Share
Lo sviluppo di widget per la piattaforma Android comporta un insieme leggermente diverso di compiti rispetto allo sviluppo di app standard. In questa serie di tutorial, lavoreremo attraverso il processo di sviluppo di un widget orologio analogico personalizzabile. L'orologio sarà basato sulla classe Android AnalogClock e personalizzato con la tua grafica.
Finora in questa serie sullo sviluppo di un widget orologio analogico personalizzato per Android abbiamo impostato il progetto e creato gli elementi di progettazione principali. In questa parte, implementeremo la classe widget Java, gestendo gli aggiornamenti e avviando l'app. Lavoreremo su due classi Java, una che estenderà la classe AppWidgetProvider e l'altra una classe Attività che verrà avviata se l'utente tenta di avviare l'app. Lavoreremo anche sul file di layout per l'attività di lancio. Dopo questo tutorial, avrai un widget orologio funzionante che verrà aggiornato continuamente per riflettere l'ora corrente.
Nella parte finale della serie consentiremo all'utente di fare una scelta dalla selezione di modelli di orologio creati l'ultima volta.
Questa è la terza parte della nostra serie sulla costruzione di un orologio analogico Android personalizzabile su quattro tutorial:
Le app per widget estendono la classe AppWidgetProvider in Android, quindi è quello che faremo qui. In questa classe è possibile fornire passaggi di elaborazione per l'aggiornamento del widget mentre viene eseguito nella schermata iniziale dell'utente. La nostra attività di avvio utilizzerà il file di layout XML principale per visualizzare una risorsa String definita nel primo tutorial. In questo tutorial copriremo anche l'uso delle icone di avvio (e opzionalmente di anteprima) per la nostra app di widget.
Potresti ricordare che nel primo tutorial, abbiamo deciso di includere un'attività di avvio nell'app widget. Questa non è una necessità, ma offre un paio di vantaggi. Gli utenti che non sono a conoscenza di come avviare un'app widget vedranno le istruzioni su come avviarlo. Inoltre, i dispositivi con Android 4.0 a volte non riescono a includere nuove app di widget nel menu, ma fornire un'attività di avvio sembra aggirare il problema.
Quando hai creato il tuo progetto in Eclipse, se hai specificato un'attività iniziale per l'app, Eclipse avrebbe dovuto creare una classe Java per esso. Usando i passi predefiniti descritti nella Parte 1, dovresti avere una classe Java nel tuo pacchetto di progetto chiamato "CustomClockWidgetActivity" o un nome alternativo se lo hai cambiato. Apri questo in Eclipse - dovrebbe contenere il seguente schema:
// package name import android.app.Activity; importare android.os.Bundle; public class CustomClockWidgetActivity estende l'attività / ** chiamata quando l'attività viene creata per la prima volta. * / @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.main);
Se Eclipse non ha creato la classe, crearla ora e aggiungere il codice, modificando il nome della classe, se necessario. Possiamo effettivamente utilizzare il comportamento predefinito di questa classe di attività principale e lasciare il codice così com'è. Si noti che il codice specifica il layout XML principale per la sua visualizzazione del contenuto. Modificheremo il file di layout XML principale accanto ai dettagli della nostra app widget.
L'attività dovrebbe essere già inclusa nel file manifest del progetto come segue:
Qui indichiamo che questa attività dovrebbe iniziare all'avvio dell'app. Questo è il modo in cui un'attività di avvio è elencata all'interno di Manifest per un'app standard (non widget). Sebbene il nostro widget venga generalmente inserito aggiungendo alla schermata iniziale dell'utente, stiamo fornendo un'attività di avvio per i motivi sopra menzionati.
Aprire il file di layout XML principale: "res / layout / main.xml". Eclipse avrebbe dovuto creare questo file quando hai creato il progetto. La maggior parte di questo file può essere lasciata con il codice predefinito, ma vogliamo aggiungere il seguente attributo all'elemento TextView per migliorare la leggibilità:
Android: padding = "10dp"
Il tuo file di layout XML principale dovrebbe ora apparire come segue:
Il layout mostra semplicemente la stringa di testo "ciao" che abbiamo modificato nella parte 1 di questa serie. La stringa istruisce l'utente in termini di come aggiungere il widget alla sua schermata iniziale. Ricorda che abbiamo incluso due versioni di String, una nella cartella "values" e una nella cartella "values-v14", in modo da poter adattare le istruzioni alla versione di Android che l'utente ha installato.
Con un'app widget, l'icona del programma di avvio viene visualizzata negli elenchi di app. Nel nostro caso, apparirà anche nel menu principale del dispositivo utente perché abbiamo fornito un'attività di lancio. Puoi creare un'immagine di anteprima per il tuo widget, se lo desideri, ma se non lo fai, l'icona di avvio apparirà nelle anteprime dei widget. Per gli utenti che utilizzano Android 4.0 e versioni successive, i widget vengono aggiunti dalla scheda Widget nel menu del dispositivo. All'interno di questa sezione del menu, viene visualizzata l'immagine di anteprima o viene visualizzata l'icona di avvio se non è stata fornita l'anteprima. Nei precedenti livelli API l'anteprima o l'icona appare all'interno del selettore widget, dopo aver premuto a lungo la schermata iniziale.
Per il nostro widget orologio utilizzeremo solo un'icona di avvio, quindi crea il tuo adesso - puoi utilizzare il seguente set se non vuoi ancora progettare il tuo:
Utilizza la seguente guida alle dimensioni massime per le tue icone ad ogni densità:
Se si utilizza il nome file "ic_launcher" per l'icona di avvio, non è necessario modificare alcun codice come gli strumenti predefiniti per questo nome. Verifica che il tuo progetto stia effettivamente utilizzando questo nome aprendo il file Manifest e controllando l'attributo dell'icona dell'elemento dell'applicazione, che dovrebbe apparire come segue:
Android: icon = "@ drawable / ic_launcher"
Se non viene visualizzato in questo modo, modificare il codice in modo che corrisponda al nome che si desidera utilizzare per l'icona di avvio. Salva le tue copie dell'icona in ogni cartella drawable, ricordando di usare lo stesso nome in ogni cartella (ma il contenuto dell'immagine con varie dimensioni per adattarsi a ciascuna densità). Se stai creando le tue icone di avvio, prova a far sì che riflettano l'aspetto e la funzione del tuo widget orologio in modo che gli utenti possano creare intuitivamente il collegamento tra l'icona e il widget.
Se si desidera creare immagini di anteprima per le app del widget, è possibile utilizzare l'applicazione Anteprima widget. Esegui un'app di widget su un AVD in Eclipse (per il widget dell'orologio puoi farlo alla fine di questo tutorial o il prossimo) - assicurati che l'AVD abbia allocata memoria su una scheda SD. Apri il menu del dispositivo di emulazione e seleziona l'app Anteprima widget. Scegli il tuo widget dall'elenco. Quando viene visualizzata l'immagine del widget, fai clic su "Scatta istantanea" per acquisire un'anteprima.
È quindi possibile salvare l'anteprima direttamente sul computer da Eclipse. Per fare ciò, apri la prospettiva DDMS, seleziona il tuo emulatore nella vista Dispositivi e cerca l'immagine nella vista Esplora file (guarda nella directory Download sulla scheda SD). Seleziona il file immagine di anteprima e fai clic sul pulsante "Pull a File From the Device" per salvare l'immagine sul tuo file system locale.
Una volta ottenuta l'immagine di anteprima, copiarla nelle cartelle disegnabili del progetto ed elencarne il nome nel file delle proprietà del widget "res / xml" elemento "appwidget-provider", accanto alle dimensioni, al periodo di aggiornamento e ai valori iniziali del layout, utilizzando il seguente attributo:
Android: previewImage = "@ drawable / clock_preview"
Ciò si applicherebbe a un file immagine denominato, ad esempio, "clock_preview.png" salvato in ciascuna cartella drawable pertinente.
Ora passiamo alla classe Java per il nostro widget orologio. Ricorda che nel Manifest del progetto abbiamo incluso un elemento ricevente che indica una classe chiamata "ClockWidget" - la creeremo in seguito. Prenditi un momento per guardare al Manifest ora prima di implementare la tua classe. Si noti che l'elemento ricevitore include l'azione "APPWIDGET_UPDATE" e specifica i metadati comprendenti il file XML "clock_widget" in cui sono state definite le proprietà del widget di base.
Crea ora la classe del tuo widget facendo clic con il pulsante destro del mouse o selezionando il pacchetto dell'app principale nella directory "src" e scegliendo "File", quindi "Nuovo", "Classe" - inserisci "ClockWidget" per abbinare il nome al Manifest. Eclipse dovrebbe aprire il tuo nuovo file di classe. Estendi la riga di dichiarazione della classe di apertura come segue:
la classe pubblica ClockWidget estende AppWidgetProvider
Dovrai aggiungere la seguente dichiarazione di importazione sopra questa riga all'inizio della classe:
import android.appwidget.AppWidgetProvider;
Aggiungi una variabile di istanza all'interno della dichiarazione della classe come segue:
Viste RemoteViews;
Questo ci consentirà di fare riferimento all'interfaccia utente / elementi visibili per il widget, che richiede un processo leggermente diverso nelle classi di widget rispetto alle classi di attività. Le viste remote ci consentono di fare riferimento al layout del widget e alle viste al suo interno. Questo è essenziale quando si aggiornano e si forniscono funzioni interattive per il widget. Avrai bisogno di un'altra dichiarazione di importazione:
importare android.widget.RemoteViews;
Quindi aggiungere il contorno del metodo "onReceive" all'interno della classe come segue:
public void onReceive (Context context, Intent intent)
AppWidgetProvider eredita questo metodo dalla classe BroadcastReceiver. Nel prossimo tutorial, utilizzeremo questo metodo per gestire i clic sul widget dell'orologio. Per il momento, tutto ciò che dobbiamo fare è istruire Android ad aggiornare l'aspetto del widget quando il metodo viene eseguito. Aggiungi prima le seguenti istruzioni di importazione:
importare android.content.Context; import android.content.Intent;
All'interno del metodo "onReceive", includere un test condizionale per verificare se il metodo è in esecuzione perché il widget deve essere aggiornato:
// scopri l'azione String action = intent.getAction (); // è il momento di aggiornare se (AppWidgetManager.ACTION_APPWIDGET_UPDATE.equals (azione))
Aggiungi un'altra dichiarazione di importazione:
import android.appwidget.AppWidgetManager;
All'interno dell'istruzione "if", recupera le viste remote per il layout del nostro widget, creando un'istanza della variabile di istanza creata come segue:
views = new RemoteViews (context.getPackageName (), R.layout.clock_widget_layout);
Si noti che utilizziamo l'oggetto Context passato al metodo "onReceive" per recuperare il nome del pacchetto. Abbiamo specificato il file di layout del widget dell'orologio su cui abbiamo lavorato nell'ultimo tutorial: se hai usato un nome di file diverso, modifica questo codice per rifletterlo. Ora aggiorna il widget aggiungendo il seguente codice, sempre all'interno dell'istruzione "if":
AppWidgetManager.getInstance (context) .updateAppWidget (intent.getIntArrayExtra (AppWidgetManager.EXTRA_APPWIDGET_IDS), viste);
Qui usiamo AppWidgetManager per chiamare l'aggiornamento, passando l'oggetto Viste remote come riferimento. Ora puoi eseguire l'app per widget per vedere il suo aspetto e comportamento di default. Quando l'app viene inizialmente installata / avviata, viene avviata l'attività di avvio:
L'attività di lancio è puramente informativa quindi è meglio in generale mantenerla semplice, a meno che non abbia in mente qualche altro scopo. Oltre a questo sentiti libero di alterare il suo aspetto nel modo che preferisci. Le seguenti schermate mostrano il widget che viene aggiunto dal menu del dispositivo dell'utente su Ice Cream Sandwich:
Si noti che l'icona di avvio viene visualizzata nel menu Widget: se si include un'immagine di anteprima e la si elenca nel widget XML, verrà visualizzata qui. Infine, il widget orologio viene eseguito utilizzando il suo design predefinito:
Gli elementi di base del widget Orologio analogico sono ora completi. Nella prossima e ultima parte della serie di tutorial, implementeremo consentendo all'utente di scegliere un design di orologio. Il design dell'orologio predefinito è attualmente visualizzato perché nell'ultimo tutorial abbiamo impostato gli altri disegni come invisibili. Gestiremo i clic dell'utente sul widget aggiungendo funzionalità alla classe del widget. Utilizzeremo anche una nuova attività per visualizzare la selezione di disegni di clock per l'utente, rilevando quale seleziona e aggiorna l'aspetto del widget di conseguenza. Infine, utilizzeremo l'applicazione Preferenze condivise per archiviare un record di quale disegno del widget è stato selezionato dall'utente, rendendolo personalizzabile.
Accentsconagua