Share
Android-applikasjoner brytes ofte ned i funksjonelle områder hvor hver er knyttet til en aktivitetsklasse som dikterer visning og oppførsel av en bestemt skjerm. Noen ganger vil du betinget informere brukeren om noe eller spørre dem om spesifikk innspilling, men du vil ikke vise den informasjonen på skjermen selv. Her har du to grunnleggende valg: Du kan starte et barn Aktivitetsklasse for et bestemt resultat, og deretter gå tilbake til din opprinnelige aktivitet, eller du kan bruke en praktisk funksjon som er tilgjengelig for Aktivitetsklasser: dialoger.
I dag skal vi snakke om dialoger, hva de kan brukes til, og hvordan de blir opprettet og brukt. Vi vil da gå gjennom trinnene for å implementere en grunnleggende dialog i en aktivitetsklasse fra start til slutt. Vi vil følge opp denne opplæringen med noen QuickTut-oppskrifter for ulike typer dialoger du kanskje vil bruke i de typiske Android-appene dine. Men først må du forstå livssyklusen til en aktivitetsdialog.
Android Dialog-klassen (android.app.Dialog) er grunnklassen for alle typer dialogbokser som du kan bruke i aktivitetsklassene dine. Dialogger lever i livssyklusen til aktiviteten din (android.app.Activity). De dukker opp i forgrunnen, blokkerer aktivitetsskjermbildet, for å fange brukerens oppmerksomhet av en rekke årsaker.
Vær oppmerksom på fremtidssikring av appene dine og å bygge Fragment-aware programmer: Denne opplæringen vil bruke den tradisjonelle metoden for å administrere grunnleggende dialogbokser innenfor en enkel aktivitet. Noen av disse metodene ble nylig avviklet. Android SDK-dokumentasjonen anbefaler nå at hvis du vil bruke Dialogger, bør du installere kompatibilitetsbiblioteket og bruke klassen DialogFragment i stedet. Når du har mestret grunnleggende om Dialog-livssyklusen, vil du også sjekke ut DialogFragment-klassen (android.app.DialogFragment) også. Denne tilnærmingen er imidlertid utenfor rammen av denne grunnleggende dialogdiskusjonen, da det krever at du installerer og bruker kompatibilitetsbiblioteket for å støtte dialogbokser i eldre versjoner av Android SDK (vi vil dekke dette i en fremtidig opplæring). Mens metodene vi diskuterer her er oppført som avskrevet, ble den nye måten å gjøre dialoger ikke introdusert til Honeycomb, så denne løsningen vil fortsette å virke helt fint på alle enheter.
Dialogger er nyttige når du vil:
En melding om toastmeldinger: Noen utviklere bruker også Toast-meldinger (android.widget.Toast) for å sende enkle meldinger eller meldinger til brukeren. En Toast-melding vises over Aktivitetsskjermbildet i noen sekunder, og forsvinner deretter automatisk. Brukeren har ingen sjanse til å samhandle med en Toast-melding. Vi liker å tenke at skillelinjen mellom når du bruker Toast over en dialog, er som følger: Hvis brukeren blir informert om ikke-viktig informasjon, bruk en Toast, men når informasjonen som presenteres er viktig, bruk en dialog. Vi bruker Toasts som svært lette, informative meldinger. Eventuell informasjon du vil sikre brukeren bekrefter, skal vises ved hjelp av en dialog som krever at deres aktive deltakelse avvises.
Et eksempel på Toast-meldingen er vist nedenfor:
Dialogger har en rekke forskjellige komponenter, hvorav de fleste er valgfrie. En grunnleggende dialog har:
En felles dialogkonfigurasjon vises nedenfor:
Du kan også opprette egendefinerte dialogbokser, hvor du kontrollerer oppsettet i dialogområdet. Du kan bygge sofistikerte dialogbokser på denne måten, inkludert de som tar innspill fra brukeren ved hjelp av andre Android-kontroller som EditText, Spinner og mer.
En egendefinert dialogkonfigurasjon:
La oss nå snakke om hvordan Dialogs styres av aktivitetsklassen din. Vi starter med de grunnleggende fakta:
Så hvordan lager du en grunnleggende dialog for aktivitetsklassen din? Du definerer, oppretter og initialiserer det bare som en del av aktiviteten din. La oss se på et enkelt eksempel.
Begynn med å lage et enkelt Android-program med en fungerende knappekontroll. Vi vil endre denne prøveapplikasjonen for å få et knappeklikk til å utløse en veldig enkel dialog å vise på skjermen. Du kan enten opprette dette programmet fra grunnen av eller følge med i kildekoden vi tilbyr for gjennomgang.
La oss nå legge til tre nye dialogbokser til din grunnleggende aktivitetsklasse.
Rediger aktivitets Java-klassen din og legg til følgende medlemsvariabler:
privat statisk endelig int MY_SUPER_SIMPLE_DIALOG_ID = 0; privat statisk slutt int MY_SIMPLE_DIALOG_ID = 1; privat statisk endelig int MY_DIALOG_ID = 2;
Dette definerer tre unike dialog-identifikatorer for vår aktivitetsklasse. Verdiene er vilkårlig, men må være unike i aktiviteten.
Hvis du vil opprette dialogbokser, må du implementere onCreateDialog () -metoden i aktivitetsklassen din. Når metoden showDialog () kalles, utløser den et anrop til denne metoden, som må returnere det aktuelle Dialog-forekomsten. Siden vi skal ha tre forskjellige dialogbokser i klassen vår, må vi sjekke den innkommende dialogboksen, og bruk en bryter for å returnere dialogboksen av den aktuelle typen.
En enkleste dialogboksen (MY_SUPER_SIMPLE_DIALOG_ID), som vist i figur 4, viser bare en teksttittel. Det har ingen knapper. Den eneste måten å avvise det er å trykke på Tilbake-knappen. Du ser ikke denne typen dialog ofte, siden de fleste har minst en OK-knapp for å avvise det. Denne dialogboksen kan opprettes ved å instansere dialogboksen, og angi tittelen til dialogboksen ved hjelp av setTitle () -metoden.
Et vanligste av Dialog kontroller (MY_ SIMPLE_DIALOG_ID), vist nedenfor, viser en tekst tittel med et ikon og en melding. Den har en enkelt knapp - OK. Dette er en AlertDialog, som enkelt kan opprettes ved hjelp av AlertDialog.Builder-klassen. I dette tilfellet bruker du setTitle (), setMessage (), setIcon () og setPositiveButton () metoder for å konfigurere knappen som ønsket.
En annen vanlig Dialog kontroll (MY_DIALOG_ID), vist i neste figur, viser en tekst tittel med et ikon og en konfigurerbar melding. Den har to knapper - OK og Avbryt. Dette er en annen AlertDialog, som kan opprettes ved hjelp av AlertDialog.Builder-klassen. I dette tilfellet bruker du setTitle (), setMessage (), setIcon, setPositiveButton () og setNegativeButton () metoder for å konfigurere knappen som ønsket.
Den fullstendige implementeringen av metoden onCreateDialog (), som viser opprettelsen av alle tre Dialogtyper diskutert ovenfor, er vist her:
@Override protected Dialog onCreateDialog (int id) switch (id) tilfelle MY_SUPER_SIMPLE_DIALOG_ID: Dialog superSimpleDlg = ny dialog (dette); superSimpleDlg.setTitle (R.string.dialog_title); returnere superSimpleDlg; tilfelle MY_SIMPLE_DIALOG_ID: AlertDialog.Builder builder = ny AlertDialog.Builder (dette); 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, ny DialogInterface.OnClickListener () offentlig ugyldig påClick (DialogInterface dialog, int som) Toast.makeText (getApplicationContext (), "Clicked OK!", Toast.LENGTH_SHORT) .show (); komme tilbake; ); returner builder.create (); tilfelle MY_DIALOG_ID: AlertDialog.Builder builder2 = ny AlertDialog.Builder (dette); builder2.setTitle (R.string.dialog_title); builder2.setIcon (android.R.drawable.btn_star); builder2.setMessage ( ""); builder2.setPositiveButton (android.R.string.ok, ny DialogInterface.OnClickListener () offentlig ugyldig påClick (DialogInterface dialog, int som) Toast.makeText (getApplicationContext (), "Clicked OK!", Toast.LENGTH_SHORT) .show (); komme tilbake; ); builder2.setNegativeButton (android.R.string.cancel, ny DialogInterface.OnClickListener () public void onClick (DialogInterface dialog, int som) Toast.makeText (getApplicationContext (), "Clicked Cancel!", Toast.LENGTH_SHORT) .show (); komme tilbake; ); returner builder2.create (); returnere null;
Husk at en aktivitet holder dialogbokser rundt og gjenbruker dem når de blir vist. Enkelte dialoger, som våre to første eksempler (MY_SUPER_SIMPLE_DIALOG_ID og MY _SIMPLE_DIALOG_ID), har statisk innhold, så det vises ikke noe igjen, så visning av dem igjen og igjen. Du kan gjøre all din dialogkonfigurasjon i metoden onCreateDialog () i dette tilfellet.
Vårt tredje Dialog-eksempel (MY_DIALOG_ID) har imidlertid en konfigurerbar melding som må oppdateres hver gang dialogen vises for å vise gjeldende dato og klokkeslett som dialogen ble forespurt. Hvis du konfigurerte meldingen for denne dialogen i metoden onCreateDialog (), vil den alltid vise den tiden.
Hver gang en dialog blir forespurt, får du sjansen til å oppdatere innholdet ved hjelp av metoden onPrepareDialog (). Vi kan bruke denne muligheten til å oppdatere meldingen til dialogen vår med nytt innhold.
Accentsconagua
@Override protected void onPrepareDialog (int id, Dialog dialog) super.onPrepareDialog (id, dialog); bytt (id) tilfelle MY_SUPER_SIMPLE_DIALOG_ID: // Statisk dialoginnhold. Ingen initialisering nødvendig pause; tilfelle MY_SIMPLE_DIALOG_ID: // Statisk dialoginnhold. Ingen initialisering nødvendig pause; tilfelle MY_DIALOG_ID: // Enkel initialisering nødvendig. AlertDialog myDialog = (AlertDialog) dialogboksen; SimpleDateFormat dFormat = ny SimpleDateFormat ("yyyy-MM-dd HH: mm: ss", Locale.getDefault ()); myDialog.setMessage ("Denne dialogen ble lansert på" + dFormat.format (mCurrentTime)); gå i stykker; komme tilbake; Vær oppmerksom på at mCurrentTime er en medlemsvariabel som vi angir hver gang dialogen utløses. Se den komplette kildekoden for hele eksemplet på hvordan dette fungerer.
Til slutt er du klar til å utløse dialogboksen til å vise etter behov. For vår svært enkle testapplikasjon bruker vi en enkelt knapp for å utløse lanseringen av en av de tre Dialogene vi har opprettet, avhengig av gjeldende tid. Klikkhåndtereren for vår Knappkontroll, som definert i Aktivitetsklassen, ser slik ut:
offentlig ugyldig påDialogButtonClick (Vis v) Date dt = new Date (); // Går gjeldende dato / klokkeslett hvis (dt.getSeconds ()% 3 == 0) showDialog (MY_SUPER_SIMPLE_DIALOG_ID); annet hvis (dt.getSeconds ()% 3 == 1) showDialog (MY_SIMPLE_DIALOG_ID); ellers mCurrentTime = dt; showdialog (MY_DIALOG_ID);
Det er alt du trenger for å utløse dialoger i aktivitetsklassen. Klikk på knappen et par ganger for å se de forskjellige dialogrutene du har definert.
Dialogger er et kraftig verktøy for brukergrensesnitt som kan hjelpe deg med å holde applikasjonsgrensesnittet ditt fleksibelt og ryddig. Du kan tilpasse dialogbokser på mange måter for å informere brukere, spørre brukere og samle inn flere innspill. Forstå dialogens livssyklus er viktig, da de blir samlet og gjenbrukt av deres foreldreaktivitet.
Mobilutviklere Lauren Darcey og Shane Conder har medforfatter flere bøker om Android-utvikling: en grundig programmeringsbok med tittel Android Wireless Application Development, andre utgave og Sams lær deg selv Android Application Development i 24 timer, andre utgave. Når de ikke skriver, bruker de sin tid på å utvikle mobil programvare hos deres firma og tilby konsulenttjenester. De kan nås via e-post til [email protected], via bloggen deres på androidbook.blogspot.com, og på Twitter @androidwireless.
я я
