Share
Le applicazioni Android sono comunemente suddivise in aree funzionali in cui ciascuna di esse è legata a una classe di attività che determina la visualizzazione e il comportamento di uno schermo specifico. A volte vuoi informare condizionatamente l'utente di qualcosa o chiedergli un input specifico, ma non vuoi visualizzare quelle informazioni sullo schermo stesso. Ecco due opzioni fondamentali: puoi avviare una classe Attività figlio per un risultato specifico, quindi tornare all'attività originale oppure puoi utilizzare una comoda funzione disponibile per le classi Attività: finestre di dialogo.
Oggi parleremo dei dialoghi, di cosa possono essere utilizzati e di come vengono creati e utilizzati. Inizieremo quindi le fasi di implementazione di una finestra di dialogo di base all'interno di una classe di attività dall'inizio alla fine. Seguiremo questo tutorial con alcune ricette QuickTut per diversi tipi di finestre di dialogo che potresti voler utilizzare nelle tue tipiche app Android. Ma prima devi capire il ciclo di vita di una finestra di dialogo Attività.
La classe Android Dialog (android.app.Dialog) è la classe base per tutti i tipi di controlli di dialogo che è possibile utilizzare nelle classi di attività. Le finestre di dialogo vivono all'interno del ciclo di vita della tua attività (android.app.Activity). Si aprono in primo piano, bloccando la schermata Attività, per attirare l'attenzione dell'utente per una serie di motivi.
Prendi nota delle prove future delle tue app e della creazione di applicazioni a frammentazione: Questo tutorial utilizzerà il metodo tradizionale per la gestione di finestre di dialogo di base all'interno di un'attività semplice. Alcuni di questi metodi sono stati recentemente deprecati. La documentazione di Android SDK ora consiglia che se si desidera utilizzare le finestre di dialogo, è necessario installare la libreria di compatibilità e utilizzare invece la classe DialogFragment. Una volta acquisite le nozioni di base del ciclo di vita di Dialog, è anche possibile controllare la classe DialogFragment (android.app.DialogFragment). Tuttavia, tale approccio va oltre lo scopo di questa discussione di dialogo di base in quanto richiede l'installazione e l'uso della libreria di compatibilità per supportare i Dialoghi nelle versioni precedenti di Android SDK (lo illustreremo in un prossimo tutorial). Mentre i metodi che discutiamo qui sono elencati come deprecati, il nuovo modo di fare le finestre di dialogo non è stato introdotto fino a Honeycomb, quindi questa soluzione continuerà a funzionare bene su tutti i dispositivi.
Le finestre di dialogo sono utili quando si desidera:
Una nota sui messaggi di pane tostato: Alcuni sviluppatori usano anche i messaggi Toast (android.widget.Toast) per l'invio di semplici notifiche o messaggi all'utente. Un messaggio di Toast viene visualizzato sulla schermata Attività per alcuni secondi e quindi scompare automaticamente. L'utente non ha alcuna possibilità di interagire con un messaggio Toast. Ci piace pensare che la linea di demarcazione tra quando utilizzare un Toast su una finestra di dialogo sia la seguente: se l'utente viene informato di informazioni non essenziali, utilizzare un Toast, ma quando l'informazione presentata è di vitale importanza, utilizzare una finestra di dialogo. Usiamo Toasts come notifiche informative molto leggere. Tutte le informazioni che si desidera garantire all'utente devono essere visualizzate utilizzando una finestra di dialogo che richiede la loro partecipazione attiva per il licenziamento.
Un esempio di messaggio di Brindisi è mostrato di seguito:
Le finestre di dialogo hanno un numero di componenti diversi, molti dei quali sono opzionali. Una finestra di dialogo di base ha:
Di seguito è mostrata una configurazione di Dialogo comune:
È anche possibile creare controlli di dialogo personalizzati, in cui si controlla il layout nell'area di dialogo. Puoi creare finestre di dialogo sofisticate in questo modo, inclusi quelli che prendono input dall'utente utilizzando altri controlli Android come EditText, Spinner e altro ancora.
Una configurazione di finestra di dialogo personalizzata:
Ora parliamo di come i Dialoghi sono gestiti dalla tua classe di attività. Inizieremo con i fatti di base:
Quindi, come crei una finestra di dialogo di base per la tua classe di attività? Semplicemente definisci, crea e inizializza come parte della tua attività. Diamo un'occhiata ad un semplice esempio.
Inizia creando una semplice applicazione Android con un controllo Button funzionante. Modificheremo questa applicazione di esempio per far sì che un clic del pulsante attivi una finestra di dialogo molto semplice da visualizzare sullo schermo. Puoi creare questa applicazione da zero o seguire nel codice sorgente di esempio che forniamo per la revisione.
Ora aggiungiamo tre nuovi Dialoghi alla tua classe di attività di base.
Modifica la tua classe Java Activity e aggiungi le seguenti variabili membro:
private static final int MY_SUPER_SIMPLE_DIALOG_ID = 0; private static final int MY_SIMPLE_DIALOG_ID = 1; private static final int MY_DIALOG_ID = 2;
Questo definisce tre identificatori di finestre di dialogo unici per la nostra classe di attività. I valori sono arbitrari, ma devono essere unici all'interno dell'Attività.
Per creare istanze di dialogo, è necessario implementare il metodo onCreateDialog () della classe Activity. Quando viene chiamato il metodo showDialog (), attiva una chiamata a questo metodo, che deve restituire l'istanza della finestra di dialogo appropriata. Dal momento che avremo tre diversi Dialoghi nella nostra classe, dovremo controllare l'identificatore della finestra di dialogo in entrata e utilizzare un interruttore per restituire la finestra di dialogo del tipo appropriato.
Un semplice controllo della finestra di dialogo (MY_SUPER_SIMPLE_DIALOG_ID), come mostrato nella Figura 4, mostra semplicemente un titolo testuale. Non ha pulsanti. L'unico modo per eliminarlo è premere il pulsante Indietro. Non vedi questo tipo di finestra di dialogo molto spesso, poiché la maggior parte ha almeno un pulsante OK per chiuderla. Questa finestra di dialogo può essere creata istanziando la classe Dialog e impostando il titolo della finestra di dialogo usando il metodo setTitle ().
Un controllo di finestra di dialogo più comune (MY_ SIMPLE_DIALOG_ID), mostrato di seguito, mostra un titolo di testo con un'icona e un messaggio. Ha un solo pulsante - OK. Questo è un AlertDialog, che può essere facilmente creato utilizzando la classe AlertDialog.Builder. In questo caso, si utilizzano i metodi setTitle (), setMessage (), setIcon () e setPositiveButton () per configurare il pulsante come desiderato.
Un altro comando di dialogo comune (MY_DIALOG_ID), mostrato nella figura successiva, mostra un titolo di testo con un'icona e un messaggio configurabile. Ha due pulsanti: OK e Annulla. Questo è un altro AlertDialog, che può essere creato utilizzando la classe AlertDialog.Builder. In questo caso, si utilizzano i metodi setTitle (), setMessage (), setIcon, setPositiveButton () e setNegativeButton () per configurare il pulsante come desiderato.
La completa implementazione del metodo onCreateDialog (), che mostra la creazione di tutti e tre i tipi di dialoghi discussi sopra, è mostrata qui:
@Override protected Dialog onCreateDialog (int id) switch (id) case MY_SUPER_SIMPLE_DIALOG_ID: Dialog superSimpleDlg = new Dialog (this); superSimpleDlg.setTitle (R.string.dialog_title); return superSimpleDlg; case MY_SIMPLE_DIALOG_ID: AlertDialog.Builder builder = new AlertDialog.Builder (this); builder.setTitle (R.string.dialog_title); builder.setMessage (R.string.dialog_message); builder.setIcon (android.R.drawable.btn_star); builder.setPositiveButton (android.R.string.ok, new DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int which) Toast.makeText (getApplicationContext (), "Clic OK!", Toast.LENGTH_SHORT) .show (); ritorno; ); return builder.create (); case MY_DIALOG_ID: AlertDialog.Builder builder2 = new AlertDialog.Builder (this); builder2.setTitle (R.string.dialog_title); builder2.setIcon (android.R.drawable.btn_star); builder2.setMessage ( ""); builder2.setPositiveButton (android.R.string.ok, new DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int which) Toast.makeText (getApplicationContext (), "Clic OK!", Toast.LENGTH_SHORT) .show (); ritorno; ); builder2.setNegativeButton (android.R.string.cancel, new DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int which) Toast.makeText (getApplicationContext (), "Clicked Cancel!", Toast.LENGTH_SHORT) .show (); ritorno; ); return builder2.create (); return null;
Ricorda che un'attività mantiene i dialoghi in giro e li riutilizza ogni volta che vengono mostrati. Alcune finestre di dialogo, come i nostri primi due esempi (MY_SUPER_SIMPLE_DIALOG_ID e MY _SIMPLE_DIALOG_ID), hanno contenuti statici, quindi mostrarli più e più volte non è un problema. In questo caso è possibile eseguire tutte le configurazioni Dialog nel metodo onCreateDialog ().
Tuttavia, il nostro terzo esempio di finestra di dialogo (MY_DIALOG_ID) presenta un messaggio configurabile che deve essere aggiornato ogni volta che viene visualizzata la finestra di dialogo per visualizzare la data e l'ora correnti richieste dalla finestra di dialogo. Se hai configurato il messaggio per questa finestra di dialogo nel metodo onCreateDialog (), verrà sempre visualizzato tale orario.
Ogni volta che viene richiesta una finestra di dialogo, è possibile aggiornarne il contenuto utilizzando il metodo onPrepareDialog (). Possiamo usare questa opportunità per aggiornare il messaggio del nostro Dialogo con nuovi contenuti.
Accentsconagua
@Override protected void onPrepareDialog (int id, Dialog dialog) super.onPrepareDialog (id, dialog); switch (id) case MY_SUPER_SIMPLE_DIALOG_ID: // Contenuto della finestra di dialogo statico. Nessuna interruzione di inizializzazione necessaria; case MY_SIMPLE_DIALOG_ID: // Contenuto della finestra statica. Nessuna interruzione di inizializzazione necessaria; caso MY_DIALOG_ID: // È necessaria un'inizializzazione. AlertDialog myDialog = (AlertDialog) dialog; SimpleDateFormat dFormat = new SimpleDateFormat ("yyyy-MM-dd HH: mm: ss", Locale.getDefault ()); myDialog.setMessage ("Questa finestra di dialogo è stata avviata in" + dFormat.format (mCurrentTime)); rompere; ritorno; Tieni presente che mCurrentTime è una variabile membro che impostiamo ogni volta che viene attivata la finestra di dialogo. Vedi il codice sorgente completo per l'esempio completo di come funziona.
Infine, sei pronto per attivare i controlli della finestra di dialogo da visualizzare secondo necessità. Per la nostra semplicissima applicazione di test, utilizziamo un singolo pulsante per attivare l'avvio di una delle tre finestre di dialogo create, in base all'ora corrente. Il gestore di clic per il nostro controllo Button, come definito nella classe Attività, ha il seguente aspetto:
public void onDialogButtonClick (View v) Date dt = new Date (); // Ottiene la data / ora corrente se (dt.getSeconds ()% 3 == 0) showDialog (MY_SUPER_SIMPLE_DIALOG_ID); else if (dt.getSeconds ()% 3 == 1) showDialog (MY_SIMPLE_DIALOG_ID); else mCurrentTime = dt; showDialog (MY_DIALOG_ID);
È tutto ciò di cui hai bisogno per attivare i dialoghi nella tua classe di attività. Fai clic sul pulsante un paio di volte per vedere i diversi tipi di controlli di dialogo che hai definito.
Le finestre di dialogo sono un potente strumento di interfaccia utente che può aiutarti a mantenere l'interfaccia utente dell'applicazione flessibile e senza fronzoli. È possibile personalizzare i controlli della finestra di dialogo in vari modi per informare gli utenti, richiedere agli utenti e raccogliere più input. La comprensione del ciclo di vita di Dialog è importante poiché vengono raggruppate e riutilizzate dall'attività principale.
Gli sviluppatori mobili Lauren Darcey e Shane Conder hanno coautore diversi libri sullo sviluppo di Android: un libro di programmazione approfondito intitolato Sviluppo di applicazioni wireless Android, seconda edizione e Sams ti insegna a sviluppare applicazioni Android in 24 ore, seconda edizione. Quando non scrivono, passano il loro tempo a sviluppare software mobile presso la loro azienda ea fornire servizi di consulenza. Possono essere contattati via email a [email protected], tramite il loro blog su androidbook.blogspot.com e su Twitter @androidwireless.
я я
