Innehåll
- Vad är widgetar för Android?
- Behöver mitt projekt verkligen en applikationswidget?
- Widgets för Android kan förbättra användarupplevelsen
- Kraftigare än genvägar för applikationer
- Skapa en Android-widget för att driva långsiktigt engagemang
- Skapa en widget-samling för app
- Bygg din widgets layout
- Befolkning av samlingswidget
- AppWidgetProvider: Konfigurera din widget
- Skapa adaptern
- Definiera widgetens livscykelmetoder
- Hämtar nytt innehåll med onUpdate
- onEnabled: Utför den första installationen
- Städning, med OnDisabled
- Den färdiga AppWidgetProvider
- AppWidgetProviderInfo-filen
- 1. android: previewImage
- 2. android: widgetCategory
- 3. android: initialLayout
- 4. android: resizeMode = ”horisontell | vertikal”
- 5. android: minHöjd och android: minBredd
- 6. android: updatePeriodMillis
- Den färdiga AppWidgetProviderInfo
- Skräp inte användarens hemmaskärm!
- Skicka data till widgeten
- Registrera din widget i manifestet
- Sätt din widget på testet
- Skapa en förhandsgranskningsbild för Android-widget
- Anpassningsbara widgetar: Lägga till en konfigurationsaktivitet
- Skapa konfigurationsaktivitet
- Testa ditt projekt
- Avslutar
Sedan OS: s tidiga dagar har widgets för Android gjort det möjligt för användare att engagera sig med sina favoritappar, från bekvämligheten på sin hemskärm. Så hur skapar du en Android-widget?
För utvecklaren ger widgets din applikation en värdefull närvaro på användarens hemmaskärm. Istället för att bli undangömt i appens låda kommer användarna att påminnas om din app varje gång de tittar på sin hemskärm - samtidigt som de får en förhandsgranskning av din apps mest intressanta och användbara innehåll.
Widgets ger din applikation en värdefull närvaro på användarens hemmaskärm
I den här artikeln visar jag dig hur du kan ge en bättre användarupplevelse samtidigt som jag uppmuntrar användare att engagera sig i din app genom att skapa en Android-widget! I slutet av den här artikeln har du skapat en rullbar samlingswidget som visar en komplett datauppsättning på användarens startsida.
För att säkerställa att du levererar den typ av widget som användarna har vilja för att placera på sin hemskärm skapar vi också en konfigurationsaktivitet som gör det möjligt för användare att anpassa widgetens innehåll, utseende och funktioner. Slutligen kommer jag att visa hur du kan uppmuntra människor att använda din widget genom att skapa en widget-förhandsvisningsbild som visar det bästa som din widget har att erbjuda.
Läs också: Utveckling för fällbara enheter: Vad du behöver veta
Vad är widgetar för Android?
En applikationswidget är en lätt, miniatyrapplikation som lever på användarens hemskärm.
Widgets för Android kan tillhandahålla en rad innehåll, men omfattas vanligtvis av en av följande kategorier:
- Informationswidget. Detta är en icke-rullbar widget som visar viss information, till exempel dagens väderprognos eller datum och tid.
- Samling widgets. Detta är en rullbar widget som visar en uppsättning relaterade data, formaterade som ListView, GridView, StackView eller AdapterViewFlipper. Samlingswidgets stöds vanligtvis av en datakälla, till exempel en databas eller en array.
- Kontrollera widgetar. Dessa widgetar fungerar som en fjärrkontroll som gör det möjligt för användare att interagera med din applikation, utan att behöva ta det i förgrunden. Appar som spelar media, till exempel podcast eller musik, har ofta kontrollwidgets som gör det möjligt för användaren att aktivera Spela, pausa och hoppa över åtgärder direkt från sin hemskärm.
- Hybridwidgets. Ibland kan du kunna leverera en bättre användarupplevelse genom att kombinera element från flera kategorier. Om du till exempel utvecklar en kontrollwidget för en musikapplikation kan du tillhandahålla Spela, pausa och hoppa över kontroller, men du kan också välja att visa lite information, till exempel låtens titel och artist. Om du bestämmer dig för att blanda och matcha, får du inte bli med! Widgets tenderar att ge den bästa användarupplevelsen när de ger enkel åtkomst till en liten mängd aktuell, relevant information eller några vanliga funktioner. För att hålla dina hybridwidgets lätta, rekommenderas det att du identifierar widgetens primära kategori, utvecklar den enligt den kategorin och sedan lägg till några element från widgetens sekundära kategori.
Behöver mitt projekt verkligen en applikationswidget?
Det finns flera skäl till varför du bör överväga att lägga till en applikationswidget till ditt Android-projekt.
Widgets för Android kan förbättra användarupplevelsen
Som en allmän regel, ju färre navigationssteg som krävs för att slutföra en uppgift, desto bättre blir användarupplevelsen.
Genom att tillhandahålla en applikationswidget kan du ta bort flera navigeringssteg från appens mest använda flöden. I bästa fall kan dina användare få informationen de behöver bara genom att titta på sin hemskärm eller utföra önskad uppgift genom att bara trycka på en knapp i din kontrollwidget.
Kraftigare än genvägar för applikationer
Appwidgets svarar ofta på onClick-händelser genom att starta den översta nivån i den tillhörande applikationen, liknande en applikationsgenväg. Widgets kan emellertid också ge direkt tillgång till specifika aktiviteter i en applikation, till exempel genom att knacka på en widget-meddelande om ny mottagning kan det starta den tillhörande appen med den nya som redan är öppen.
Genom att bädda in flera länkar i widgetens layout kan du ge tillgång till alla dina apps viktigaste aktiviteter med en knapptryckning och ta bort ännu fler navigationssteg från dina flöden som oftast används.
Genom att bädda in flera länkar i widgetens layout kan du ge tillgång till alla dina apps viktigaste aktiviteter med en knapptryckning.
Observera att widgets endast svarar på onClick-händelser, vilket förhindrar användare från att av misstag interagera med din widget medan de sveper runt hemskärmen. Det enda undantaget är när användaren försöker ta bort din widget genom att dra den mot hemskärmens åtgärd Ta bort, eftersom i det här scenariot kommer din widget att svara på en vertikal svepgest.
Denna interaktion hanteras av Android-systemet, så du behöver inte oroa dig för att manuellt implementera vertikalt svepstöd i din widget.
Skapa en Android-widget för att driva långsiktigt engagemang
Att övertyga människor att ladda ner din app är bara det första steget för att skapa en framgångsrik Android-applikation. Chansen är att om du tar tag i din egen Android-smartphone eller surfplatta och sveper genom app-lådan kommer du att upptäcka flera appar som du inte har använt på dagar, veckor eller eventuellt månader!
Läs också:Komma igång med Facebook för Android SDK
När din app har installerats på användarens enhet måste du arbeta hårt för att hålla dem engagerade och njuta av din app. Att ge din app närvaro på hemskärmen kan vara ett kraftfullt verktyg för att driva långsiktigt engagemang, helt enkelt för att det är en konstant påminnelse om att din applikation finns!
En väldesignad widget kan också fungera som en pågående annons för din app. Varje gång användaren tittar på sin hemskärm har din widget möjlighet att aktivt uppmuntra dem att engagera sig igenom din app genom att presentera dem för allt appens mest intressanta och användbara innehåll.
Skapa en widget-samling för app
I den här handledningen bygger vi en samlingwidget som visar en matris som en rullbar ListView.
För att hjälpa dig spåra app-widgetens livscykel utlöser denna widget också olika toasts när den rör sig genom olika livscykelstatus. Mot slutet av denna självstudie kommer vi att förbättra vår widget med en anpassad förhandsvisningsbild som kommer att visas i Android: s widgetväljare och en konfigurationsaktivitet, som gör det möjligt för användare att anpassa widgeten innan de placeras på sin hemskärm.
Skapa ett nytt Android-projekt med dina inställningar och låt oss komma igång!
Bygg din widgets layout
För att starta, låt oss definiera widgetens användargränssnitt (UI).
Applikationswidgets visas i en process utanför din applikation, så att du bara kan använda layouter och vyer som stöds av RemoteViews.
När du bygger din layout är du begränsad till följande:
- Analog
- Knapp
- krono~~POS=TRUNC
- FrameLayout
- Rutnätslayout
- ImageButton
- Imageview
- Linear
- ProgressBar
- RelativeLayout
- Textview
- ViewStub
- AdapterViewFlipper
- Gridview
- Listvy
- StackView
- ViewFlipper
Observera att underklasser av ovanstående klasser och vyer är inte stöds.
Skapa en ny layoutresursfil med namnet list_widget.xml. Eftersom vi visar våra data med hjälp av en ListView, fungerar denna layout huvudsakligen som en behållare för en Därefter måste vi skapa en dataleverantör för vår ListView. Skapa en ny Java-klass med namnet DataProvider.java och lägg till följande: import android.content.Context; import android.content.Intent; import android.widget.RemoteViews; import android.widget.RemoteViewsService; importera java.util.ArrayList; importera java.util.List; importera statisk android.R.id.text1; importera statisk android.R.layout.simple_list_item_1; public class DataProvider implementerar RemoteViewsService.RemoteViewsFactory {List För att skapa en Android-widget måste du skapa flera filer. Vår första widgetspecifika fil är en AppWidgetProvider, som är en BroadcastReceiver där du definierar olika widget-livscykelmetoder, till exempel den metod som heter när din widget först skapas och metoden som kallas när den widgeten så småningom raderas. Skapa en ny Java-klass (File> New> Java Class) med namnet CollectionWidget. För att starta måste alla widgetleverantörsfiler sträcka sig från klassen AppWidgetProvider. Vi måste sedan ladda list-resursfilen list_widget.xml i ett RemoteViews-objekt och informera AppWidgetManager om det uppdaterade RemoteViews-objektet: public class CollectionWidget utökar AppWidgetProvider {statisk void updateAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Instantiate RemoteViews object // RemoteViews views = new RemoteViews (context.getPackageName (), R.layout.list_widget; setRemoteAdapter (sammanhang, vyer); // Begär att AppWidgetManager uppdaterar applikationswidget // appWidgetManager.updateAppWidget (appWidgetId, visningar); } Eftersom vi visar våra data i en ListView måste vi definiera en setRemoteAdapter-metod i vår AppWidgetProvider. SetRemoteAdapter () motsvarar AbsListView.setRemoteViewsAdapter () men är utformad för att användas i applikationswidgets. I den här metoden måste vi definiera ID för AdapterView (R.id.widget_list) och avsikten med tjänsten som så småningom kommer att tillhandahålla informationen till vår RemoteViews Adapter - vi skapar denna widgetService-klass inom kort. privata statiska tomrum setRemoteAdapter (Context context, @NonNull slutliga RemoteViews-visningar) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} I vår AppWidgetProvider måste vi också definiera följande widget-livscykelmetoder: Metoden onUpdate () -livscykelns livscykel är ansvarig för att uppdatera widgetens vyer med ny information. Denna metod kallas varje gång: Det är också här du registrerar alla eventhanterare som din widget ska använda. När du uppdaterar en Android-widget är det viktigt att komma ihåg att användare kan skapa flera instanser av samma widget. Till exempel kanske din widget kan anpassas och användaren beslutar att skapa flera "versioner" som visar olika information eller ger tillgång till unik funktionalitet. När du ringer onUpdate () måste du ange om du ska uppdatera varje instans av den här widgeten eller endast en specifik instans. Om du vill uppdatera varje instans kan du använda appWidgetIds, som är en rad ID som identifierar varje instans över enheten. I följande utdrag uppdaterar jag varje instans: @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Uppdatera alla instanser av den här widgeten // updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (context, appWidgetManager, appWidgetIds); } Observera att denna onUpdate () -metod för närvarande inte gör några ändringar av widgeten för att hjälpa till att hålla koden enkel. Livscykelmetoden onEnabled () kallas som svar på ACTION_APPWIDGET_ENABLED, som skickas när en instans av din widget läggs till på hemskärmen för först tid. Om användaren skapar två instanser av din widget, kommer OnEnabled () att kallas för första instansen, men inte för den andra. Livscykelmetoden onEnabled () är där du ska utföra alla inställningar som krävs för alla instanser av din widget, till exempel att skapa databasen som kommer att mata din widgetinformation. Jag kommer att visa en skål, så du kan se exakt när den här livscykelmetoden heter: @Override public void onEnabled (Context context) {Toast.makeText (context, "onEnabled called", Toast.LENGTH_LONG) .show (); } Observera att om användaren tar bort alla instanser av din widget och sedan skapar en ny instans, klassificeras detta som första instans och livscykelmetoden onEnabled () kommer att kallas igen. Metoden onDisabled () kallas som svar på ACTION_APPWIDGET_DISABLED, som utlöses när användaren raderar sista exempel på din widget. Denna widget-livscykelmetod är där du ska rensa alla resurser du skapade i metoden onEnabled (), till exempel att ta bort databasen du skapade i onEnabled (). För att hjälpa till att hålla vår kod okomplicerad kommer jag helt enkelt att visa en rostat bröd varje gång denna metod utlöses: @Override public void onDisabled (Context context) {Toast.makeText (context, "onDisabled called", Toast.LENGTH_LONG) .show (); } Din CollectionWidget-fil ska nu se ut så här: importera android.appwidget.AppWidgetManager; importera android.appwidget.AppWidgetProvider; import android.content.Context; import androidx.annotation.NonNull; import android.content.Intent; import android.widget.RemoteViews; import android.widget.Toast; // Utöka från AppWidgetProvider-klassen // public class CollectionWidget utökar AppWidgetProvider {statisk void updateAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Ladda layoutresursfilen i ett RemoteViews-objekt // RemoteViews-vyer = nytt RemoteViews-sammanhang. getPackageName (), R.layout.list_widget); setRemoteAdapter (sammanhang, vyer); // Informera AppWidgetManager om RemoteViews-objektet // appWidgetManager.updateAppWidget (appWidgetId, visningar); } @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (context, appWidgetManager, appWidgetIds); } @Override public void onEnabled (Context context) {Toast.makeText (context, "onEnabled called", Toast.LENGTH_LONG) .show (); } @Override public void onDisabled (Context context) {Toast.makeText (context, "onDisabled called", Toast.LENGTH_LONG) .show (); } privata statiska tomrum setRemoteAdapter (Contexttext, @NonNull slutliga RemoteViews-visningar) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} Din applikationswidget kräver också en AppWidgetProviderInfo-fil, som definierar flera viktiga egenskaper, inklusive min widgets minimimått och hur ofta den ska uppdateras. AppWidgetProviderInfo-filen lagras i projektets res / xml-mapp. Om ditt projekt inte redan innehåller den här mappen, måste du skapa den: Skapa sedan en collection_widget_info-fil, som vi kommer att använda som vår AppWidgetProviderInfo: I vår AppWidgetProviderInfo-fil måste vi definiera följande egenskaper: Detta är det dragbara som representerar din applikationswidget i enhetens widgetväljare.Befolkning av samlingswidget
AppWidgetProvider: Konfigurera din widget
Skapa adaptern
Definiera widgetens livscykelmetoder
Hämtar nytt innehåll med onUpdate
onEnabled: Utför den första installationen
Städning, med OnDisabled
Den färdiga AppWidgetProvider
AppWidgetProviderInfo-filen
1. android: previewImage
Om du inte tillhandahåller en previewImage använder Android din applikations ikon istället. För att uppmuntra användare att välja din widget från widgetväljaren bör du tillhandahålla en rita som visar hur din widget kommer att se ut när den är korrekt konfigurerad på användarens hemskärm.
Det enklaste sättet att skapa en förhandsgranskning är att använda widgetförhandsgranskningsprogrammet som ingår i Android-emulatorn. Med denna app kan du konfigurera din widget och sedan generera en bild som du sedan kan använda i ditt Android-projekt.
Vi skapar den här bilden när vi är klar med att bygga vår widget, så för närvarande kommer jag att använda den automatiskt genererade mipmap / ic_launcher-resursen som en tillfällig förhandsgranskningsbild.
2. android: widgetCategory
Applikationswidgets måste placeras i en App Widget-värd, som vanligtvis är den aktuella Android-skärmen, men kan också vara en tredjepartsstartare som Evie Launcher eller Nova Launcher.
Mellan API-nivå 17 och 20 var det möjligt att placera applikationswidgets på hemskärmen eller låsskärmen, men låsskärmsstödet försvann i API-nivå 21.
Du kan ange om din appwidget kan placeras på hemskärmen, låsskärmen (som Android refererar till som "tangentvakt") eller båda med attributet Android: widgetCategory. Eftersom det inte är möjligt att placera widgets på låsskärmen i de senaste versionerna av Android, riktar vi oss bara till startsidan.
För att bevara användarens integritet bör din widget inte visa någon känslig eller privat information när den placeras på låsskärmen.
Om du ger användare möjlighet att placera din widget på låsskärmen kan alla som tittar på användarens enhet potentiellt se din widget och allt dess innehåll. För att skydda användarens integritet bör din widget inte visa någon känslig eller privat information när den placeras på låsskärmen. Om din widget innehåller personuppgifter, kanske du vill överväga att tillhandahålla separat hemskärmslayout och låsskärmlayout.
3. android: initialLayout
Det här är den layoutresursfil som din widget ska använda när den placeras på hemskärmen, som för vårt projekt är list_widget.xml.
4. android: resizeMode = ”horisontell | vertikal”
Attributet android: resizeMode låter dig ange om din widget kan ändras storlek horisontellt, vertikalt eller längs båda axlarna.
För att säkerställa att din widget visas och fungerar korrekt på olika skärmar rekommenderas att du tillåter storleken på din widget att ändras och vertikalt, såvida du inte har en specifik anledning att inte göra det.
5. android: minHöjd och android: minBredd
Om din widget kan ändras, måste du se till att användaren inte krymper din widget till den punkt där den blir oanvändbar. Du kan använda attributen minHöjd och minBredd för att definiera den minsta appen kommer att krympa när den ändras av användaren.
Dessa värden representerar också widgetens ursprungliga storlek, så om din widget inte är storleksanpassbar definierar minHöjd och minWidth widgetens permanenta storlek.
6. android: updatePeriodMillis
AppWidgetProviderInfo är också där du anger hur ofta din widget ska begära ny information.
Det minsta uppdateringsintervallet som stöds är en gång på 1 000 000 millisekunder (30 minuter). Även om du förklarar ett kortare uppdateringsintervall kommer din widget fortfarande att uppdateras en gång var halvtimme.
Du kanske vill visa den senaste informationen så snabbt som möjligt, men systemet kommer väcka en sovande enhet för att hämta ny information. Ofta kan uppdateringar brännas genom en enhetens batteri, särskilt under perioder där enheten lämnas inaktiv under en betydande tidsperiod, till exempel över natten. Att tillhandahålla bästa möjliga användarupplevelse innebär att skapa en balans mellan begränsning av batteriförbrukning och tillhandahållande av ny information inom en rimlig tidsram.
Du bör också ta hänsyn till vilken typ av innehåll din widget visar.
Du bör också ta hänsyn till vilken typ av innehåll dina widgets för Android kommer att visa. Till exempel kan en väderwidget bara behöva hämta en uppdaterad prognos en gång om dagen, medan en app som visar nyheter måste behöva uppdateras oftare.
För att hitta den perfekta balansen kan du behöva testa din widget över en rad uppdateringsfrekvenser och mäta påverkan på batteriets livslängd och tidpunkten för widgetens innehåll. Om du har en villig grupp testare kan du till och med ställa in A / B-tester för att se om vissa uppdateringsfrekvenser tas emot mer positivt än andra.
Läste också: AndroidManifest.xml allt du behöver veta
Slutligen, när du har identifierat det perfekta uppdateringsintervallet, kanske du vill använda ett kortare intervall när du utvecklar och testar din app. Du kan till exempel använda kortast möjliga uppdateringsfrekvens (Android: updatePeriodMillis = ”1800000 ″) när du testar att din apps onUpdate () -metod utlöses korrekt och sedan ändra detta värde innan du släpper appen för allmänheten.
Den färdiga AppWidgetProviderInfo
Den färdiga collection_widget_info.xml-filen ska se ut så här:
Skräp inte användarens hemmaskärm!
För att säkerställa att startskärmen aldrig ser rörig kommer vi att lägga till lite stoppning och marginaler till vår widget. Om ditt projekt inte redan innehåller en dimension.xml-fil, måste du skapa en:
- Kontrollklicka på projektets värderingsmapp.
- Välj Ny> Värderingsresursfil.
- Ge den här filen namndimensionen.
- Klicka på OK.
Öppna din dimension.xml-fil och definiera följande marginal- och stoppningsvärden:
Skicka data till widgeten
Därefter måste vi skapa en widgettjänst som kommer att ansvara för att skicka våra insamlingsdata till widgeten.
Skapa en ny Java-klass (Ny> Java-klass) med namnet WidgetService och lägg till följande:
import android.content.Intent; import android.widget.RemoteViewsService; public class WidgetService utökar RemoteViewsService {@Override public RemoteViewsFactory onGetViewFactory (Intent intention) {return new DataProvider (this, intention); }}
Registrera din widget i manifestet
Vi måste nu göra några ändringar i vårt projekt manifest.
För att starta öppnar du Manifestet och registrerar din widget som BroadcastReceiver. Vi måste också lägga till ett avsiktsfilter för android.appwidget.action.APPWIDGET_UPDATE:
Därefter måste du ange leverantören av appwidgets:
Slutligen måste vi deklarera tjänsten som skickar data till vår widget, som i detta fall är WidgetService-klassen. Den här tjänsten kräver Android.permission.BIND_REMOTEVIEWS tillstånd:
Sätt din widget på testet
Om du har följt med den här självstudien har du nu en komplett samlingwidget som visar en uppsättning data på användarens startsida.
Om det här var ett verkligt Android-projekt skulle du vanligtvis utöka livscykelmetoderna, särskilt metoden onUpdate (), men det är allt vi behöver för att skapa en widget som du kan installera och testa på din Android-enhet:
- Installera detta projekt på en kompatibel Android-smartphone, surfplatta eller AVD (Android Virtual Device).
- Tryck länge på någon tom sektion på hemskärmen och välj widgetar när du uppmanas. detta startar widgetväljaren.
- Dra igenom widgetväljaren tills du hittar applikationswidgeten som du just skapade.
- Tryck länge på den här widgeten för att lägga till den på din hemskärm.
- Eftersom detta är den första instansen av den här widgeten, bör metoden onEnabled () köras, och du ser en “onEnabled called” toast.
- Ändra storlek på din widget. Om du ställer in en minsta storlek som stöds kontrollerar du att du inte kan krympa widgeten förbi detta värde.
- Testa att ListView rullar, som förväntat.
- Därefter bör du kontrollera metoden onDisabled () genom att radera din widget. Tryck länge på widgeten och välj sedan Ta bort från hemskärmen. Eftersom detta är den sista instansen av den här widgeten, bör metoden onDisabled () köras, och du ser en “onDisabled called” toast.
Detta är allt du behöver för att leverera en fungerande widget för Android-applikationer, men det finns några tillägg som ofta kan förbättra användarupplevelsen. I följande avsnitt uppmuntrar vi användare att välja den här widgeten från widgetväljaren genom att skapa en förhandsgranskningsbild som visar widgeten som bäst. Jag visar också hur du skapar en helt anpassningsbar widget genom att lägga till en konfigurationsaktivitet till ditt projekt.
Skapa en förhandsgranskningsbild för Android-widget
Om du tar tag i din Android-enhet och sveper genom widgetväljaren ser du att varje widget representeras av en bild, vilket vanligtvis visar hur den här widgeten kommer att se ut när den har konfigurerats på användarens startsida.
För att uppmuntra användare att välja din widget ska du ange en förhandsgranskningsbild som belyser all användbar information och funktioner som din widget har att erbjuda.
Du kan snabbt och enkelt skapa en förhandsgranskningsbild med hjälp av applikationen Widget Preview som ingår i Android-emulatorn.
Observera att widgetförhandsvisning inte ingår i de senaste Android-systembilderna, så du måste skapa en AVD med Nougat (API-nivå 25) eller tidigare:
- Installera din applikation på en AVD som kör API 25 eller lägre.
- Öppna AVD: s applåda och starta appen Widget Preview.
- Förhandsvisning av widgeten visar en lista över alla program som för närvarande är installerade på denna AVD; välj din ansökan från listan.
- Din widget kommer nu att visas på en tom bakgrund. Spendera lite tid på att ändra storlek på och justera din widget tills den visar det bästa som din widget har att erbjuda.
- När du är nöjd med widgetens utseende och innehåll väljer du Ta stillbild.
- Om du vill hämta din ögonblicksbild byter du tillbaka till Android Studio och väljer Visa> Verktyg Windows> Enhetsfilutforskare från verktygsfältet. Detta lanserar Android Studios Device File Explorer.
- Navigera till sdcard / Download i Device File Explorer. Du bör hitta din förhandsvisningsbild sparad i följande format: _ori_.png
- Dra den här bilden från Android Studio och släpp den någonstans lättillgänglig, till exempel på skrivbordet.
- Ge den här bildfilen ett beskrivande namn.
- Dra och släpp filen till projektets dragbara mapp.
- Öppna din AppWidgetProviderInfo, som för detta projekt är collection_widget_info.xml.
- Hitta raden Android: previewImage = ”@ mipmap / ic_launcher” och uppdatera den för att referera till din förhandsgranskningsbild.
Din widget kommer nu att använda den nya bildresursen som förhandsgranskningsbild:
- Installera det uppdaterade projektet på din fysiska Android-enhet eller AVD.
- Tryck länge på alla tomma delar på hemskärmen.
- Klicka på Widgets, som startar widgetväljaren.
- Bläddra till din widget; det bör nu använda den uppdaterade förhandsvisningsbilden.
Anpassningsbara widgetar: Lägga till en konfigurationsaktivitet
En konfigurationsaktivitet startas automatiskt när användaren placerar varje instans av din widget på sin hemskärm.
Det finns flera skäl till varför du kanske vill lägga till en konfigurationsaktivitet till ditt projekt.
widgets tenderar att ge den bästa användarupplevelsen när de ger tillgång till information eller funktioner som är viktigast för den enskilda användaren.
För det första kräver vissa widgetar den första inställningen, till exempel en widget som visar trafikvarningar kan behöva känna till användarens hemadress, var de arbetar och de tider då de vanligtvis pendlar. Utan något sätt att ange denna information kan din widget vara helt värdelös!
Dessutom tenderar widgets att ge den bästa användarupplevelsen när de ger tillgång till information eller funktioner som är viktigast för den enskilda användaren. Genom att lägga till en konfigurationsaktivitet till ditt projekt kan du ge användarna frihet att välja och välja exakt vad som ingår i din widget.
Till och med relativt enkla anpassningar, som att ändra en widgets bakgrund eller teckensnitt, kan ha en positiv inverkan på användarupplevelsen - trots allt kommer ingen att uppskatta en widget som visuellt kolliderar med resten av sin hemskärm!
Ingen kommer att uppskatta en widget som visuellt kolliderar med resten av sin hemskärm!
Alternativt kan du ibland ha en lång lista med innehåll som du vill inkludera i din widget och du kämpar för att begränsa dina alternativ. En konfigurationsaktivitet kan vara ett sätt att använda alla dina idéer till bra användning, utan skapande en rörig, förvirrande widget. Tänk bara på att inställning av en widget inte bör känna sig som ett jobb, så om du tillhandahåller en konfigurationsaktivitet rekommenderas att du begränsar dig till tre konfigurationsalternativ.
Låt oss lägga till en konfigurationsaktivitet till vårt projekt!
Först behöver vår konfigurationsaktivitet en layout, så skapa en ny layoutresursfil med namnet config_activity.xml.
Jag kommer att lägga till följande knappar i den här layouten:
- En konfigurationsknapp. I ett verkligt projekt skulle denna knapp modifiera widgeten på något sätt, till exempel lägga till eller ta bort innehåll, eller ändra hur ofta widgeten uppdateras. För att hålla vår kod okomplicerad, klickar du på den här knappen helt enkelt en toast för konfigurationsalternativ.
- En inställningsknapp. När användaren är nöjd med hur deras widget konfigureras, kommer du att trycka på den här knappen för att placera den nykonfigurerade widgeten på sin hemskärm.
Här är min färdiga config_activity.xml-fil:
Skapa konfigurationsaktivitet
Nu måste vi skapa vår konfigurationsaktivitet.
För att starta, skapa en ny Java-klass med namnet ConfigActivity. I den här aktiviteten kommer vi att hämta app-widget-ID från avsikten som startade konfigurationsaktiviteten. Om denna avsikt inte har ett widget-ID, måste vi anropa metoden finish ():
Avsiktlig avsikt = getIntent (); Bundle extra = intention.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Därefter måste vi skapa en returåtgärd, passera den ursprungliga appWidgetId och ställa in resultaten från konfigurationsaktiviteten:
Avsikt resultatVärde = nytt Syfte (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); Avsluta(); }}}
Om du tillhandahåller en konfigurationsaktivitet skickas inte sändningen ACTION_APPWIDGET_UPDATE automatiskt när konfigurationsaktiviteten startas, vilket betyder metoden onUpdate () vana kallas när användaren skapar en instans av din widget.
För att säkerställa att din widget skapas med aktuell information och innehåll, din konfigurationsaktivitet måste utlösa den första begäran om uppdatering ().
Här är den färdiga ConfigActivity:
import android.app.Aktivitet; importera 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 utökar aktivitet {@Override skyddat tomrum onCreate (Bundle sparadInstanceState) {super.onCreate (sparadInstanceState); 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 ();}}); Knapp configButton = (Button) findViewById (R.id.configButton); configButton.setOnClickListener (ny OnClickListener () {@Override public void onClick (View v) {handleConfigWidget ();}}); } private void handleSetupWidget () {showAppWidget (); } privat ogiltigt handtagConfigWidget () {Toast.makeText (ConfigActivity.this, "Konfigurationsalternativ", Toast.LENGTH_LONG) .show (); } int appWidgetId; private void showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Avsiktlig avsikt = getIntent (); Bundle extra = intention.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // TO DO: Utför konfigurationen // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); Avsluta(); }}}
När du har skapat en konfigurationsaktivitet måste du förklara den här aktiviteten i manifestet och ange att den accepterar åtgärden APPWIDGET_CONFIGURE:
Slutligen, eftersom en konfigurationsaktivitet hänvisas till utanför paketets omfattning, måste vi förklara denna aktivitet i vår AppWidgetProviderInfo, som i detta fall är filen collection_widget_info.xml:
android: konfigurera = "com.jessicathornsby.collectionwidget.ConfigActivity">
Testa ditt projekt
Nu är det dags att testa ditt färdiga projekt:
- Installera ditt uppdaterade projekt på en fysisk Android-enhet eller AVD.
- Radera alla tidigare instanser av din widget för att säkerställa att du arbetar med den senaste versionen.
- Tryck länge på ett tomt område på hemskärmen och välj Widgets när du uppmanas.
- Hitta din widget i widgetväljaren och tryck länge på den för att välja den.
- Släpp widgeten på din hemskärm. Konfigurationsaktiviteten bör starta automatiskt.
- Ge knappen Utför vissa konfigurationer ett klick, och en toast för konfigurationsalternativ ska visas för att bekräfta att denna interaktion har registrerats.
- Föreställ dig att du har justerat widgetens inställningar och nu är redo att placera den på din hemskärm. ge knappen Skapa widget en knapp, och denna widget ska skapas framgångsrikt.
Du kan ladda ner det slutförda samlingswidgetprojektet från GitHub.
Avslutar
I den här artikeln skapade vi en rullbar samling-widget som visar en datauppsättning på användarens hemskärm.
Om du vill fortsätta arbeta med detta projekt kan du försöka lägga till din egen kod till metoden onUpdate (), för att skapa en widget som uppdateras med ny information i det intervall som definieras i din AppWidgetProviderInfo-fil (collection_widget_info).
Om du skapar en Android-widget, var noga med att dela dina skapelser i kommentarerna nedan!
