Contenuto
- Cosa sono i widget per Android?
- Il mio progetto ha davvero bisogno di un widget per l'applicazione?
- I widget per Android possono migliorare l'esperienza dell'utente
- Più potente delle scorciatoie dell'applicazione
- Crea un widget Android per favorire un coinvolgimento a lungo termine
- Creazione di un widget app di raccolta
- Costruire il layout del tuo widget
- Popolamento del widget di raccolta
- AppWidgetProvider: configurazione del widget
- Crea l'adattatore
- Definizione dei metodi del ciclo di vita del widget
- Recupero di nuovi contenuti con onUpdate
- onEnabled: esecuzione della configurazione iniziale
- Pulizia, con onDisabled
- AppWidgetProvider completato
- Il file AppWidgetProviderInfo
- 1. android: previewImage
- 2. android: widgetCategory
- 3. android: initialLayout
- 4. android: resizeMode = "orizzontale | verticale"
- 5. android: minHeight e android: minWidth
- 6. android: updatePeriodMillis
- AppWidgetProviderInfo completato
- Non ingombrare la schermata iniziale dell'utente!
- Invio di dati al widget
- Registrazione del widget in Manifest
- Metti alla prova il tuo widget
- Creazione di un'immagine di anteprima del widget Android
- Widget personalizzabili: aggiunta di un'attività di configurazione
- Crea l'attività di configurazione
- Testare il tuo progetto
- Avvolgendo
Sin dai primi giorni del sistema operativo, i widget per Android hanno consentito agli utenti di interagire con le loro app preferite, comodamente dalla propria schermata iniziale. Quindi, come si crea un widget Android?
Per lo sviluppatore, i widget offrono alla tua applicazione una preziosa presenza nella schermata iniziale dell'utente. Invece di essere nascosto nel cassetto dell'app, agli utenti verrà ricordato l'app ogni singola volta danno un'occhiata alla loro schermata iniziale, ottenendo anche un'anteprima dei contenuti più interessanti e utili della tua app.
I widget danno alla tua applicazione una presenza preziosa nella schermata iniziale dell'utente
In questo articolo, ti mostrerò come fornire un'esperienza utente migliore incoraggiando gli utenti a interagire con la tua app, creando un widget Android! Entro la fine di questo articolo, avrai creato un widget di raccolta scorrevole che visualizza un set di dati completo nella schermata iniziale dell'utente.
Per assicurarti di offrire il tipo di widget che gli utenti volere per posizionarli sulla loro schermata iniziale, creeremo anche un'attività di configurazione, che consentirà agli utenti di personalizzare il contenuto, l'aspetto e le funzionalità del widget. Infine, mostrerò come puoi incoraggiare le persone a utilizzare il tuo widget, creando un'immagine di anteprima del widget che mostra il meglio che il tuo widget ha da offrire.
Leggi anche: Sviluppare per dispositivi pieghevoli: cosa devi sapere
Cosa sono i widget per Android?
Un widget applicazione è un'applicazione leggera e in miniatura che vive nella schermata iniziale dell'utente.
I widget per Android possono fornire una vasta gamma di contenuti, ma generalmente rientrano in una delle seguenti categorie:
- Widget informativo. Questo è un widget non scorrevole che mostra alcune informazioni, come le previsioni del tempo di oggi o la data e l'ora.
- Widget di raccolta. Questo è un widget scorrevole che visualizza un set di dati correlati, formattato come ListView, GridView, StackView o AdapterViewFlipper. I widget di raccolta sono generalmente supportati da un'origine dati, ad esempio un database o un array.
- Widget di controllo. Questi widget fungono da telecomando che consente agli utenti di interagire con la tua applicazione, senza doverlo portare in primo piano. Le app che riproducono contenuti multimediali, come podcast o musica, spesso dispongono di widget di controllo che consentono all'utente di attivare le azioni Riproduci, Pausa e Salta direttamente dalla schermata principale.
- Widget ibridi. A volte potresti essere in grado di offrire un'esperienza utente migliore combinando elementi di più categorie. Ad esempio, se stai sviluppando un widget di controllo per un'applicazione musicale, puoi fornire i controlli Riproduci, Pausa e Salta, ma puoi anche decidere di visualizzare alcune informazioni, come il titolo del brano e l'artista. Se decidi di mescolare e abbinare, non lasciarti trasportare! I widget tendono a offrire la migliore esperienza utente quando forniscono un facile accesso a una piccola quantità di informazioni tempestive e pertinenti o ad alcune funzionalità di uso comune. Per aiutare a mantenere i widget ibridi leggeri, si consiglia di identificare la categoria principale del widget, svilupparla in base a tale categoria e poi aggiungi alcuni elementi dalla categoria secondaria del widget.
Il mio progetto ha davvero bisogno di un widget per l'applicazione?
Esistono diversi motivi per cui dovresti prendere in considerazione l'aggiunta di un widget applicazione al tuo progetto Android.
I widget per Android possono migliorare l'esperienza dell'utente
Come regola generale, meno passaggi di navigazione sono necessari per completare un'attività, migliore è l'esperienza dell'utente.
Fornendo un widget dell'applicazione, puoi rimuovere più passaggi di navigazione dai flussi più comunemente utilizzati della tua app. Nel migliore dei casi, i tuoi utenti saranno in grado di ottenere le informazioni di cui hanno bisogno semplicemente dando un'occhiata alla loro schermata principale o eseguendo l'attività desiderata semplicemente toccando un pulsante nel widget di controllo.
Più potente delle scorciatoie dell'applicazione
I widget delle app spesso rispondono agli eventi onClick avviando il livello principale nell'applicazione associata, in modo simile a un collegamento dell'applicazione. Tuttavia, i widget possono anche fornire accesso diretto ad attività specifiche all'interno di un'applicazione, ad esempio toccando la notifica Nuova ricevuta di un widget potrebbe avviare l'app associata con la nuova già aperta.
Incorporando più collegamenti nel layout del widget, puoi fornire un accesso con un tocco a tutte le attività più importanti della tua app, rimuovendo ancora più passaggi di navigazione dai flussi più comunemente utilizzati.
Incorporando più collegamenti nel layout del widget, puoi fornire un accesso con un tocco a tutte le attività più importanti della tua app.
Tieni presente che i widget rispondono solo agli eventi onClick, il che impedisce agli utenti di interagire accidentalmente con il tuo widget mentre stanno scorrendo nella schermata principale. L'unica eccezione è quando l'utente sta tentando di eliminare il widget trascinandolo verso l'azione Rimuovi della schermata Home, poiché in questo scenario il widget risponderà a un gesto di scorrimento verticale.
Questa interazione è gestita dal sistema Android, quindi non devi preoccuparti di implementare manualmente il supporto dello scorrimento verticale nel tuo widget.
Crea un widget Android per favorire un coinvolgimento a lungo termine
Convincere le persone a scaricare la tua app è solo il primo passo per creare un'applicazione Android di successo. È probabile che, se prendi il tuo smartphone o tablet Android e scorri il cassetto delle app, scoprirai più app che non hai utilizzato in giorni, settimane o potenzialmente anche mesi!
Leggi anche:Introduzione all'SDK di Facebook per Android
Una volta che l'app è stata installata correttamente sul dispositivo dell'utente, dovrai impegnarti a fondo per coinvolgerla e goderti la tua app. Dare alla tua app una presenza sulla schermata iniziale può essere un potente strumento per favorire un coinvolgimento a lungo termine, semplicemente perché è un promemoria costante dell'esistenza della tua applicazione!
Un widget ben progettato può anche fungere da annuncio in corso per la tua app. Ogni volta che l'utente guarda la propria schermata iniziale, il tuo widget ha l'opportunità di incoraggiarli attivamente a interagire nuovamente con la tua app, presentandoli con tutti i contenuti più interessanti e utili della tua app.
Creazione di un widget app di raccolta
In questo tutorial, creeremo un widget di raccolta che visualizza un array come ListView scorrevole.
Per aiutarti a tenere traccia del ciclo di vita del widget dell'app, questo widget attiverà anche vari brindisi mentre si sposta attraverso i diversi stati del ciclo di vita. Verso la fine di questo tutorial, potremo migliorare il nostro widget con un'immagine di anteprima personalizzata che verrà visualizzata nel Selettore widget di Android e un'attività di configurazione, che consentirà agli utenti di personalizzare il widget prima di posizionarlo sulla propria schermata principale.
Crea un nuovo progetto Android con le impostazioni che preferisci e cominciamo!
Costruire il layout del tuo widget
Per iniziare, definiamo l'interfaccia utente (UI) del widget.
I widget dell'applicazione vengono visualizzati in un processo al di fuori l'applicazione, in modo da poter utilizzare solo layout e viste supportati da RemoteViews.
Quando crei il layout, sei limitato a quanto segue:
- AnalogClock
- Pulsante
- Cronometro
- FrameLayout
- Layout della griglia
- ImageButton
- ImageView
- LinearLayout
- Barra di avanzamento
- RelativeLayout
- TextView
- ViewStub
- AdapterViewFlipper
- Vista a griglia
- Visualizzazione elenco
- StackView
- ViewFlipper
Si noti che le sottoclassi delle classi e viste sopra sono non supportato.
Creare un nuovo file di risorse di layout denominato list_widget.xml. Poiché visualizzeremo i nostri dati utilizzando un ListView, questo layout serve principalmente come contenitore per a Successivamente, dobbiamo creare un fornitore di dati per il nostro ListView. Creare una nuova classe Java denominata DataProvider.java e aggiungere quanto segue: import android.content.Context; import android.content.Intent; import android.widget.RemoteViews; import android.widget.RemoteViewsService; import java.util.ArrayList; import java.util.List; import android.R.id.text1 statico; import android.R.layout.simple_list_item_1 statico; DataProvider di classe pubblica implementa RemoteViewsService.RemoteViewsFactory {List Per creare un widget Android, è necessario creare più file. Il nostro primo file specifico del widget è un AppWidgetProvider, che è un BroadcastReceiver in cui definirai i vari metodi del ciclo di vita del widget, come il metodo che viene chiamato quando il widget viene creato per la prima volta e il metodo che viene chiamato quando quel widget viene infine eliminato. Creare una nuova classe Java (File> Nuovo> Classe Java) denominata CollectionWidget. Per iniziare, tutti i file del provider del widget devono estendersi dalla classe AppWidgetProvider. Dobbiamo quindi caricare il file di risorse del layout list_widget.xml in un oggetto RemoteViews e informare l'AppWidgetManager sull'oggetto RemoteViews aggiornato: la classe pubblica CollectionWidget estende AppWidgetProvider {static void updateAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Crea un'istanza dell'oggetto RemoteViews // Visualizzazioni RemoteViews = new RemoteViews (context.getPackageName (), R.layout.list_widget); setRemoteAdapter (contesto, viste); // Richiede che AppWidgetManager aggiorni il widget dell'applicazione // appWidgetManager.updateAppWidget (appWidgetId, viste); } Poiché stiamo visualizzando i nostri dati in un ListView, dobbiamo definire un metodo setRemoteAdapter () nel nostro AppWidgetProvider. SetRemoteAdapter () equivale a chiamare AbsListView.setRemoteViewsAdapter () ma è progettato per essere utilizzato nei widget dell'applicazione. In questo metodo, dobbiamo definire l'id di AdapterView (R.id.widget_list) e l'intenzione del servizio che alla fine fornirà i dati al nostro RemoteViewsAdapter - creeremo presto questa classe WidgetService. void statico privato setRemoteAdapter (Context context, @NonNull final RemoteViews views) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} Nel nostro AppWidgetProvider, dobbiamo anche definire i seguenti metodi del ciclo di vita del widget: Il metodo del ciclo di vita del widget onUpdate () è responsabile dell'aggiornamento delle visualizzazioni del widget con nuove informazioni. Questo metodo viene chiamato ogni volta: Questo è anche il punto in cui registrerai tutti i gestori di eventi che il tuo widget dovrebbe usare. Quando si aggiorna un widget Android, è importante ricordare che gli utenti possono creare più istanze dello stesso widget. Ad esempio, forse il tuo widget è personalizzabile e l'utente decide di creare diverse "versioni" che visualizzano informazioni diverse o forniscono accesso a funzionalità uniche. Quando chiami onUpdate (), devi specificare se stai aggiornando ogni istanza di questo widget o solo un'istanza specifica. Se vuoi aggiornare ogni istanza, puoi usare appWidgetIds, che è un array di ID che identifica ogni istanza sul dispositivo. Nel seguente frammento, sto aggiornando ogni istanza: @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {// Aggiorna tutte le istanze di questo widget // updateAppWidget (contesto, appWidgetManager, appWidgetId); } super.onUpdate (contesto, appWidgetManager, appWidgetIds); } Tieni presente che per aiutare a mantenere il codice semplice, questo metodo onUpdate () non sta attualmente apportando modifiche al widget. Il metodo del ciclo di vita onEnabled () viene chiamato in risposta a ACTION_APPWIDGET_ENABLED, che viene inviato quando un'istanza del widget viene aggiunta alla schermata principale per primo tempo. Se l'utente crea due istanze del widget, onEnabled () verrà chiamato per la prima istanza, ma non per il secondo. Il metodo del ciclo di vita onEnabled () è il punto in cui è necessario eseguire qualsiasi impostazione richiesta per tutte le istanze del widget, ad esempio la creazione del database che fornirà le informazioni sul widget. Visualizzerò un brindisi, quindi puoi vedere esattamente quando viene chiamato questo metodo del ciclo di vita: @Override public void onEnabled (Contesto contesto) {Toast.makeText (contesto, "onEnabled chiamato", Toast.LENGTH_LONG) .show (); } Si noti che se l'utente elimina tutte le istanze del widget e quindi crea una nuova istanza, questa viene classificata come prima istanza e verrà nuovamente chiamato il metodo del ciclo di vita onEnabled (). Il metodo onDisabled () viene chiamato in risposta a ACTION_APPWIDGET_DISABLED, che viene attivato quando l'utente elimina il scorso istanza del tuo widget. Questo metodo del ciclo di vita del widget è il punto in cui è necessario ripulire tutte le risorse create nel metodo onEnabled (), ad esempio eliminando il database creato in onEnabled (). Per aiutare a mantenere il nostro codice semplice, visualizzerò semplicemente un brindisi ogni volta che viene attivato questo metodo: @Override public void onDisabled (contesto di contesto) {Toast.makeText (contesto, "onDisabled chiamato", Toast.LENGTH_LONG) .show (); } Il tuo file CollectionWidget ora dovrebbe assomigliare a questo: 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; // Estende dalla classe AppWidgetProvider // La classe pubblica CollectionWidget estende AppWidgetProvider {static void updateAppWidget (Context context, AppWidgetManager appWidgetManager, int appWidgetId) {// Carica il file di risorse del layout in un oggetto RemoteViews // Visualizzazioni RemoteViews = nuovo RemoteViews (contesto. getPackageName (), R.layout.list_widget); setRemoteAdapter (contesto, viste); // Informa AppWidgetManager sull'oggetto RemoteViews // appWidgetManager.updateAppWidget (appWidgetId, views); } @Override public void onUpdate (Context context, AppWidgetManager appWidgetManager, int appWidgetIds) {for (int appWidgetId: appWidgetIds) {updateAppWidget (contesto, appWidgetManager, appWidgetId); } super.onUpdate (contesto, appWidgetManager, appWidgetIds); } @Override public void onEnabled (Contesto contesto) {Toast.makeText (contesto, "onEnabled chiamato", Toast.LENGTH_LONG) .show (); } @Override public void onDisabled (contesto di contesto) {Toast.makeText (contesto, "onDisabled chiamato", Toast.LENGTH_LONG) .show (); } vuoto statico privato setRemoteAdapter (Context context, @NonNull final RemoteViews views) {views.setRemoteAdapter (R.id.widget_list, new Intent (context, WidgetService.class)); }} Il widget dell'applicazione richiede anche un file AppWidgetProviderInfo, che definisce diverse proprietà importanti, tra cui le dimensioni minime del widget e la frequenza con cui deve essere aggiornato. Il file AppWidgetProviderInfo è archiviato nella cartella res / xml del progetto. Se il tuo progetto non contiene già questa cartella, dovrai crearla: Quindi, crea un file collection_widget_info, che useremo come AppWidgetProviderInfo: Nel nostro file AppWidgetProviderInfo, dobbiamo definire le seguenti proprietà: Questo è il disegno che rappresenta il widget dell'applicazione nel Selettore widget del dispositivo.Popolamento del widget di raccolta
AppWidgetProvider: configurazione del widget
Crea l'adattatore
Definizione dei metodi del ciclo di vita del widget
Recupero di nuovi contenuti con onUpdate
onEnabled: esecuzione della configurazione iniziale
Pulizia, con onDisabled
AppWidgetProvider completato
Il file AppWidgetProviderInfo
1. android: previewImage
Se non fornisci un'immagine di anteprima, Android utilizzerà invece l'icona della tua applicazione. Per incoraggiare gli utenti a selezionare il tuo widget dal Selettore widget, dovresti fornire un disegno che mostra come apparirà il tuo widget una volta configurato correttamente nella schermata iniziale dell'utente.
Il modo più semplice per creare un'immagine di anteprima è utilizzare l'applicazione Anteprima widget inclusa nell'emulatore Android. Questa app ti consente di configurare il tuo widget e quindi generare un'immagine, che puoi quindi utilizzare nel tuo progetto Android.
Creeremo questa immagine una volta terminata la creazione del nostro widget, quindi per ora userò la risorsa mipmap / ic_launcher generata automaticamente come immagine di anteprima temporanea.
2. android: widgetCategory
I widget dell'applicazione devono essere collocati all'interno di un host widget di app, che di solito è la schermata iniziale di Android, ma può anche essere un lanciatore di terze parti come Evie Launcher o Nova Launcher.
Tra i livelli API 17 e 20, è stato possibile posizionare i widget dell'applicazione sulla schermata iniziale o il lockscreen, ma il supporto del lockscreen è stato deprecato nel livello API 21.
Puoi specificare se il widget della tua app può essere posizionato sulla schermata iniziale, sulla schermata di blocco (che Android chiama "keyguard") o su entrambi, utilizzando l'attributo android: widgetCategory. Dal momento che non è possibile posizionare i widget sulla schermata di blocco nelle versioni più recenti di Android, ci rivolgeremo solo alla schermata iniziale.
Per preservare la privacy dell'utente, il tuo widget non dovrebbe mostrare alcuna informazione sensibile o privata quando viene inserito nella schermata di blocco.
Se offri agli utenti la possibilità di posizionare il tuo widget sulla schermata di blocco, chiunque guardi il dispositivo dell'utente potrebbe potenzialmente vedere il tuo widget e tutto il suo contenuto. Per aiutare a preservare la privacy dell'utente, il tuo widget non dovrebbe mostrare alcuna informazione sensibile o privata quando viene inserito nella schermata di blocco. Se il tuo widget contiene dati personali, ti consigliamo di fornire layout separati per schermata iniziale e schermata di blocco.
3. android: initialLayout
Questo è il file di risorse di layout che il tuo widget dovrebbe usare quando viene posizionato nella schermata iniziale, che per il nostro progetto è list_widget.xml.
4. android: resizeMode = "orizzontale | verticale"
L'attributo android: resizeMode ti consente di specificare se il tuo widget può essere ridimensionato orizzontalmente, verticalmente o lungo entrambi gli assi.
Per garantire che il widget venga visualizzato e funzioni correttamente su una varietà di schermate, si consiglia di consentire il ridimensionamento orizzontale del widget e in verticale, a meno che tu non abbia un motivo specifico per non farlo.
5. android: minHeight e android: minWidth
Se il tuo widget è ridimensionabile, devi assicurarti che l'utente non lo riduca al punto in cui diventa inutilizzabile. Puoi utilizzare gli attributi minHeight e minWidth per definire il più piccolo in cui la tua app verrà ridotta quando viene ridimensionata dall'utente.
Questi valori rappresentano anche la dimensione iniziale del tuo widget, quindi se il tuo widget non è ridimensionabile, minHeight e minWidth definiranno il dimensionamento permanente del widget.
6. android: updatePeriodMillis
AppWidgetProviderInfo indica anche la frequenza con cui il widget deve richiedere nuove informazioni.
L'intervallo di aggiornamento supportato più piccolo è una volta ogni 1800000 millisecondi (30 minuti). Anche se dichiari un intervallo di aggiornamento più breve, il tuo widget verrà comunque aggiornato solo ogni mezz'ora.
Mentre potresti voler visualizzare le informazioni più recenti il più rapidamente possibile, il sistema volontà riattivare un dispositivo per dormire per recuperare nuove informazioni. Aggiornamenti frequenti possono bruciare attraverso la batteria di un dispositivo, in particolare durante i periodi in cui il dispositivo viene lasciato inattivo per un periodo di tempo significativo, ad esempio durante la notte. Fornire la migliore esperienza utente possibile significa trovare un equilibrio tra limitare il consumo della batteria e fornire nuove informazioni in tempi ragionevoli.
Dovresti anche tenere conto del tipo di contenuto che verrà visualizzato dal tuo widget.
Dovresti anche tenere conto del tipo di contenuto che verranno visualizzati dai tuoi widget per Android. Ad esempio, un widget meteo potrebbe dover recuperare una previsione aggiornata solo una volta al giorno, mentre un'app che visualizza le ultime notizie dovrà aggiornarsi più frequentemente.
Per trovare questo equilibrio perfetto, potrebbe essere necessario testare il widget su una gamma di frequenze di aggiornamento e misurare l'impatto sulla durata della batteria e la tempestività dei contenuti del widget. Se disponi di un gruppo disponibile di tester, puoi anche impostare il test A / B, per vedere se alcune frequenze di aggiornamento vengono ricevute più positivamente di altre.
Inoltre leggi: AndroidManifest.xml tutto ciò che devi sapere
Infine, una volta identificato l'intervallo di aggiornamento perfetto, potresti voler utilizzare un intervallo più breve durante lo sviluppo e il test della tua app. Ad esempio, potresti utilizzare la frequenza di aggiornamento più breve possibile (android: updatePeriodMillis = "1800000 ″) quando stai testando che il metodo onUpdate () della tua app si sta attivando correttamente, quindi modifica questo valore prima di rilasciare la tua app al pubblico.
AppWidgetProviderInfo completato
Il file collection_widget_info.xml finito dovrebbe assomigliare a questo:
Non ingombrare la schermata iniziale dell'utente!
Per garantire che la schermata iniziale non sia mai ingombra, aggiungeremo un po 'di riempimento e margini al nostro widget. Se il tuo progetto non contiene già un file dimens.xml, dovrai crearne uno:
- Fai clic tenendo premuto il tasto Ctrl sulla cartella dei valori del tuo progetto.
- Seleziona Nuovo> Valori file di risorse.
- Dai a questo file il nome dimens.
- Clicca OK.
Apri il tuo file dimens.xml e definisci i seguenti valori di margine e riempimento:
Invio di dati al widget
Successivamente, dobbiamo creare un servizio di widget, che sarà responsabile per l'invio dei dati della nostra raccolta al widget.
Creare una nuova classe Java (Nuova> Classe Java) denominata WidgetService e aggiungere quanto segue:
import android.content.Intent; import android.widget.RemoteViewsService; classe pubblica WidgetService estende RemoteViewsService {@Override RemoteViewsFactory pubblico suGetViewFactory (intento intento) {restituisce nuovo DataProvider (questo, intento); }}
Registrazione del widget in Manifest
Ora dobbiamo apportare alcune modifiche al manifest del nostro progetto.
Per iniziare, apri il Manifest e registra il tuo widget come BroadcastReceiver. Dobbiamo anche aggiungere un filtro intent per l'azione android.appwidget.action.APPWIDGET_UPDATE:
Successivamente, è necessario specificare il provider del widget dell'app:
Infine, dobbiamo dichiarare il servizio che invierà i dati al nostro widget, che in questa istanza è la classe WidgetService. Questo servizio richiede l'autorizzazione android.permission.BIND_REMOTEVIEWS:
Metti alla prova il tuo widget
Se hai seguito questo tutorial, ora avrai un widget di raccolta completo che mostra una serie di dati nella schermata iniziale dell'utente.
Se si trattasse di un progetto Android nella vita reale, in genere si espanderebbe sui metodi del ciclo di vita, in particolare il metodo onUpdate (), ma è tutto ciò che serve per creare un widget che è possibile installare e testare sul proprio dispositivo Android:
- Installa questo progetto su uno smartphone, tablet o AVD Android compatibile (dispositivo virtuale Android).
- Premi a lungo qualsiasi sezione vuota della schermata iniziale e seleziona Widget quando richiesto; questo avvia il Widget Picker.
- Scorri il Selettore widget fino a trovare il widget dell'applicazione appena creato.
- Premi a lungo questo widget per aggiungerlo alla tua schermata iniziale.
- Poiché questa è la prima istanza di questo particolare widget, dovrebbe essere eseguito il metodo onEnabled () e vedrai un toast "onEnabled chiamato".
- Ridimensiona il tuo widget. Se si imposta una dimensione minima supportata, verificare che non sia possibile ridurre il widget oltre questo valore.
- Verificare che ListView scorra, come previsto.
- Successivamente, è necessario controllare il metodo onDisabled (), eliminando il widget. Premi a lungo il widget, quindi seleziona Rimuovi dalla schermata principale. Poiché questa è l'ultima istanza di questo particolare widget, dovrebbe essere eseguito il metodo onDisabled () e vedrai un toast "onDisabled chiamato".
Questo è tutto ciò di cui hai bisogno per fornire un widget dell'applicazione Android funzionante, ma ci sono alcune aggiunte che spesso possono migliorare l'esperienza dell'utente. Nelle sezioni seguenti, incoraggeremo gli utenti a scegliere questo widget dal Selettore widget, creando un'immagine di anteprima che mostri il widget al meglio. Ti mostrerò anche come creare un widget completamente personalizzabile, aggiungendo un'attività di configurazione al tuo progetto.
Creazione di un'immagine di anteprima del widget Android
Se prendi il tuo dispositivo Android e scorri il Selettore widget, vedrai che ogni widget è rappresentato da un'immagine, il che di solito dimostra come apparirà questo widget una volta configurato nella schermata iniziale dell'utente.
Per incoraggiare gli utenti a selezionare il tuo widget, devi fornire un'immagine di anteprima che evidenzi tutte le informazioni utili e le funzionalità che il tuo widget ha da offrire.
Puoi creare rapidamente e facilmente un'immagine di anteprima, utilizzando l'applicazione Anteprima widget inclusa nell'emulatore Android.
Tieni presente che l'anteprima del widget non è inclusa nelle immagini di sistema Android più recenti, quindi dovrai creare un AVD usando Nougat (API Level 25) o precedente:
- Installa la tua applicazione su un AVD che esegue API 25 o precedente.
- Apri il cassetto delle app di AVD e avvia l'app Anteprima widget.
- L'anteprima del widget mostrerà un elenco di tutte le applicazioni attualmente installate su questo AVD; seleziona la tua applicazione dall'elenco.
- Il widget verrà ora visualizzato su uno sfondo vuoto. Dedica un po 'di tempo al ridimensionamento e alla modifica del tuo widget fino a quando non mostra il meglio che il tuo widget ha da offrire.
- Quando sei soddisfatto dell'aspetto e dei contenuti del tuo widget, seleziona Scatta istantanea.
- Per recuperare la tua istantanea, torna ad Android Studio e seleziona Visualizza> Strumenti Windows> Esplora file dispositivo dalla barra degli strumenti. Questo avvia Esplora file dispositivo di Android Studio.
- In Esplora file dispositivo, vai su sdcard / Download. Dovresti trovare l'immagine di anteprima salvata nel seguente formato: _ori_.png
- Trascina questa immagine da Android Studio e rilasciala in un punto facilmente accessibile, come ad esempio il tuo desktop.
- Assegna a questo file immagine un nome descrittivo.
- Trascina e rilascia il file nella cartella disegnabile del tuo progetto.
- Apri AppWidgetProviderInfo, che per questo progetto è collection_widget_info.xml.
- Trova la linea android: previewImage = "@ mipmap / ic_launcher" e aggiornala per fare riferimento all'immagine di anteprima.
Il tuo widget ora utilizzerà questa nuova risorsa immagine come immagine di anteprima:
- Installa il progetto aggiornato sul tuo dispositivo Android fisico o AVD.
- Premi a lungo qualsiasi sezione vuota della schermata iniziale.
- Tocca Widget, che avvia Selezione widget.
- Scorri fino al tuo widget; ora dovrebbe utilizzare l'immagine di anteprima aggiornata.
Widget personalizzabili: aggiunta di un'attività di configurazione
Un'attività di configurazione si avvia automaticamente quando l'utente posiziona ciascuna istanza del widget sulla propria schermata principale.
Esistono diversi motivi per cui potresti voler aggiungere un'attività di configurazione al tuo progetto.
i widget tendono a fornire la migliore esperienza utente quando forniscono accesso alle informazioni o alle funzionalità più importanti per il singolo utente.
In primo luogo, alcuni widget richiedono una configurazione iniziale, ad esempio un widget che visualizza gli avvisi sul traffico potrebbe dover conoscere l'indirizzo di casa dell'utente, il luogo in cui lavora e i tempi in cui di solito si spostano. Senza un modo per inserire queste informazioni, il tuo widget potrebbe essere completamente inutile!
Inoltre, i widget tendono a fornire la migliore esperienza utente quando forniscono accesso alle informazioni o alle funzionalità più importanti per il singolo utente. Aggiungendo un'attività di configurazione al tuo progetto, puoi dare agli utenti la libertà di scegliere Esattamente cosa è incluso nel tuo widget.
Anche personalizzazioni relativamente semplici, come la modifica dello sfondo o del carattere di un widget, possono avere un impatto positivo sull'esperienza dell'utente - dopo tutto, nessuno apprezzerà un widget che si scontra visivamente con il resto della propria schermata iniziale!
Nessuno apprezzerà un widget che si scontra visivamente con il resto della loro schermata iniziale!
In alternativa, a volte potresti avere un lungo elenco di contenuti che desideri includere nel tuo widget e stai lottando per restringere le opzioni. Un'attività di configurazione può essere un modo per mettere a frutto tutte le idee, senza la creazione di un widget disordinato e confuso. Ricorda solo che la configurazione di un widget non dovrebbe essere un lavoro ingrato, quindi se fornisci un'attività di configurazione, ti consigliamo di limitarti a tre opzioni di configurazione.
Aggiungiamo un'attività di configurazione al nostro progetto!
Innanzitutto, la nostra attività di configurazione richiede un layout, quindi crea un nuovo file di risorse di layout denominato config_activity.xml.
Aggiungerò i seguenti pulsanti a questo layout:
- Un pulsante di configurazione. In un progetto di vita reale, questo pulsante modifica il widget in qualche modo, ad esempio aggiungendo o rimuovendo contenuto o modificando la frequenza con cui il widget si aggiorna. Per aiutare a mantenere semplice il nostro codice, facendo clic su questo pulsante verrà semplicemente visualizzato un toast delle opzioni di configurazione.
- Un pulsante di configurazione. Una volta che l'utente è soddisfatto della configurazione del proprio widget, premendo questo pulsante si posizionerà il widget appena configurato sulla propria schermata principale.
Ecco il mio file config_activity.xml completato:
Crea l'attività di configurazione
Ora, dobbiamo creare la nostra attività di configurazione.
Per iniziare, crea una nuova classe Java denominata ConfigActivity. In questa attività, recupereremo l'ID widget app dall'intento che ha avviato l'attività di configurazione. Se questo intento non ha un ID widget, allora dovremo chiamare il metodo finish ():
Intent intent = getIntent (); Pacchetti extra = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); }
Successivamente, dobbiamo creare un intento di ritorno, passare l'appWidgetId originale e impostare i risultati dall'attività di configurazione:
Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); finire(); }}}
Se fornisci un'attività di configurazione, la trasmissione ACTION_APPWIDGET_UPDATE non verrà inviata automaticamente all'avvio dell'attività di configurazione, il che significa che il metodo onUpdate () non lo farà essere chiamato quando l'utente crea un'istanza del widget.
Per garantire che il tuo widget sia creato con informazioni e contenuti aggiornati, la tua attività di configurazione dovere attiva la prima richiesta onUpdate ().
Ecco il ConfigActivity completato:
import android.app.Activity; 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; classe pubblica ConfigActivity estende l'attività {@Override Protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.config_activity); setResult (RESULT_CANCELED); Button setupWidget = (Button) findViewById (R.id.setupWidget); setupWidget.setOnClickListener (new OnClickListener () {@Override public void onClick (View v) {handleSetupWidget ();}}); Button configButton = (Button) findViewById (R.id.configButton); configButton.setOnClickListener (new OnClickListener () {@Override public void onClick (View v) {handleConfigWidget ();}}); } handle di vuoto privatoSetupWidget () {showAppWidget (); } private void handleConfigWidget () {Toast.makeText (ConfigActivity.this, "Opzioni di configurazione", Toast.LENGTH_LONG) .show (); } int appWidgetId; void privato showAppWidget () {appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID; Intent intent = getIntent (); Pacchetti extra = intent.getExtras (); if (extras! = null) {appWidgetId = extras.getInt (AppWidgetManager.EXTRA_APPWIDGET_ID, AppWidgetManager.INVALID_APPWIDGET_ID); if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {finish (); } // DA FARE: eseguire la configurazione // Intent resultValue = new Intent (); resultValue.putExtra (AppWidgetManager.EXTRA_APPWIDGET_ID, appWidgetId); setResult (RESULT_OK, resultValue); finire(); }}}
Dopo aver creato un'attività di configurazione, devi dichiararla nel Manifest e specificare che accetta l'azione APPWIDGET_CONFIGURE:
Infine, poiché un'attività di configurazione viene referenziata al di fuori dell'ambito del pacchetto, è necessario dichiararla nel nostro AppWidgetProviderInfo, che in questo caso è il file collection_widget_info.xml:
Android: configure = "com.jessicathornsby.collectionwidget.ConfigActivity">
Testare il tuo progetto
Ora è il momento di mettere alla prova il tuo progetto finito:
- Installa il tuo progetto aggiornato su un dispositivo Android fisico o AVD.
- Elimina tutte le precedenti istanze del tuo widget, per assicurarti di lavorare con la versione più recente.
- Premi a lungo qualsiasi area vuota della schermata iniziale e seleziona Widget quando richiesto.
- Trova il tuo widget nel Selettore widget e premi a lungo per selezionarlo.
- Rilascia il widget sul tuo homescreen. L'attività di configurazione dovrebbe avviarsi automaticamente.
- Fai clic sul pulsante Esegui alcune configurazioni e dovrebbe apparire un brindisi con le opzioni di configurazione, a conferma che questa interazione è stata registrata correttamente.
- Immagina di aver modificato le impostazioni del widget e ora sei pronto per posizionarlo sulla tua schermata iniziale; dare un tocco al pulsante Crea il widget e questo widget dovrebbe essere creato con successo.
È possibile scaricare il progetto del widget di raccolta completato da GitHub.
Avvolgendo
In questo articolo, abbiamo creato un widget di raccolta scorrevole che visualizza un set di dati nella schermata iniziale dell'utente.
Se vuoi continuare a lavorare con questo progetto, allora potresti provare ad aggiungere il tuo codice al metodo onUpdate (), per creare un widget che si aggiorna con nuove informazioni all'intervallo definito nel tuo file AppWidgetProviderInfo (collection_widget_info).
Se crei un widget Android, assicurati di condividere le tue creazioni nei commenti qui sotto!
