Share
Aplicațiile Android sunt defalcate în mod obișnuit în zone funcționale în care fiecare este legat de o clasă de activitate care dictează afișarea și comportamentul unui anumit ecran. Uneori doriți să informați în mod condiționat utilizatorul despre ceva sau să îi solicitați o intrare specifică, dar nu doriți să afișați aceste informații chiar pe ecran. Aici aveți două opțiuni de bază: puteți lansa o clasă de activități pentru un anumit rezultat și apoi puteți reveni la activitatea dvs. originală sau puteți utiliza o funcție disponibilă pentru clasele de activități: dialoguri.
Astăzi vom vorbi despre dialoguri, despre ce pot fi folosite și despre modul în care sunt create și utilizate. Apoi vom trece prin pașii de implementare a unui dialog de bază în cadrul unei clase de activitate de la început până la sfârșit. Vom urmări acest tutorial cu câteva rețete QuickTut pentru diferite tipuri de dialoguri pe care ați putea dori să le utilizați în aplicațiile tipice Android. Dar mai întâi trebuie să înțelegeți ciclul de viață al unui dialog de activitate.
Clasa de dialog Android (android.app.Dialog) este clasa de bază pentru toate tipurile de controale de dialog pe care le puteți utiliza în cadrul claselor de activitate. Dialogurile trăiesc în cadrul ciclului de viață al activității dvs. (android.app.Activity). Ele apar în prim-plan, blocând ecranul Activitate, pentru a prinde atenția utilizatorului din mai multe motive.
Notați despre protejarea în viitor a aplicațiilor și construirea de aplicații care respectă fragmente: Acest tutorial va folosi metoda tradițională de gestionare a dialogurilor de bază într-o activitate simplă. Câteva dintre aceste metode au fost recent respinse. Documentația Android SDK recomandă acum că dacă doriți să utilizați Dialoguri, ar trebui să instalați biblioteca de compatibilitate și să folosiți clasa DialogFragment. Odată ce ați învățat elementele de bază ale ciclului de viață Dialog, veți dori, de asemenea, să verificați clasa DialogFragment (android.app.DialogFragment). Cu toate acestea, această abordare este dincolo de sfera de aplicare a acestei discuții de bază de dialog deoarece necesită instalarea și utilizarea bibliotecii de compatibilitate pentru a suporta dialogurile în versiunile mai vechi ale SDK-ului Android (vom acoperi acest lucru într-un tutorial viitor). În timp ce metodele pe care le discutăm aici sunt enumerate ca fiind depreciate, noul mod de a face dialoguri nu a fost introdus până la Honeycomb, deci această soluție va continua să funcționeze foarte bine pe toate dispozitivele.
Dialogurile sunt utile atunci când doriți:
O notă privind mesajele toast: Unii dezvoltatori utilizează, de asemenea, mesaje Toast (android.widget.Toast) pentru a trimite utilizatorilor notificări sau mesaje simple. Un mesaj Toast apare pe ecranul Activitate pentru câteva secunde și apoi dispare automat. Utilizatorul nu are nici o șansă să interacționeze cu un mesaj Toast. Ne place să credem că linia de separare dintre momentul de utilizare a unui toast pe un dialog este după cum urmează: dacă utilizatorul este informat despre informații neesențiale, utilizați un pâine prăjită, dar când informațiile prezentate sunt vitale, utilizați un dialog. Utilizăm toasturile ca niște notificări foarte ușoare, informative. Orice informație pe care doriți să o vă asigurați că utilizatorul o recunoaște ar trebui să fie afișată utilizând un dialog care necesită eliminarea participării active a acestuia.
Un exemplu de mesaj de Toast este prezentat mai jos:
Dialogurile au un număr de componente diferite, majoritatea fiind opționale. Un dialog de bază are:
O configurație obișnuită de dialog este prezentată mai jos:
De asemenea, puteți crea comenzi personalizate Dialog, unde puteți controla aspectul în zona Dialog. Puteți crea Dialoguri sofisticate în acest fel, inclusiv cele care iau informații de la utilizator folosind alte controale Android precum EditText, Spinner și multe altele.
O configurație Dialog personalizată:
Acum, să vorbim despre modul în care Dialogurile sunt gestionate de clasa dvs. de activitate. Vom începe cu faptele de bază:
Deci, cum creați un Dialog de bază pentru clasa de activitate? Pur și simplu definiți, creați și inițializați-o ca parte a activității dvs. Să ne uităm la un exemplu simplu.
Începeți prin a crea o aplicație Android Android cu un buton de control al butonului. Vom modifica această aplicație pentru a determina o apăsare a unui buton pentru a declanșa un Dialog foarte simplu pentru a fi afișat pe ecran. Puteți crea această aplicație fie de la zero, fie puteți urmări în exemplul codului sursă pe care îl furnizăm pentru examinare.
Acum, să adăugăm trei noi Dialoguri la clasa de activitate de bază.
Editați clasa de activitate Java și adăugați următoarele variabile membre:
definiție statică privată int MY_SUPER_SIMPLE_DIALOG_ID = 0; definiție statică privată int MY_SIMPLE_DIALOG_ID = 1; definiție statică privată int MY_DIALOG_ID = 2;
Aceasta definește trei identificatori de dialog unic pentru clasa noastră de activitate. Valorile sunt arbitrare, dar trebuie să fie unice în cadrul Activității.
Pentru a crea instanțe Dialog, trebuie să implementați metoda onCreateDialog () a clasei dvs. de activitate. Atunci când se numește metoda showDialog (), se declanșează un apel la această metodă, care trebuie să returneze instanța Dialog corespunzătoare. Deoarece vom avea trei dialoguri diferite în clasa noastră, va trebui să verificăm identificatorul de dialog de intrare și să folosim un comutator pentru a returna dialogul corespunzător.
Cea mai simplă dintre comenzile Dialog (MY_SUPER_SIMPLE_DIALOG_ID), după cum se arată în Figura 4, arată pur și simplu un titlu de text. Nu are butoane. Singura modalitate de ao respinge este să apăsați butonul Înapoi. Nu vedeți acest tip de Dialog foarte des, deoarece majoritatea au cel puțin un buton OK pentru ao respinge. Acest dialog poate fi creat prin instanțierea clasei Dialog și setarea titlului Dialogului folosind metoda setTitle ().
Cele mai obișnuite comenzi de dialog (MY_ SIMPLE_DIALOG_ID), prezentate mai jos, prezintă un titlu de text cu o pictogramă și un mesaj. Are un singur buton - OK. Acesta este un AlertDialog, care poate fi ușor creat folosind clasa AlertDialog.Builder. În acest caz, utilizați metodele setTitle (), setMessage (), setIcon () și setPositiveButton () pentru a configura butonul după cum doriți.
O altă comandă de dialog comună (MY_DIALOG_ID), prezentată în figura următoare, prezintă un titlu de text cu o pictogramă și un mesaj configurabil. Are două butoane - OK și Anulare. Acesta este un alt AlertDialog, care poate fi creat folosind clasa AlertDialog.Builder. În acest caz, utilizați metodele setTitle (), setMessage (), setIcon, setPositiveButton () și setNegativeButton () pentru a configura butonul după cum doriți.
Implementarea completă a metodei onCreateDialog (), care arată crearea celor trei tipuri de dialog discutate mai sus, este prezentată aici:
@Override protejate Dialog onCreateDialog (int id) comutator (id) caz MY_SUPER_SIMPLE_DIALOG_ID: Dialog superSimpleDlg = dialog nou (acesta); superSimpleDlg.setTitle (R.string.dialog_title); retur superSimpleDlg; caz MY_SIMPLE_DIALOG_ID: AlertDialog.Builder builder = nou AlertDialog.Builder (acest lucru); 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, noul DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int care) Toast.makeText (getApplicationContext (), "Clicked OK!", Toast.LENGTH_SHORT) .show (); întoarcere; ); retur builder.create (); cazul MY_DIALOG_ID: AlertDialog.Builder builder2 = nou AlertDialog.Builder (acest lucru); builder2.setTitle (R.string.dialog_title); builder2.setIcon (android.R.drawable.btn_star); builder2.setMessage ( ""); builder2.setPositiveButton (android.R.string.ok, noul DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int care) Toast.makeText (getApplicationContext (), "Clicked OK!", Toast.LENGTH_SHORT) .show (); întoarcere; ); builder2.setNegativeButton (android.R.string.cancel, noul DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int care) Toast.makeText (getApplicationContext (), "Clicked Cancel", Toast.LENGTH_SHORT) .show (); întoarcere; ); retur builder2.create (); return null;
Amintiți-vă că o activitate menține dialogurile în jur și le reutilizează ori de câte ori sunt afișate. Unele dialoguri, ca și primele două exemple (MY_SUPER_SIMPLE_DIALOG_ID și MY _SIMPLE_DIALOG_ID), au conținut static, astfel încât să le afișăm din nou și din nou nu este o problemă. Puteți face toate configurațiile Dialogului în metoda onCreateDialog () în acest caz.
Cu toate acestea, cel de-al treilea exemplu de dialog (MY_DIALOG_ID) are un mesaj configurabil care trebuie actualizat de fiecare dată când se afișează dialogul pentru a afișa data și ora curente în care a fost solicitat dialogul. Dacă ați configurat mesajul pentru acest Dialog în metoda onCreateDialog (), acesta va arăta întotdeauna acel timp.
De fiecare dată când se solicită un dialog, veți avea șansa să actualizați conținutul acestuia utilizând metoda onPrepareDialog (). Putem folosi această ocazie pentru a actualiza mesajul Dialogului nostru cu conținut nou.
Accentsconagua
@Override protejat void onPrepareDialog (int id, Dialog dialog) super.onPrepareDialog (id, dialog); switch (id) caz MY_SUPER_SIMPLE_DIALOG_ID: // Conținutul dialogului static. Nici o initializare nu a necesitat pauza; caz MY_SIMPLE_DIALOG_ID: // Conținutul dialogului static. Nici o initializare nu a necesitat pauza; cazul MY_DIALOG_ID: // Este necesară o anumită inițializare. AlertDialog myDialog = (AlertDialog) dialog; SimpleDateFormat dFormat = nou SimpleDateFormat ("aaaa-MM-dd HH: mm: ss", Locale.getDefault ()); myDialog.setMessage ("Acest dialog a fost lansat la" + dFormat.format (mCurrentTime) "; pauză; întoarcere; Rețineți că mCurrentTime este o variabilă de membru pe care o setăm de fiecare dată când se declanșează dialogul. Consultați codul sursă complet pentru exemplul complet al modului în care funcționează acest lucru.
În cele din urmă, sunteți gata să declanșați comenzile Dialog pentru a fi afișate după cum este necesar. Pentru aplicația noastră foarte simplă de testare, folosim un singur buton pentru a declanșa lansarea unuia dintre cele trei dialoguri pe care le-am creat, în funcție de ora curentă. Instrumentul de control al clicurilor pentru controlul butonului nostru, așa cum este definit în clasa Activitate, arată astfel:
public void onDialogButtonClick (Vizualizare v) Date dt = new Date (); // Permite data / ora curentă dacă (dt.getSeconds ()% 3 == 0) showDialog (MY_SUPER_SIMPLE_DIALOG_ID); altfel dacă (dt.getSeconds ()% 3 == 1) showDialog (MY_SIMPLE_DIALOG_ID); altceva mCurrentTime = dt; showDialog (MY_DIALOG_ID);
Asta e tot ce ai nevoie pentru a declanșa dialoguri în clasa de activitate. Faceți clic pe butonul de câteva ori pentru a vedea diferitele tipuri de comenzi de dialog pe care le-ați definit.
Dialogurile sunt un instrument puternic de interfață cu utilizatorul, care vă poate ajuta să păstrați interfața cu utilizatorul în aplicație flexibilă și neclară. Puteți personaliza comenzile Dialog în numeroase moduri pentru a informa utilizatorii, a solicita utilizatorilor și pentru a colecta mai multe intrări. Înțelegerea ciclului de viață Dialog este importantă, deoarece acestea sunt reunite și reutilizate de activitatea părintelui.
Dezvoltatorii mobili Lauren Darcey și Shane Conder au coautorizat mai multe cărți despre dezvoltarea Android: o carte de programare în profunzime intitulată Dezvoltarea aplicațiilor fără fir Android, ediția a doua și Sams Teach Yourself Dezvoltare de aplicații Android în 24 de ore, ediția a doua. Când nu scriu, își petrec timpul dezvoltând software-ul mobil la compania lor și oferind servicii de consultanță. Acestea pot fi obținute prin e-mail la androidwirelessdev@[email protected], prin intermediul blogului lor la androidbook.blogspot.com, și pe Twitter @ androidwireless.
я я
