Conţinut
- Ce sunt widget-urile pentru Android?
- Proiectul meu are într-adevăr nevoie de un widget pentru aplicații?
- Widget-urile pentru Android pot îmbunătăți experiența utilizatorului
- Mai puternic decât comenzile rapide pentru aplicații
- Creați un widget Android pentru a conduce implicarea pe termen lung
- Crearea unui widget pentru aplicații de colecție
- Construiți aspectul widgetului
- Popularea widget-ului colecției
- AppWidgetProvider: Configurarea widgetului
- Creați adaptorul
- Definirea metodelor ciclului de viață a widget-urilor
- Recuperarea conținutului nou cu onUpdate
- onEnabled: Efectuarea configurației inițiale
- Curățare, cu OnDisabled
- AppWidgetProvider completat
- Fișierul AppWidgetProviderInfo
- 1. android: previewImage
- 2. android: widgetCategorie
- 3. android: initialLayout
- 4. android: resizeMode = ”orizontal | vertical”
- 5. Android: minHeight și Android: minWidth
- 6. android: updatePeriodMillis
- AppWidgetProviderInfo completat
- Nu înghesuiți ecranul de pornire al utilizatorului!
- Trimiterea datelor către widget
- Înregistrarea widget-ului în Manifest
- Puneți testul widget-ului
- Crearea unei imagini de previzualizare widget Android
- Widgeturi personalizabile: Adăugarea unei activități de configurare
- Creați Activitatea de configurare
- Testarea proiectului tău
- Înveliți
Încă din primele zile ale sistemului de operare, widget-urile pentru Android au permis utilizatorilor să se angajeze cu aplicațiile lor preferate, din confortul ecranului lor de pornire. Deci cum creezi un widget Android?
Pentru dezvoltator, widget-urile oferă aplicației dvs. o prezență valoroasă pe ecranul de pornire al utilizatorului. În loc să fie scos din vedere în sertarul aplicației, utilizatorii vor fi amintiți despre aplicație de fiecare dată se uită la ecranul lor de pornire - obținând, de asemenea, o previzualizare a celui mai interesant și util conținut al aplicației.
Widget-urile oferă aplicației o prezență valoroasă pe ecranul de pornire al utilizatorului
În acest articol, vă voi arăta cum să oferiți o experiență de utilizator mai bună, în timp ce voi încuraja utilizatorii să se angajeze cu aplicația dvs., prin crearea unui widget Android! Până la sfârșitul acestui articol, veți crea un widget de colecție rulant care afișează un set complet de date pe ecranul de pornire al utilizatorului.
Pentru a vă asigura că furnizați tipul de widget pe care îl utilizează vrei pentru a le plasa pe ecranul lor de pornire, vom crea, de asemenea, o activitate de configurare, care va permite utilizatorilor să personalizeze conținutul, aspectul și funcțiile widgetului. În cele din urmă, voi arăta cum puteți încuraja oamenii să utilizeze widget-ul dvs., prin crearea unei imagini de previzualizare a widget-urilor care prezintă cele mai bune oferte ale widgetului.
Citește și: Dezvoltare pentru dispozitive pliabile: Ce trebuie să știți
Ce sunt widget-urile pentru Android?
Un widget de aplicație este o aplicație ușoară, în miniatură, care se află pe ecranul de pornire al utilizatorului.
Widget-urile pentru Android pot oferi o gamă de conținut, dar, în general, se încadrează într-una din următoarele categorii:
- Widget informativ. Acesta este un widget care nu poate fi defilat care afișează unele informații, cum ar fi prognoza meteo de astăzi sau data și ora.
- Widget-uri de colecție. Acesta este un widget defilabil care afișează un set de date conexe, formatate ca ListView, GridView, StackView sau AdapterViewFlipper. Widget-urile de colecție sunt de obicei susținute de o sursă de date, cum ar fi o bază de date sau un Array.
- Controlați widget-urile. Aceste widgeturi funcționează ca o telecomandă care permite utilizatorilor să interacționeze cu aplicația dvs., fără trebuind să o aducă în prim-plan. Aplicațiile care joacă media, cum ar fi podcast-uri sau muzică, au adesea widget-uri de control care permit utilizatorului să declanșeze acțiuni Play, Pause și Skip direct de pe ecranul lor de pornire.
- Widgeturi hibride. Uneori este posibil să puteți oferi o experiență de utilizator mai bună prin combinarea elementelor din mai multe categorii. De exemplu, dacă dezvoltați un widget de control pentru o aplicație de muzică, puteți furniza controale Play, Pause și Skip, dar puteți de asemenea să vă afișați anumite informații, cum ar fi titlul melodiei și artistul. Dacă decideți să combinați și să potriviți, atunci nu vă lăsați transportat! Widget-urile tind să ofere cea mai bună experiență de utilizator atunci când oferă acces ușor la o cantitate mică de informații relevante, în timp util sau la câteva funcții frecvent utilizate. Pentru a ajuta la menținerea ușoară a widget-urilor hibride, vă recomandăm să identificați categoria principală a widgetului, să o dezvoltați în conformitate cu acea categorie și atunci adăugați câteva elemente din categoria secundară a widget-ului.
Proiectul meu are într-adevăr nevoie de un widget pentru aplicații?
Există mai multe motive pentru care ar trebui să luați în considerare adăugarea unui widget de aplicație la proiectul dvs. Android.
Widget-urile pentru Android pot îmbunătăți experiența utilizatorului
De regulă, cu cât sunt mai puțini pași de navigare necesari pentru a finaliza o sarcină, cu atât este mai bună experiența utilizatorului.
Prin furnizarea unui widget de aplicație, puteți elimina mai mulți pași de navigare din cele mai utilizate fluxuri ale aplicației. În cel mai bun caz, utilizatorii dvs. vor putea obține informațiile de care au nevoie doar aruncând o privire la ecranul lor de pornire sau pot efectua sarcina dorită doar atingând un buton din widgetul de control.
Mai puternic decât comenzile rapide pentru aplicații
Widget-urile aplicației răspund adesea la evenimentele onClick prin lansarea nivelului superior în aplicația asociată, similar cu o comandă rapidă a aplicației. Cu toate acestea, widget-urile pot oferi, de asemenea, acces direct la activități specifice dintr-o aplicație, de exemplu atingerea unei notificări Primite a unui widget poate lansa aplicația asociată cu noua deja deschisă.
Prin încorporarea mai multor legături în aspectul widgetului, puteți oferi acces la un singur acces la toate cele mai importante activități ale aplicației, eliminând și mai mulți pași de navigare din fluxurile cele mai utilizate în mod obișnuit.
Prin încorporarea mai multor link-uri în aspectul widgetului, puteți oferi acces un singur acces la toate cele mai importante activități ale aplicației.
Rețineți că widget-urile răspund doar la evenimentele onClick, ceea ce împiedică utilizatorii să interacționeze accidental cu widgetul în timp ce alunecă pe ecranul de pornire. Singura excepție este atunci când utilizatorul încearcă să șteargă widgetul trăgându-l către acțiunea de Eliminare a ecranului de domiciliu, deoarece în acest scenariu widgetul dvs. va răspunde la un gest de glisare verticală.
Această interacțiune este gestionată de sistemul Android, astfel încât nu trebuie să vă faceți griji cu privire la implementarea manuală a suportului vertical de swipe în widget.
Creați un widget Android pentru a conduce implicarea pe termen lung
Convingerea oamenilor să-și descarce aplicația este doar primul pas pentru crearea unei aplicații Android de succes. Șansele sunt că, dacă vă apucați propriul smartphone sau tabletă Android și treceți prin sertarul aplicației, atunci veți descoperi mai multe aplicații pe care nu le-ați folosit în zile, săptămâni sau, eventual, chiar luni!
Citește și:Noțiuni introductive cu SDK Facebook pentru Android
După ce aplicația dvs. este instalată cu succes pe dispozitivul utilizatorului, va trebui să depuneți eforturi pentru ca acestea să fie angajate și să se bucure de aplicația dvs. Oferiți aplicației prezența pe ecranul de domiciliu poate fi un instrument puternic pentru a ajuta la implicarea pe termen lung, pur și simplu pentru că este un memento constant că aplicația dvs. există!
Un widget bine proiectat poate servi, de asemenea, ca un anunț permanent pentru aplicația dvs. De fiecare dată când utilizatorul aruncă o privire pe ecranul lor de pornire, widgetul are posibilitatea de a-i încuraja în mod activ să se angajeze din nou cu aplicația dvs., prezentându-i tot cel mai interesant și util conținut al aplicației.
Crearea unui widget pentru aplicații de colecție
În acest tutorial, vom construi un widget de colecție care afișează un tablou ca ListView deplasat.
Pentru a vă ajuta să urmăriți ciclul de viață al widgetului aplicației, acest widget va declanșa, de asemenea, diverse toasturi, în timp ce trece prin diferite stări ale ciclului de viață. Spre sfârșitul acestui tutorial, vom îmbunătăți widgetul cu o imagine de previzualizare personalizată, care va fi afișată în Widget Picker pentru Android și o activitate de configurare, care va permite utilizatorilor să personalizeze widgetul înainte de a-l plasa pe ecranul lor de pornire.
Creați un nou proiect Android cu setările pe care le alegeți și să începem!
Construiți aspectul widgetului
Pentru început, să definim interfața de utilizare a widgetului (UI).
Widgeturile aplicațiilor sunt afișate într-un proces in afara aplicația dvs., astfel încât să puteți utiliza machete și vizualizări acceptate de RemoteViews.
Când construiți aspectul, sunteți restricționat la următoarele:
- AnalogClock
- Buton
- Cronometru
- FrameLayout
- GridLayout
- ImageButton
- ImageView
- LinearLayout
- Bara de progres
- RelativeLayout
- TextView
- ViewStub
- AdapterViewFlipper
- GridView
- ListView
- StackView
- ViewFlipper
Rețineți că sunt subclase din clasele de mai sus și Vizualizări nu sprijinit.
Creați un nou fișier de resurse de dispunere numit list_widget.xml. Întrucât vom afișa datele noastre folosind un ListView, acest aspect servește în principal ca un container pentru o În continuare, trebuie să creăm un furnizor de date pentru ListView-ul nostru. Creați o nouă clasă Java numită DataProvider.java și adăugați următoarele: import android.content.Context; import android.content.Intent; import Android.widget.RemoteViews; import Android.widget.RemoteViewsService; import java.util.ArrayList; import java.util.List; importați static android.R.id.text1; import android static.R.layout.simple_list_item_1; public class DataProvider implementează RemoteViewsService.RemoteViewsFactory {List Pentru a crea un widget Android, trebuie să creați mai multe fișiere. Primul nostru fișier specific widget este un AppWidgetProvider, care este un BroadcastReceiver în care veți defini diferitele metode ale ciclului de viață a widgetului, cum ar fi metoda numită atunci când widgetul a fost creat pentru prima dată și metoda numită atunci când respectivul widget este șters. Creați o nouă clasă Java (Fișier> Nou> Clasă Java) numită CollectionWidget. Pentru început, toate fișierele furnizorului de widget trebuie să se extindă din clasa AppWidgetProvider. Apoi, trebuie să încărcăm fișierul de resurse de format list_widget.xml într-un obiect RemoteViews și să informăm AppWidgetManager despre obiectul RemoteViews actualizat: public class CollectionWidget extinde AppWidgetProvider {static void updateAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Instantează obiectul RemoteViews // RemoteViews views = nou RemoteViews (context.getPackageName (), R.layout.list; setRemoteAdapter (context, vizualizări); // Solicitați ca AppWidgetManager să actualizeze widget-ul aplicației // appWidgetManager.updateAppWidget (appWidgetId, vizualizări); } Deoarece ne afișăm datele într-o ListView, trebuie să definim o metodă setRemoteAdapter () în AppWidgetProvider. SetRemoteAdapter () este echivalent cu apelarea AbsListView.setRemoteViewsAdapter (), dar este proiectat pentru a fi utilizat în widget-urile aplicației. În această metodă, trebuie să definim id-ul AdapterView (R.id.widget_list) și intenția serviciului care în cele din urmă va furniza datele către RemoteViewsAdapter - vom crea în scurt timp această clasă WidgetService. private static void setRemoteAdapter (Context context, @NonNull final RemoteViews views) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} În AppWidgetProvider, trebuie să definim următoarele metode ale ciclului de viață a widgetului: Metoda ciclului de viață a widgetului OnUpdate () este responsabilă pentru actualizarea Vizualizărilor widgetului cu informații noi. Această metodă se numește de fiecare dată: Acesta este și locul în care veți înregistra orice operator de gestionare a evenimentelor pe care widget-ul ar trebui să le utilizeze. Atunci când actualizați un widget Android, este important să rețineți că utilizatorii pot crea mai multe instanțe ale aceluiași widget. De exemplu, poate widgetul dvs. este personalizabil, iar utilizatorul decide să creeze mai multe „versiuni” care să afișeze informații diferite sau să ofere acces la funcționalități unice. Când apelați la Actualizare (), trebuie să specificați dacă actualizați fiecare instanță a acestui widget sau doar o anumită instanță. Dacă doriți să actualizați fiecare instanță, atunci puteți utiliza appWidgetIds, care este un tablou de ID-uri care identifică fiecare instanță de pe dispozitiv. În fragmentul următor, actualizez fiecare instanță: @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Actualizați toate instanțele acestui widget // updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (context, appWidgetManager, appWidgetIds); } Rețineți că pentru a ajuta codul să fie simplu, această metodă onUpdate () nu face în prezent modificări la widget. Metoda ciclului de viață OnEnabled () este apelată ca răspuns la ACTION_APPWIDGET_ENABLED, care este trimisă când se adaugă o instanță a widgetului pe ecranul de pornire pentru primul timp. Dacă utilizatorul creează două instanțe ale widget-ului, atunci OnEnabled () va fi apelat pentru prima instanță, dar nu pentru al doilea. Metoda ciclului de viață OnEnabled () este aceea în care ar trebui să efectuați orice configurare necesară pentru toate instanțele widget-ului dvs., cum ar fi crearea bazei de date care va alimenta informațiile despre widget-uri. Voi afișa un toast, astfel încât să puteți vedea exact când se numește această metodă de ciclu de viață: @Substitui public void onEnabled (context contextual) {Toast.makeText (context, "onEnabled numit", Toast.LENGTH_LONG) .show (); } Rețineți că, dacă utilizatorul șterge toate instanțele widgetului și apoi creează o nouă instanță, aceasta este clasată ca primă instanță, iar metoda ciclului de viață OnEnabled () va fi apelată din nou. Metoda onDisabled () este apelată ca răspuns la ACTION_APPWIDGET_DISABLED, care este declanșat atunci când utilizatorul șterge ultimul exemplu a widgetului. Această metodă a ciclului de viață a widgetului este aceea în care ar trebui să curățați toate resursele pe care le-ați creat în metoda onEnabled (), de exemplu ștergerea bazei de date pe care ați creat-o în onEnabled (). Pentru a vă menține codul simplu, voi afișa pur și simplu un toast de fiecare dată când această metodă este declanșată: @ Supraversează public void onDisabled (context contextual) {Toast.makeText (context, "onDisabled numit", Toast.LENGTH_LONG) .show (); } Fișierul dvs. CollectionWidget ar trebui să arate acum așa: 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; // Extindeți-vă de la clasa AppWidgetProvider // clasa publică CollectionWidget extinde AppWidgetProvider {static void updateAppWidget (context contextual, AppWidgetManager appWidgetManager, int appWidgetId) {// Încărcați fișierul de resurse de dispunere într-un obiect RemoteViews // context RemoteViews = context RemoteViews getPackageName (), R.layout.list_widget); setRemoteAdapter (context, vizualizări); // Informează AppWidgetManager despre obiectul RemoteViews // appWidgetManager.updateAppWidget (appWidgetId, vizualizări); } @ Supraversează public void onUpdate (context contextual, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (context, appWidgetManager, appWidgetId); } super.onUpdate (context, appWidgetManager, appWidgetIds); } @Substitui public void onEnabled (context context) {Toast.makeText (context, "onEnabled numit", Toast.LENGTH_LONG) .show (); } @Se anulează public void onDisabled (context contextual) {Toast.makeText (context, "onDisabled numit", Toast.LENGTH_LONG) .show (); } private static void setRemoteAdapter (Context context, @NonNull final RemoteViews views) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} Widget-ul dvs. de aplicație necesită, de asemenea, un fișier AppWidgetProviderInfo, care definește mai multe proprietăți importante, inclusiv dimensiunile minime ale widgetului și cât de des trebuie actualizat. Fișierul AppWidgetProviderInfo este stocat în folderul res / xml al proiectului. Dacă proiectul dvs. nu conține deja acest dosar, va trebui să îl creați: Apoi, creați un fișier collection_widget_info, pe care îl vom folosi ca AppWidgetProviderInfo: În fișierul nostru AppWidgetProviderInfo, trebuie să definim următoarele proprietăți: Acesta este desenul care reprezintă widgetul aplicației dvs. în selectorul de widgeturi al dispozitivului.Popularea widget-ului colecției
AppWidgetProvider: Configurarea widgetului
Creați adaptorul
Definirea metodelor ciclului de viață a widget-urilor
Recuperarea conținutului nou cu onUpdate
onEnabled: Efectuarea configurației inițiale
Curățare, cu OnDisabled
AppWidgetProvider completat
Fișierul AppWidgetProviderInfo
1. android: previewImage
Dacă nu furnizați o imagine de previzualizare, Android va utiliza în schimb pictograma aplicației dvs. Pentru a încuraja utilizatorii să selecteze widget-ul din Selectorul de widget, ar trebui să furnizați un desen care arată cum va arăta widgetul după ce va fi configurat corect pe ecranul de pornire al utilizatorului.
Cel mai simplu mod de a crea o imagine de previzualizare este de a utiliza aplicația de previzualizare a widget-urilor care este inclusă în emulatorul Android. Această aplicație vă permite să configurați widgetul și apoi să generați o imagine, pe care o puteți folosi apoi în proiectul dvs. Android.
Vom crea această imagine după ce am terminat de construit widgetul, așa că deocamdată voi folosi resursa mipmap / ic_launcher generată automat ca imagine de previzualizare temporară.
2. android: widgetCategorie
Widgeturile pentru aplicații trebuie să fie plasate în interiorul unei aplicații Widget Host, care este de obicei ecranul de stoc Android Android, dar poate fi și un lansator terț, precum Evie Launcher sau Nova Launcher.
Între nivelurile 17 și 20 de API, a fost posibil să plasați widget-uri pe aplicația de pornire sau Lockscreen, dar suportul lockscreen a fost depășit la nivelul API 21.
Puteți specifica dacă widgetul dvs. de aplicație poate fi plasat pe ecranul inițial, pe ecranul de blocare (la care Android se numește „cheie de protecție”) sau pe ambele, folosind atributul Android: widgetCategory. Întrucât nu este posibil să plasați widget-uri pe ecranul de blocare în cele mai recente versiuni de Android, vom viza doar ecranul inițial.
Pentru a păstra confidențialitatea utilizatorului, widgetul dvs. nu ar trebui să afișeze informații private sau sensibile atunci când este plasat pe ecranul de blocare.
Dacă oferiți utilizatorilor opțiunea de a plasa widgetul pe ecranul de blocare, oricine aruncă o privire asupra dispozitivului utilizatorului ar putea vedea widgetul și tot conținutul acestuia. Pentru a păstra confidențialitatea utilizatorului, widget-ul dvs. nu ar trebui să afișeze informații private sau sensibile atunci când este plasat pe ecranul de blocare. Dacă widgetul dvs. conține date cu caracter personal, atunci poate doriți să luați în considerare furnizarea de machete separate pe ecranul de casă și pe ecranul de blocare.
3. android: initialLayout
Acesta este fișierul de resurse de dispunere pe care widgetul ar trebui să îl utilizeze atunci când este plasat pe ecranul de pornire, care pentru proiectul nostru este list_widget.xml.
4. android: resizeMode = ”orizontal | vertical”
Atributul Android: resizeMode vă permite să specificați dacă widgetul dvs. poate fi redimensionat pe orizontală, vertical sau pe ambele axe.
Pentru a asigura afișarea și funcționarea corectă a widgetului pe o varietate de ecrane, vă recomandăm să permiteți redimensionarea orizontală a widgetului dvs. și pe verticală, cu excepția cazului în care aveți un motiv specific de a nu face acest lucru.
5. Android: minHeight și Android: minWidth
Dacă widget-ul dvs. poate fi redimensionat, trebuie să vă asigurați că utilizatorul nu va micșora widgetul până la punctul de a deveni inutilizabil. Puteți utiliza atributele minHeight și minWidth pentru a defini cea mai mică aplicație a dvs. va scădea atunci când este redimensionată de către utilizator.
Aceste valori reprezintă, de asemenea, dimensiunea inițială a widget-ului dvs., astfel încât dacă widgetul nu este redimensionabil, atunci minHeight și minWidth vor defini dimensiunea permanentă a widget-ului.
6. android: updatePeriodMillis
AppWidgetProviderInfo este, de asemenea, locul în care veți specifica cât de des ar trebui să vă solicite widget-urile noi.
Cel mai mic interval de actualizare acceptat este o dată la 1800000 milisecunde (30 minute). Chiar dacă declarați un interval de actualizare mai scurt, widgetul dvs. se va actualiza încă o dată la fiecare jumătate de oră.
În timp ce este posibil să doriți să afișați cele mai recente informații cât mai repede posibil, sistemul voi treziți un dispozitiv de dormit pentru a prelua informații noi. Actualizările frecvente pot arde prin bateria unui dispozitiv, în special în perioadele în care dispozitivul este lăsat inactiv pentru o perioadă semnificativă de timp, cum ar fi peste noapte. Oferirea de cea mai bună experiență posibilă a utilizatorului înseamnă a găsi un echilibru între limitarea consumului bateriei și furnizarea de informații noi într-un interval de timp rezonabil.
De asemenea, ar trebui să țineți cont de tipul de conținut pe care îl va afișa widgetul.
De asemenea, ar trebui să țineți cont de tipul de conținut pe care îl vor afișa widget-urile pentru Android. De exemplu, un widget meteo poate avea nevoie doar de a prelua o prognoză actualizată o dată pe zi, în timp ce o aplicație care afișează știri de ultimă oră va trebui să se actualizeze mai frecvent.
Pentru a găsi acest echilibru perfect, poate fi necesar să testați widgetul într-o gamă de frecvențe de actualizare și să măsurați impactul asupra duratei de viață a bateriei și a actualității conținutului widgetului. Dacă aveți un grup doritor de testeri, atunci puteți configura chiar și testarea A / B, pentru a vedea dacă unele frecvențe de actualizare sunt primite mai pozitiv decât altele.
Aalso a citit: AndroidManifest.xml tot ce trebuie să știți
În cele din urmă, după ce ați identificat intervalul de actualizare perfect, poate doriți să utilizați un interval mai scurt atunci când dezvoltați și testați aplicația. De exemplu, puteți utiliza cea mai scurtă frecvență posibilă de actualizare (Android: updatePeriodMillis = "1800000") când testați dacă metoda onUpdate () a aplicației se declanșează corect, apoi modificați această valoare înainte de a elibera aplicația la publicul larg.
AppWidgetProviderInfo completat
Fișierul collection_widget_info.xml terminat ar trebui să arate așa:
Nu înghesuiți ecranul de pornire al utilizatorului!
Pentru a ne asigura că ecranul de pornire nu pare niciodată înghesuit, vom adăuga câteva pagini și margini la widget-ul nostru. Dacă proiectul dvs. nu conține deja un fișier dimens.xml, va trebui să creați unul:
- Faceți clic pe controlul dosarului de valori al proiectului.
- Selectați Nou> Valoare fișier resursă.
- Dați acestui fișier numele dimensiunii.
- Faceți clic pe OK.
Deschideți-vă fișierul dimens.xml și definiți următoarele valori de margine și de umplere:
Trimiterea datelor către widget
În continuare, trebuie să creăm un serviciu de widget, care va fi responsabil pentru trimiterea datelor colecției noastre la widget.
Creați o clasă Java nouă (Nouă> Java clasă) numită WidgetService și adăugați următoarele:
import android.content.Intent; import Android.widget.RemoteViewsService; public class WidgetService extinde RemoteViewsService {@Override public RemoteViewsFactory onGetViewFactory (Intenție intenție) {returnare DataProvider nou (aceasta, intenție); }}
Înregistrarea widget-ului în Manifest
Acum trebuie să facem unele modificări la Manifestul proiectului nostru.
Pentru a începe, deschideți Manifestul și înregistrați-vă widget-ul ca BroadcastReceiver. De asemenea, trebuie să adăugăm un filtru de intenție pentru acțiunea android.appwidget.action.APPWIDGET_UPDATE:
În continuare, trebuie să specificați furnizorul de widget-uri pentru aplicații:
În cele din urmă, trebuie să declaram serviciul care va trimite date către widget-ul nostru, care în această instanță este clasa WidgetService. Acest serviciu necesită permisiunea Android.permission.BIND_REMOTEVIEWS:
Puneți testul widget-ului
Dacă urmați acest tutorial, veți avea acum un widget complet de colecție care afișează un set de date pe ecranul de pornire al utilizatorului.
Dacă acesta a fost un proiect Android din viața reală, atunci în mod obișnuit, ați extinde pe metodele ciclului de viață, în special metoda onUpdate (), dar este tot ce avem nevoie pentru a crea un widget pe care îl puteți instala și testa pe dispozitivul dvs. Android:
- Instalați acest proiect pe un smartphone Android, tabletă sau AVD (dispozitiv virtual Android) compatibil.
- Apăsați lung orice secțiune goală a ecranului de domiciliu și selectați Widgets când vi se solicită; acest lucru lansează Widget Picker.
- Glisați prin Widget Picker până găsiți widget-ul pentru aplicații pe care tocmai l-ați creat.
- Apăsați lung acest widget pentru a-l adăuga pe ecranul dvs. de pornire.
- Întrucât aceasta este prima instanță a acestui widget particular, metoda onEnabled () ar trebui să fie executată și veți vedea un toast „onEnabled numit”.
- Redimensionați widgetul. Dacă setați o dimensiune minimă acceptată, verificați dacă nu puteți micsora widgetul peste această valoare.
- Testați dacă ListView derulează, așa cum era de așteptat.
- În continuare, ar trebui să verificați metoda onDisabled (), ștergând widgetul. Apăsați lung pe widget, apoi selectați Ștergeți din ecranul de pornire. Întrucât aceasta este ultima instanță a acestui widget particular, metoda onDisabled () ar trebui să fie executată și veți vedea un toast „onDisabled numit”.
Acesta este tot ce îți trebuie pentru a livra un widget pentru aplicații Android funcțional, dar există câteva adăugiri care pot îmbunătăți adesea experiența utilizatorului. În următoarele secțiuni, vom încuraja utilizatorii să aleagă acest widget din Widget Picker, creând o imagine de previzualizare care prezintă cel mai bine widgetul. Vă voi arăta, de asemenea, cum puteți crea un widget complet personalizabil, adăugând o activitate de configurare la proiectul dvs.
Crearea unei imagini de previzualizare widget Android
Dacă apucați dispozitivul Android și treceți prin Picker Widget, veți vedea că fiecare widget este reprezentat de o imagine, care demonstrează, de obicei, cum va arăta acest widget odată ce a fost configurat pe ecranul de pornire al utilizatorului.
Pentru a încuraja utilizatorii să selecteze widgetul, ar trebui să oferiți o imagine de previzualizare care evidențiază toate informațiile și funcțiile utile pe care widgetul trebuie să le ofere.
Puteți crea rapid și ușor o imagine de previzualizare, folosind aplicația Previzualizare widget inclusă în emulatorul Android.
Rețineți că Previzualizarea widget-urilor nu este inclusă în cele mai recente imagini ale sistemului Android, deci va trebui să creați un AVD folosind Nougat (API-ul nivel 25) sau mai vechi:
- Instalați aplicația pe un AVD care rulează API 25 sau mai mic.
- Deschide sertarul aplicației AVD și lansează aplicația Previzualizare widget.
- Previzualizarea widgetului va afișa o listă a fiecărei aplicații instalate în prezent pe acest AVD; selectați aplicația din listă.
- Widgetul dvs. va fi acum afișat pe un fundal gol. Petreceți ceva timp redimensionându-vă și regăsind widgetul până când arată cel mai bun lucru pe care widgetul îl are de oferit.
- După ce sunteți mulțumit de aspectul și conținutul widget-ului dvs., selectați Echipare.
- Pentru a vă prelua instantaneul, treceți înapoi la Android Studio și selectați Afișați> Instrumentul Windows> Device File Explorer din bara de instrumente. Aceasta lansează Android Studio Device File Explorer.
- În Exploratorul fișierului dispozitivului, navigați la sdcard / Descărcare. Ar trebui să găsiți imaginea previzualizată salvată în următorul format: _ori_.png
- Trageți această imagine din Android Studio și aruncați-o undeva ușor accesibilă, cum ar fi desktopul dvs.
- Dați acestui fișier imagine un nume descriptiv.
- Trageți și fixați fișierul în folderul desenabil al proiectului.
- Deschideți AppWidgetProviderInfo, care pentru acest proiect este collection_widget_info.xml.
- Găsiți linia Android: previewImage = ”@ mipmap / ic_launcher” și actualizați-o pentru a face referire la imaginea dvs. de previzualizare.
Widgetul dvs. va folosi acum această nouă resursă de imagine ca imagine de previzualizare:
- Instalați proiectul actualizat pe dispozitivul dvs. fizic Android sau pe AVD.
- Apăsați lung orice secțiune goală a ecranului de pornire.
- Atingeți Widgets, care lansează Widget Picker.
- Parcurgeți widgetul; ar trebui să folosească acum imaginea de previzualizare actualizată.
Widgeturi personalizabile: Adăugarea unei activități de configurare
O activitate de configurare se lansează automat atunci când utilizatorul plasează fiecare instanță a widgetului pe ecranul său de pornire.
Există mai multe motive pentru care poate doriți să adăugați o activitate de configurare la proiectul dvs.
widget-urile tind să ofere cea mai bună experiență de utilizator atunci când oferă acces la informații sau caracteristici care sunt cele mai importante pentru fiecare utilizator.
În primul rând, unele widgeturi necesită configurarea inițială, de exemplu, un widget care afișează alerte de trafic ar putea fi necesar să cunoască adresa de domiciliu a utilizatorului, unde lucrează și momentele în care se face naveta. Fără un fel de a introduce aceste informații, widget-ul dvs. ar putea fi complet inutil!
În plus, widget-urile tind să ofere cea mai bună experiență de utilizator atunci când oferă acces la informațiile sau funcțiile care sunt cele mai importante pentru fiecare utilizator. Prin adăugarea unei activități de configurare la proiectul dvs., puteți oferi utilizatorilor libertatea de a alege și alege exact ce este inclus în widget.
Chiar și personalizările relativ simple, cum ar fi schimbarea fundalului sau a fontului unui widget, pot avea un impact pozitiv asupra experienței utilizatorului - până la urmă, nimeni nu va aprecia un widget care se confruntă vizual cu restul ecranului lor de pornire!
Nimeni nu va aprecia un widget care se confruntă vizual cu restul ecranului lor de pornire!
În mod alternativ, uneori este posibil să aveți o listă lungă de conținut pe care doriți să-l includeți în widget și vă luptați să vă restrângeți opțiunile. O activitate de configurare poate fi o modalitate de a-ți folosi toate ideile într-un mod bun, fără crearea de un widget înfundat, confuz. Rețineți că configurarea unui widget nu ar trebui să se simtă ca o corvoadă, așa că dacă furnizați o activitate de configurare, atunci vă recomandăm să vă limitați la trei opțiuni de configurare.
Să adăugăm o activitate de configurare la proiectul nostru!
În primul rând, Activitatea noastră de configurare are nevoie de un aspect, deci creează un nou fișier de resurse de layout numit config_activity.xml.
Voi adăuga următoarele machete la acest aspect:
- Un buton de configurare. Într-un proiect din viața reală, acest buton ar modifica într-un fel widgetul, de exemplu, adăugarea sau eliminarea conținutului sau modificarea frecvenței actualizării widgetului. Pentru a vă menține codul simplu, făcând clic pe acest buton va fi afișat pur și simplu un toast Opțiuni de configurare.
- Un buton de configurare. Odată ce utilizatorul este mulțumit de modul în care este configurat widgetul său, apăsând acest buton va pune widget-ul nou configurat pe ecranul său de pornire.
Iată fișierul meu complet config_activity.xml:
Creați Activitatea de configurare
Acum, trebuie să ne creăm Activitatea de configurare.
Pentru a începe, creați o nouă clasă Java numită ConfigActivity. În această activitate, vom regăsi ID-ul widget-ului aplicației din intenția care a lansat Activitatea de configurare. Dacă această intenție nu are un ID de widget, atunci va trebui să apelăm la metoda finisare ():
Intenție intenție = getIntent (); Bundle extras = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
În continuare, trebuie să creăm o intenție de returnare, să trecem appWidgetId original și să stabilim rezultatele din activitatea de configurare:
Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, rezultatValue); finalizarea(); }}}
Dacă furnizați o Activitate de configurare, atunci difuzarea ACTION_APPWIDGET_UPDATE nu va fi trimisă automat la lansarea Activității de configurare, ceea ce înseamnă metoda onUpdate () nu va fi apelat atunci când utilizatorul creează o instanță a widgetului.
Pentru a vă asigura că widgetul dvs. este creat cu informații și conținut actualizate, Activitatea de configurare trebuie sa declanșează prima cerere onUpdate ().
Iată ConfigActivity completată:
import Android.app.Activitate; 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 extinde Activitatea {@Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (salvatInstanceState); setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Buton setupWidget = (Buton) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (nou OnClickListener () {@Override public void onClick (View v) {handleSetupWidget ();}}); Buton configButton = (Buton) findViewById (R.id.configButton); configButton.setOnClickListener (nou OnClickListener () {@Override public void onClick (View v) {handleConfigWidget ();}}); } private void handleSetupWidget () {showAppWidget (); } private void handleConfigWidget () {Toast.makeText (ConfigActivity.this, "Opțiuni de configurare", Toast.LENGTH_LONG) .show (); } int appWidgetId; private void showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Intenție intenție = getIntent (); Bundle extras = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // DO DO: Realizați configurația // Rezultatul intențieiValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, rezultatValue); finalizarea(); }}}
După ce ați creat o activitate de configurare, trebuie să declarați această activitate în Manifest și să specificați că acceptă acțiunea APPWIDGET_CONFIGURE:
În cele din urmă, având în vedere că o activitate de configurare este făcută referință în afara domeniului de aplicare al pachetului, trebuie să declaram această activitate în AppWidgetProviderInfo nostru, care în acest caz este fișierul collection_widget_info.xml:
Android: configurare = "com.jessicathornsby.collectionwidget.ConfigActivity">
Testarea proiectului tău
Acum este timpul să supuneți proiectului finalizat la test:
- Instalați proiectul actualizat pe un dispozitiv fizic Android sau pe AVD.
- Ștergeți toate instanțele anterioare ale widgetului, pentru a vă asigura că lucrați cu cea mai recentă versiune.
- Apăsați lung orice zonă goală a ecranului de domiciliu și selectați Widgeturi atunci când vi se solicită.
- Găsiți widget-ul în selectorul de widget și apăsați lung pentru a-l selecta.
- Aruncați widgetul pe ecranul de pornire. Activitatea de configurare ar trebui să se lanseze automat.
- Dați clic pe butonul Efectuați unele configurare și trebuie să apară un toast Opțiuni de configurare, confirmând că această interacțiune a fost înregistrată cu succes.
- Imaginați-vă că ați modificat setările widgetului și sunteți gata să îl plasați pe ecranul dvs. de pornire; dați clic pe butonul Create The Widget și acest widget ar trebui creat cu succes.
Puteți descărca proiectul de widget de colecție completat de la GitHub.
Înveliți
În acest articol, am creat un widget de colecție rulant care afișează un set de date pe ecranul de pornire al utilizatorului.
Dacă doriți să continuați să lucrați cu acest proiect, atunci puteți încerca să adăugați propriul cod la metoda onUpdate (), pentru a crea un widget care se actualizează cu informații noi la intervalul definit în fișierul dvs. AppWidgetProviderInfo (collection_widget_info).
Dacă creați un widget Android, asigurați-vă că vă împărtășiți creațiile în comentariile de mai jos!
