Innhold
- Hva er widgets for Android?
- Trenger prosjektet mitt en applikasjonswidget?
- Widgets for Android kan forbedre brukeropplevelsen
- Kraftigere enn snarveier for applikasjoner
- Lag en Android-widget for å drive langsiktig engasjement
- Oppretter en samling-appwidget
- Bygge widgetens layout
- Populere samlewidgeten
- AppWidgetProvider: Konfigurere widgeten
- Lag adapteren
- Definere widget-livssyklusmetodene
- Henter nytt innhold med onUpdate
- onEnabled: Utfører det første oppsettet
- Rydde opp, med OnDisabled
- Den fullførte AppWidgetProvider
- AppWidgetProviderInfo-filen
- 1. android: previewImage
- 2. android: widgetCategory
- 3. android: initialLayout
- 4. android: resizeMode = ”horisontal | vertikal”
- 5. android: minHøyde og android: minBredde
- 6. android: updatePeriodMillis
- Den fullførte AppWidgetProviderInfo
- Ikke rot brukerens hjemmeskjerm!
- Sende data til widgeten
- Registrerer widgeten din i manifestet
- Sett widgeten din på prøve
- Opprette et forhåndsvisningsbilde for Android-widget
- Tilpassbare widgeter: Legger til en konfigurasjonsaktivitet
- Opprett konfigurasjonsaktivitet
- Testing av prosjektet ditt
- Innpakking
Siden de første dagene av OS har widgets for Android tillatt brukere å engasjere seg med favorittappene sine, fra komforten på hjemmeskjermen. Så hvordan lager du en Android-widget?
For utvikleren gir widgets applikasjonen din en verdifull tilstedeværelse på brukerens hjemmeskjerm. I stedet for å bli stukket utenfor syne i appskuffen, blir brukerne påminnet om appen din hver eneste gang de ser på hjemmeskjermen - samtidig som de får en forhåndsvisning av appens mest interessante og nyttige innhold.
Widgets gir applikasjonen din en verdifull tilstedeværelse på brukerens hjemmeskjerm
I denne artikkelen skal jeg vise deg hvordan du kan gi en bedre brukeropplevelse, samtidig som jeg oppfordrer brukere til å engasjere seg i appen din, ved å lage en Android-widget! På slutten av denne artikkelen vil du ha opprettet en rullbar samling-widget som viser et komplett datasett på brukerens hjemmeskjerm.
For å sikre at du leverer den typen widget som brukerne vil for å plassere på hjemmeskjermen, oppretter vi også en konfigurasjonsaktivitet, som lar brukerne tilpasse widgetens innhold, utseende og funksjoner. Til slutt skal jeg vise hvordan du kan oppmuntre folk til å bruke widgeten din, ved å lage et widget-forhåndsvisningsbilde som viser det beste som widgeten din har å tilby.
Les også: Utvikle for sammenleggbare enheter: Det du trenger å vite
Hva er widgets for Android?
En applikasjonswidget er et lite, miniatyrprogram som lever på brukerens hjemmeskjerm.
Widgets for Android kan tilby et utvalg innhold, men faller generelt inn i en av følgende kategorier:
- Informasjons widget. Dette er en ikke-rullbar widget som viser litt informasjon, for eksempel dagens værvarsel eller dato og klokkeslett.
- Samlingswidgets. Dette er en rullbar widget som viser et sett med relaterte data, formatert som ListView, GridView, StackView eller AdapterViewFlipper. Samlingswidgets er vanligvis støttet av en datakilde, for eksempel en database eller en matrise.
- Kontroll widgets. Disse widgetene fungerer som en fjernkontroll som gjør det mulig for brukere å samhandle med applikasjonen din, uten å måtte ta den i forgrunnen. Apper som spiller medier, for eksempel podcaster eller musikk, har ofte kontrollwidgets som lar brukeren utløse spill, pause og hoppe over handlinger direkte fra hjemmeskjermen.
- Hybrid widgets. Noen ganger kan du være i stand til å levere en bedre brukeropplevelse ved å kombinere elementer fra flere kategorier. For eksempel, hvis du utvikler en kontrollwidget for en musikkapplikasjon, kan du tilby Play-, Pause- og Skip-kontroller, men du kan også bestemme deg for å vise litt informasjon, for eksempel sangens tittel og artist. Hvis du bestemmer deg for å mikse og matche, så ikke bli revet med! Widgets har en tendens til å gi den beste brukeropplevelsen når de gir enkel tilgang til en liten mengde rettidig, relevant informasjon eller noen få funksjoner som ofte brukes. For å hjelpe deg med å holde dine lette hybridwidgets, anbefales det at du identifiserer widgetens primære kategori, utvikler den i henhold til den kategorien, og deretter legg til noen få elementer fra widgetens sekundære kategori.
Trenger prosjektet mitt en applikasjonswidget?
Det er flere grunner til at du bør vurdere å legge til en applikasjonswidget til Android-prosjektet ditt.
Widgets for Android kan forbedre brukeropplevelsen
Som en generell regel, jo færre navigasjonstrinn som kreves for å fullføre en oppgave, jo bedre blir brukeropplevelsen.
Ved å tilby en applikasjonswidget, kan du fjerne flere navigasjonstrinn fra appens mest brukte strømmer. I beste fall vil brukerne dine kunne få den informasjonen de trenger bare ved å kikke på hjemmeskjermen, eller utføre ønsket oppgave bare ved å trykke på en knapp i kontrollwidgeten.
Kraftigere enn snarveier for applikasjoner
Appwidgets reagerer ofte på onClick-hendelser ved å starte det øverste nivået i det tilknyttede programmet, lik en snarvei til applikasjonen. Widgets kan imidlertid også gi direkte tilgang til spesifikke aktiviteter i en applikasjon, for eksempel ved å trykke på en widget-varsel om mottatt nyhet kan det starte den tilknyttede appen med den nye som allerede er åpen.
Ved å legge inn flere koblinger i widgetens oppsett, kan du gi tilgang til alle appene dine viktigste aktiviteter med ett trykk, og fjerne enda flere navigasjonstrinn fra de mest brukte strømningene.
Ved å legge inn flere koblinger i widgetens oppsett, kan du gi tilgang til alle appene dine viktigste aktiviteter med ett trykk.
Vær oppmerksom på at widgets bare reagerer på onClick-hendelser, noe som forhindrer brukere i tilfeldig samspill med widgeten din mens de sveiper rundt på startskjermen. Det eneste unntaket er når brukeren prøver å slette widgeten din ved å dra den mot hjemmeskjermen sin Fjern handling, da i dette scenariet din widget vil svare på en vertikal sveipbevegelse.
Denne interaksjonen administreres av Android-systemet, så du trenger ikke å bekymre deg for manuelt å implementere vertikal sveipestøtte i widgeten din.
Lag en Android-widget for å drive langsiktig engasjement
Å overbevise folk om å laste ned appen din er bare det første trinnet for å lage en vellykket Android-applikasjon. Sjansen er stor, hvis du tar tak i din egen Android-smarttelefon eller -brett og sveiper gjennom app-skuffen, vil du oppdage flere apper som du ikke har brukt på dager, uker eller potensielt til og med måneder!
Les også:Komme i gang med Facebook for Android SDK
Når appen din er installert på brukerens enhet, må du jobbe hardt for å holde dem engasjert og glede deg over appen din. Å gi appen din tilstedeværelse på hjemmeskjermen kan være et kraftig verktøy for å bidra til langsiktig engasjement, ganske enkelt fordi det er en konstant påminnelse om at applikasjonen din eksisterer!
En godt designet widget kan også fungere som en pågående annonse for appen din. Hver gang brukeren ser på hjemmeskjermen, har widgeten din muligheten til å aktivt oppmuntre dem til å engasjere seg på appen din ved å presentere dem for alt appets mest interessante og nyttige innhold.
Oppretter en samling-appwidget
I denne opplæringen bygger vi en samling-widget som viser en matrise som en rullbar ListView.
For å hjelpe deg med å spore app-widgetens livssyklus, vil denne widgeten også utløse forskjellige toasts når den beveger seg gjennom de forskjellige livssyklustilstandene. Mot slutten av denne opplæringen forbedrer vi widgeten vår med et tilpasset forhåndsvisningsbilde som vises i Android's Widget Picker, og en konfigurasjonsaktivitet, som lar brukerne tilpasse widgeten før de plasseres på hjemmeskjermen.
Lag et nytt Android-prosjekt med innstillingene du velger, og la oss komme i gang!
Bygge widgetens layout
For å starte, la oss definere widgetens brukergrensesnitt (UI).
Applikasjonswidgets vises i en prosess utenfor applikasjonen din, slik at du bare kan bruke oppsett og visninger som støttes av RemoteViews.
Når du bygger oppsettet ditt, er du begrenset til følgende:
- AnalogClock
- Knapp
- kronometer
- FrameLayout
- Gridlayout
- ImageButton
- Imageview
- LinearLayout
- ProgressBar
- RelativeLayout
- TextView
- ViewStub
- AdapterViewFlipper
- Rutenett visning
- Listevisning
- StackView
- ViewFlipper
Merk at underklasser av ovennevnte klasser og visninger er ikke støttes.
Lag en ny layoutressursfil som heter list_widget.xml. Siden vi viser dataene våre ved hjelp av en ListView, fungerer denne utformingen hovedsakelig som en beholder for en Deretter må vi opprette en dataleverandør for vår ListView. Lag en ny Java-klasse som heter DataProvider.java og legg til følgende: import android.content.Context; import android.content.Intent; import android.widget.RemoteViews; import android.widget.RemoteViewsService; importer java.util.ArrayList; import java.util.List; importer statisk android.R.id.text1; importer statisk android.R.layout.simple_list_item_1; offentlig klasse DataProvider implementerer RemoteViewsService.RemoteViewsFactory {List For å opprette en Android-widget må du opprette flere filer. Den første widget-spesifikke filen vår er en AppWidgetProvider, som er en BroadcastReceiver der du definerer de forskjellige widget-livssyklusmetodene, for eksempel metoden som heter når widgeten din først opprettes og metoden som heter når den widgeten til slutt blir slettet. Opprett en ny Java-klasse (Fil> Ny> Java-klasse) med navnet CollectionWidget. For å starte, må alle widgetleverandørfiler utvides fra klassen AppWidgetProvider. Vi må da laste inn ressursfilen list_widget.xml i et RemoteViews-objekt, og informere AppWidgetManager om det oppdaterte RemoteViews-objektet: public class CollectionWidget utvider AppWidgetProvider {statisk tomromsoppdateringAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Instantiate RemoteViews-objektet // RemoteViews views = nye RemoteViews (context.getPackageName (), R.layout.list_widget; setRemoteAdapter (kontekst, visninger); // Be om at AppWidgetManager oppdaterer applikasjonswidget // appWidgetManager.updateAppWidget (appWidgetId, visninger); } Siden vi viser dataene våre i en ListView, må vi definere en setRemoteAdapter () -metode i AppWidgetProvider. SetRemoteAdapter () tilsvarer AbsListView.setRemoteViewsAdapter (), men er designet for å brukes i applikasjonswidgets. I denne metoden må vi definere IDen til AdapterView (R.id.widget_list) og intensjonen til tjenesten som til slutt vil gi dataene til RemoteViews Adapter - vi oppretter denne WidgetService-klassen om kort tid. privat statisk tomrom setRemoteAdapter (Kontekstkontekst, @NonNull endelige RemoteViews-visninger) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} I AppWidgetProvider må vi også definere følgende widget-livssyklusmetoder: Metoden onUpdate () -livssyklusmetoden er ansvarlig for å oppdatere widgetens visninger med ny informasjon. Denne metoden kalles hver gang: Det er også her du registrerer eventhåndterere som widgeten din skal bruke. Når du oppdaterer en Android-widget, er det viktig å huske at brukere kan opprette flere forekomster av den samme widgeten. For eksempel kan widgeten din tilpasses, og brukeren bestemmer seg for å lage flere "versjoner" som viser forskjellig informasjon, eller gir tilgang til unik funksjonalitet. Når du ringer onUpdate (), må du spesifisere om du vil oppdatere hver forekomst av denne widgeten, eller bare en bestemt forekomst. Hvis du vil oppdatere alle forekomster, kan du bruke appWidgetIds, som er en rekke ID-er som identifiserer alle forekomster på tvers av enheten. I følgende tekstutdrag oppdaterer jeg alle forekomster: @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Oppdater alle forekomster av denne widgeten / updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (kontekst, appWidgetManager, appWidgetIds); } Merk at for å holde koden grei, gjør denne onUpdate () metoden for øyeblikket ingen endringer i widgeten. Livssyklusmetoden onEnabled () kalles som svar på ACTION_APPWIDGET_ENABLED, som sendes når en forekomst av widgeten din legges til startskjermen for først tid. Hvis brukeren oppretter to forekomster av widgeten din, vil onEnabled () bli kalt for første gang, men ikke for andre. Livssyklusmetoden onEnabled () er der du skal utføre et hvilket som helst oppsett som er nødvendig for alle forekomster av widgeten din, for eksempel å opprette databasen som vil mate widget-informasjonen din. Jeg skal vise en skål, så du kan se nøyaktig når denne livssyklusmetoden heter: @Override offentlig tomrom onEnabled (Kontekstkontekst) {Toast.makeText (kontekst, "onEnabled called", Toast.LENGTH_LONG) .show (); } Merk at hvis brukeren sletter alle forekomster av widgeten din og deretter oppretter en ny forekomst, klassifiseres dette som første forekomst, og livssyklusmetoden onEnabled () vil bli kalt igjen. OnDisabled () -metoden kalles som svar på ACTION_APPWIDGET_DISABLED, som utløses når brukeren sletter siste forekomst av widgeten. Denne widgetens livssyklusmetode er der du bør rydde opp ressursene du opprettet i metoden onEnabled (), for eksempel å slette databasen du opprettet i onEnabled (). For å hjelpe med å holde koden vår grei, viser jeg bare en skål hver gang denne metoden utløses: @Override public void onDisabled (Kontekstkontekst) {Toast.makeText (kontekst, "onDisabled called", Toast.LENGTH_LONG) .show (); } CollectionWidget-filen din skal nå se slik ut: import android.appwidget.AppWidgetManager; import android.appwidget.AppWidgetProvider; import android.content.Context; import androidx.annotation.NonNull; import android.content.Intent; import android.widget.RemoteViews; import android.widget.Toast; // Utvide fra AppWidgetProvider-klassen // public class CollectionWidget utvider AppWidgetProvider {statisk tomoppdateringAppWidget (Kontekstkontekst, AppWidgetManager appWidgetManager, int appWidgetId) {// Last inn ressursfilen i et RemoteViews-objekt // RemoteViews-visninger = ny RemoteViews-kontekst. getPackageName (), R.layout.list_widget); setRemoteAdapter (kontekst, visninger); // Informer AppWidgetManager om RemoteViews-objektet // appWidgetManager.updateAppWidget (appWidgetId, visninger); } @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (kontekst, appWidgetManager, appWidgetIds); } @Overrid offentlig tomrom onEnabled (Kontekstkontekst) {Toast.makeText (kontekst, "onEnabled heter", Toast.LENGTH_LONG) .show (); } @Override offentlig tomrom onDisabled (Kontekstkontekst) {Toast.makeText (kontekst, "onDisabled called", Toast.LENGTH_LONG) .show (); } privat statisk tomrom setRemoteAdapter (Kontekstkontekst, @NonNull endelige RemoteViews-visninger) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} Applikasjonswidgeten din krever også en AppWidgetProviderInfo-fil, som definerer flere viktige egenskaper, inkludert widgetens minimale dimensjoner og hvor ofte den skal oppdateres. AppWidgetProviderInfo-filen er lagret i prosjektets res / xml-mappe. Hvis prosjektet ditt ikke allerede inneholder denne mappen, må du opprette den: Deretter oppretter du en samling_widget_info-fil, som vi bruker som AppWidgetProviderInfo: I AppWidgetProviderInfo-filen vår, må vi definere følgende egenskaper: Dette er tegnet som representerer applikasjonswidgeten din i enhetens widgetvelger.Populere samlewidgeten
AppWidgetProvider: Konfigurere widgeten
Lag adapteren
Definere widget-livssyklusmetodene
Henter nytt innhold med onUpdate
onEnabled: Utfører det første oppsettet
Rydde opp, med OnDisabled
Den fullførte AppWidgetProvider
AppWidgetProviderInfo-filen
1. android: previewImage
Hvis du ikke gir et previewImage, bruker Android ikonet for applikasjonen i stedet. For å oppmuntre brukere til å velge widgeten din fra widgetvelgeren, må du oppgi en tegning som viser hvordan widgeten din vil se ut når den er riktig konfigurert på brukerens hjemmeskjerm.
Den enkleste måten å lage et forhåndsvisningsbilde på, er å bruke Widget Preview-applikasjonen som er inkludert i Android-emulatoren. Denne appen lar deg konfigurere widgeten din og deretter generere et bilde, som du deretter kan bruke i Android-prosjektet ditt.
Vi lager dette bildet når vi er ferdig med å bygge widgeten vår, så for nå skal jeg bruke den automatisk genererte mipmap / ic_launcher-ressursen som et midlertidig forhåndsvisningsbilde.
2. android: widgetCategory
Applikasjonswidgets må plasseres i en App Widget Host, som vanligvis er aksjesiden for Android-skjermen, men kan også være en tredjepartsstarter som Evie Launcher eller Nova Launcher.
Mellom API-nivå 17 og 20 var det mulig å plassere applikasjonswidgets på startskjermen eller låseskjermen, men støtte for låseskjerm ble avskrevet i API-nivå 21.
Du kan spesifisere om appwidgeten din kan plasseres på startskjermen, låseskjermen (som Android refererer til som "tastaturet") eller begge deler ved å bruke attributtet android: widgetCategory. Siden det ikke er mulig å plassere widgets på låseskjermen i de nyeste versjonene av Android, målretter vi bare hjemmeskjermen.
For å bevare brukerens personvern, skal ikke widgeten din vise sensitiv eller privat informasjon når den er plassert på låseskjermen.
Hvis du gir brukerne muligheten til å plassere widgeten din på låseskjermen, kan alle som ser på brukerens enhet potensielt se widgeten din og alt innholdet. For å bevare brukerens personvern, skal widgeten din ikke vise sensitiv eller privat informasjon når den er plassert på låseskjermen. Hvis widgeten din inneholder personopplysninger, kan det være lurt å vurdere å opprette separate hjemmeskjerm- og låseskjermoppsett.
3. android: initialLayout
Dette er layout-ressursfilen som widgeten din skal bruke når den plasseres på hjemmeskjermen, som for prosjektet vårt er list_widget.xml.
4. android: resizeMode = ”horisontal | vertikal”
Android: resizeMode-attributtet lar deg spesifisere om widgeten din kan endres størrelse horisontalt, vertikalt eller langs begge aksene.
For å sikre at widgeten din vises og fungerer riktig på tvers av en rekke skjermer, anbefales det at du lar størrelsen på widgeten din være horisontalt og vertikalt, med mindre du har en spesifikk grunn til ikke å gjøre det.
5. android: minHøyde og android: minBredde
Hvis widgeten din kan endre størrelse, må du forsikre deg om at brukeren ikke krymper widgeten til det punktet der den blir ubrukelig. Du kan bruke minHøyden og minBredde-attributtene for å definere den minste appen din vil krympe når den endres av brukeren.
Disse verdiene representerer også widgetens opprinnelige størrelse, så hvis widgeten ikke kan endres størrelse, vil minHøyde og minBredde definere widgetens permanente størrelse.
6. android: updatePeriodMillis
AppWidgetProviderInfo er også der du vil angi hvor ofte widgeten din skal be om ny informasjon.
Det minste støtteapparatet som støttes, er en gang hver 1800000 millisekund (30 minutter). Selv om du erklærer et kortere oppdateringsintervall, vil widgeten din fortsatt bare oppdatere en gang hver halvtime.
Selv om det kan være lurt å vise den nyeste informasjonen så raskt som mulig, er systemet vil vekke en sovende enhet for å hente ny informasjon. Hyppige oppdateringer kan brenne gjennom enhetens batteri, spesielt i perioder der enheten er inaktiv i en betydelig periode, for eksempel over natten. Å gi en best mulig brukeropplevelse betyr å oppnå en balanse mellom å begrense batteriforbruket og gi ny informasjon innen rimelig tid.
Du bør også ta hensyn til hva slags innhold widgeten din vil vise.
Du bør også ta hensyn til hva slags innhold widgets for Android vil vise. For eksempel kan det hende at en vær-widget bare trenger å hente en oppdatert prognose en gang per dag, mens en app som viser nyheter, må oppdateres oftere.
For å finne denne perfekte balansen, kan det hende du må teste widgeten din over en rekke oppdateringsfrekvenser og måle innvirkningen på batteriets levetid og aktualiteten til widgetens innhold. Hvis du har en villig gruppe testere, kan du til og med konfigurere A / B-testing for å se om noen oppdateringsfrekvenser mottas mer positivt enn andre.
Les også: AndroidManifest.xml alt du trenger å vite
Til slutt, når du har identifisert det perfekte oppdateringsintervallet, kan det være lurt å bruke et kortere intervall når du utvikler og tester appen din. For eksempel kan du bruke kortest mulig oppdateringsfrekvens (android: updatePeriodMillis = ”1800000 ″) når du tester at appens onUpdate () -metode utløses riktig, og deretter endre denne verdien før du slipper appen din for allmennheten.
Den fullførte AppWidgetProviderInfo
Den ferdige collection_widget_info.xml-filen skal se slik ut:
Ikke rot brukerens hjemmeskjerm!
For å sikre at startskjermen aldri blir rotet, vil vi legge til noe polstring og marginer i widgeten vår. Hvis prosjektet ikke allerede inneholder en dimens.xml-fil, må du opprette en:
- Kontrollklikk på prosjektets verdimappe.
- Velg Ny> Verdier ressursfil.
- Gi denne filen navnet dimensjon.
- Klikk OK.
Åpne dimens.xml-filen og definer følgende marge- og polstringverdier:
Sende data til widgeten
Deretter må vi opprette en widget-tjeneste, som vil være ansvarlig for å sende innsamlingsdataene våre til widgeten.
Opprett en ny Java-klasse (Ny> Java-klasse) med navnet WidgetService, og legg til følgende:
import android.content.Intent; import android.widget.RemoteViewsService; public class WidgetService utvider RemoteViewsService {@Override public RemoteViewsFactory onGetViewFactory (Intent intention) {return new DataProvider (this, intention); }}
Registrerer widgeten din i manifestet
Vi må nå gjøre noen endringer i prosjektets manifest.
For å starte, åpner du Manifestet og registrerer widgeten din som BroadcastReceiver. Vi må også legge til et intensjonsfilter for android.appwidget.action.APPWIDGET_UPDATE-handlingen:
Deretter må du spesifisere leverandøren av appwidgets:
Til slutt må vi erklære tjenesten som vil sende data til widgeten vår, som i dette tilfellet er WidgetService-klassen. Denne tjenesten krever tillatelse android.permission.BIND_REMOTEVIEWS:
Sett widgeten din på prøve
Hvis du har fulgt med i denne opplæringen, vil du nå ha en komplett samling-widget som viser et sett med data på brukerens hjemmeskjerm.
Hvis dette var et ekte Android-prosjekt, vil du vanligvis utvide livssyklusmetodene, spesielt onUpdate () -metoden, men dette er alt vi trenger for å lage en widget som du kan installere og teste på Android-enheten din:
- Installer dette prosjektet på en kompatibel Android-smarttelefon, nettbrett eller AVD (Android Virtual Device).
- Trykk lenge på en hvilken som helst tom del av startskjermen, og velg Widgets når du blir bedt om det; dette lanserer widgetvelgeren.
- Sveip gjennom widgetvelgeren til du finner applikasjonswidgeten du nettopp opprettet.
- Trykk lenge på denne widgeten for å legge den til på hjemmeskjermen.
- Siden dette er den første forekomsten av denne spesifikke widgeten, skal onEnabled () -metoden kjøres, og du vil se en “onEnabled called” toast.
- Endre størrelse på widgeten. Hvis du angir en minimumstøttet størrelse, kontrollerer du at du ikke kan krympe widgeten forbi denne verdien.
- Test at ListView ruller som forventet.
- Deretter bør du sjekke metoden onDisabled () ved å slette widgeten. Trykk lenge på widgeten, og velg deretter Fjern fra startskjermbildet. Siden dette er den siste forekomsten av denne spesifikke widgeten, skal onDisabled () -metoden kjøres, og du vil se en “onDisabled called” toast.
Dette er alt du trenger for å levere en fungerende Android-applikasjonswidget, men det er noen få tillegg som ofte kan forbedre brukeropplevelsen. I de følgende seksjoner vil vi oppfordre brukere til å velge denne widgeten fra widgetvelgeren ved å lage et forhåndsvisningsbilde som viser widgeten på sitt beste. Jeg viser deg hvordan du oppretter en widget som kan tilpasses fullt ut, ved å legge til en konfigurasjonsaktivitet til prosjektet ditt.
Opprette et forhåndsvisningsbilde for Android-widget
Hvis du tar tak i Android-enheten din og sveiper gjennom widgetvelgeren, vil du se at hver widget er representert av et bilde, noe som vanligvis viser hvordan denne widgeten vil se ut når den er konfigurert på brukerens hjemmeskjerm.
For å oppmuntre brukere til å velge widgeten din, bør du gi et forhåndsvisningsbilde som fremhever all nyttig informasjon og funksjoner som widgeten din har å tilby.
Du kan raskt og enkelt opprette et forhåndsvisningsbilde ved å bruke Widget Preview-applikasjonen som er inkludert i Android-emulatoren.
Vær oppmerksom på at widgetforhåndsvisning ikke er inkludert i de nyeste Android-systembildene, så du må opprette en AVD ved å bruke Nougat (API-nivå 25) eller tidligere:
- Installer applikasjonen din på en AVD som kjører API 25 eller lavere.
- Åpne AVDs appskuff, og start appen Widget Preview.
- Forhåndsvisning av widgeten vil vise en liste over alle applikasjoner som for øyeblikket er installert på denne AVD; Velg søknaden din fra listen.
- Din widget vises nå på en blank bakgrunn. Bruk litt tid på å endre størrelse på og finpusse widgeten din til den viser det beste som widgeten din har å tilby.
- Når du er fornøyd med widgetens utseende og innhold, velger du Ta stillbilde.
- For å hente stillbildet ditt, bytter du tilbake til Android Studio og velger Vis> Verktøy Windows> Enhetsfilutforsker fra verktøylinjen. Dette lanserer Android Studios Device File Explorer.
- Naviger til sdcard / Download i enhetsfilutforskeren. Du bør finne forhåndsvisningsbildet ditt som er lagret i følgende format: _ori_.png
- Dra dette bildet ut av Android Studio og slipp det et sted lett tilgjengelig, for eksempel skrivebordet.
- Gi denne bildefilen et beskrivende navn.
- Dra og slipp filen til prosjektets tegnbare mappe.
- Åpne AppWidgetProviderInfo, som for dette prosjektet er collection_widget_info.xml.
- Finn linjen android: previewImage = ”@ mipmap / ic_launcher” og oppdater den for å referere til forhåndsvisningsbildet.
Din widget vil nå bruke denne nye bildressursen som forhåndsvisningsbilde:
- Installer det oppdaterte prosjektet på din fysiske Android-enhet eller AVD.
- Trykk lenge på en hvilken som helst tom del av startskjermen.
- Trykk på Widgets, som starter widgetvelgeren.
- Bla til widgeten din; den skal nå bruke det oppdaterte forhåndsvisningsbildet.
Tilpassbare widgeter: Legger til en konfigurasjonsaktivitet
En konfigurasjonsaktivitet starter automatisk når brukeren plasserer hver forekomst av widgeten på hjemmeskjermen.
Det er flere grunner til at du kanskje vil legge til en konfigurasjonsaktivitet til prosjektet ditt.
widgets pleier å gi den beste brukeropplevelsen når de gir tilgang til informasjonen eller funksjonene som er viktigst for den enkelte bruker.
For det første krever noen widgeter første oppsett, for eksempel en widget som viser trafikkvarsler, kanskje trenger brukerens hjemmeadresse, hvor de jobber og tidspunktene de vanligvis pendler. Uten noen måte å legge inn denne informasjonen kan widgeten din være helt ubrukelig!
I tillegg har widgets en tendens til å gi den beste brukeropplevelsen når de gir tilgang til informasjonen eller funksjonene som er viktigst for den enkelte bruker. Ved å legge til en konfigurasjonsaktivitet til prosjektet ditt, kan du gi brukerne frihet til å velge og velge nøyaktig hva som er inkludert i widgeten din.
Til og med relativt enkle tilpasninger, for eksempel å endre en widgets bakgrunn eller font, kan ha en positiv innvirkning på brukeropplevelsen - tross alt er det ingen som vil sette pris på en widget som visuelt blir sammenstøt med resten av hjemmeskjermen!
Ingen kommer til å sette pris på en widget som visuelt blir sammenstøt med resten av hjemmeskjermen!
Alternativt kan det hende at du noen ganger har en lang liste med innhold du vil inkludere i widgeten din, og du sliter med å begrense alternativene. En konfigurasjonsaktivitet kan være en måte å bruke alle ideene dine til god bruk uten skaper en rotete, forvirrende widget. Bare husk at konfigurering av en widget ikke ikke skal føles som en oppgave, så hvis du gir en konfigurasjonsaktivitet, anbefales det at du begrenser deg til tre konfigurasjonsalternativer.
La oss legge til en konfigurasjonsaktivitet til prosjektet vårt!
For det første trenger konfigurasjonsaktiviteten vår en layout, så lag en ny layoutressurfil med navnet config_activity.xml.
Jeg skal legge til følgende knapper i denne oppsettet:
- En konfigurasjonsknapp. I et ekte prosjekt, vil denne knappen endre widgeten på en eller annen måte, for eksempel å legge til eller fjerne innhold, eller endre hvor ofte widgeten oppdateres. For å hjelpe oss med å holde koden vår grei, klikker du på denne knappen bare en toast for konfigurasjonsalternativer.
- En oppsett-knapp. Når brukeren er fornøyd med hvordan widgeten deres er konfigurert, vil du trykke på denne knappen plassere den nylig konfigurerte widgeten på startskjermen.
Her er min fullførte config_activity.xml-fil:
Opprett konfigurasjonsaktivitet
Nå må vi opprette konfigurasjonsaktiviteten vår.
For å starte oppretter du en ny Java-klasse som heter ConfigActivity. I denne aktiviteten skal vi hente app-widget-IDen fra hensikten som lanserte konfigurasjonsaktiviteten. Hvis denne hensikten ikke har en widget-ID, må vi kalle finish () -metoden:
Intent intention = getIntent (); Pakketilbehør = intention.getExtras (); if (statister! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Deretter må vi opprette en returintensjon, passere den opprinnelige appWidgetId og angi resultatene fra konfigurasjonsaktiviteten:
Intensjonsresultat Verdi = nytt Hensikt (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); bli ferdig(); }}}
Hvis du oppgir en konfigurasjonsaktivitet, sendes ikke sendingen ACTION_APPWIDGET_UPDATE automatisk når konfigurasjonsaktiviteten startes, noe som betyr metoden onUpdate () vil ikke ringes når brukeren oppretter en forekomst av widgeten din.
Konfigurasjonsaktivitet for å sikre at widgeten din er opprettet med oppdatert informasjon og innhold må utløse den første onUpdate () -forespørselen.
Her er den fullførte ConfigActivity:
import android.app.Aktivitet; import android.appwidget.AppWidgetManager; import android.os.Bundle; import android.widget.Button; import android.content.Intent; import android.view.View; import android.view.View.OnClickListener; import android.widget.Toast; public class ConfigActivity utvider aktivitet {@Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Button setupWidget = (Button) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (ny OnClickListener () {@Override public void onClick (View v) {handleSetupWidget ();}}); Button configButton = (Button) findViewById (R.id.configButton); configButton.setOnClickListener (ny OnClickListener () {@Override public void onClick (View v) {handleConfigWidget ();}}); } private void handleSetupWidget () {showAppWidget (); } private void handleConfigWidget () {Toast.makeText (ConfigActivity.this, "Konfigurasjonsalternativer", Toast.LENGTH_LONG) .show (); } int appWidgetId; private void showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Intent intention = getIntent (); Pakketilbehør = intention.getExtras (); if (statister! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // TO DO: Utfør konfigurasjonen // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); bli ferdig(); }}}
Når du har opprettet en konfigurasjonsaktivitet, må du erklære denne aktiviteten i manifestet og spesifisere at den godtar handlingen APPWIDGET_CONFIGURE:
Til slutt, siden det refereres til en konfigurasjonsaktivitet utenfor pakkeomfanget, må vi erklære denne aktiviteten i AppWidgetProviderInfo, som i dette tilfellet er filen collection_widget_info.xml:
android: configure = "com.jessicathornsby.collectionwidget.ConfigActivity">
Testing av prosjektet ditt
Nå er det på tide å sette det ferdige prosjektet på prøve:
- Installer det oppdaterte prosjektet på en fysisk Android-enhet eller AVD.
- Slett alle tidligere forekomster av widgeten din, for å sikre at du jobber med den aller nyeste versjonen.
- Trykk lenge på et hvilket som helst tomt område på startskjermen, og velg Widgets når du blir bedt om det.
- Finn widgeten din i widgetvelgeren og trykk lenge for å velge den.
- Slipp widgeten på startskjermen. Konfigurasjonsaktiviteten skal starte automatisk.
- Gi knappen Utfør en konfigurasjon et klikk, og en toast for konfigurasjonsalternativer skal vises for å bekrefte at denne interaksjonen er registrert.
- Se for deg at du har justert widgetens innstillinger og nå er klar til å plassere den på startskjermen. gi knappen Lag widgeten et trykk, og denne widgeten skal opprettes.
Du kan laste ned det ferdige samlingswidget-prosjektet fra GitHub.
Innpakking
I denne artikkelen opprettet vi en rullbar samling-widget som viser et datasett på brukerens hjemmeskjerm.
Hvis du vil fortsette å jobbe med dette prosjektet, kan du prøve å legge til din egen kode til metoden onUpdate (), for å lage en widget som oppdateres med ny informasjon i intervallet som er definert i AppWidgetProviderInfo-filen (collection_widget_info).
Hvis du oppretter en Android-widget, må du huske å dele kreasjonene dine i kommentarfeltet nedenfor!
