Hva er Android-aktiviteter og hva er deres livssyklus?

Et av hovedkonseptene i utviklingen av mobile applikasjoner er begrepet Activity, disse er grunnlaget for applikasjonen, denne gangen skal vi se hva de består av og hva som er deres livssyklus.

På den offisielle Android-utviklersiden kan vi finne en mer detaljert forklaring på hva aktivitetene representerer (https://developer.android.com/guide/components/activities/intro-activities) her vil vi se en generalitet om dem og deres livssyklus.

Vi har allerede sett at en Android-applikasjon består av forskjellige grafiske komponenter eller visninger og i tillegg har de en katalogstruktur som gjør at det grafiske grensesnittet kan være uavhengig av applikasjonens logikk, skjermene administreres gjennom xml-filene som inneholder layoutene eller innholdsadministratorene og logikken jobbes i Aktiviteter som tilsvarer aktivitetsklassen, det er også et annet konsept som kalles fragmenter som lever inne i aktiviteter, men dette er noe vi skal dekke senere.

Aktivitetsklassen er en av hovedkomponentene i en applikasjon. De er nettopp grunnlaget for å bygge apper, da de styrer systemlogikken og hva brukeren skal samhandle med. En Android-applikasjon starter med en forekomst av en aktivitet som har en definert livssyklus for å holde applikasjonen i gang.

Før du dykker inn i livssyklusen er det veldig viktig å gjøre det klart at hvordan en mobilapp fungerer er forskjellig fra hvordan andre apper fungerer, en mobilapp har ikke et spesifikt utgangspunkt, i motsetning til en desktop-app som starter gjennom en main()-metode, en applikasjon kan startes fra hvilken som helst av skjermene (dette betyr ikke at vi ikke kan gi en startordre).

Internt, når vi bytter skjerm, er det som gjøres et anrop mellom aktiviteter (eller fragmentene erstattes i samme aktivitet), og når vi bytter mellom applikasjoner på samme måte, påkalles applikasjonen ved å kalle den opprinnelige aktiviteten.

En applikasjon er vanligvis sammensatt av flere skjermer, noe som tilsvarer å ha flere aktiviteter som kommuniserer med hverandre, selv om det allerede er nevnt at applikasjonen kan startes fra hvilken som helst aktivitet, er en aktivitet alltid definert som hovedaktiviteten MainActivity (selv om ikke nødvendigvis må være den første som vises) og derfra markere startpunktet for navigering i systemet som kaller nye aktiviteter eller fragmenter.

Manifestfil (AndroidManifest.xml)

I en tidligere oppføring snakket vi om manifestfilen, dette er en konfigurasjonsfil som lar deg parameterisere hovedelementene i applikasjonen, her finner du informasjon som applikasjons-ID, navnet, ikonet, aktivitetene den inneholder, tillatelsene, blant andre viktige elementer.

Når en aktivitet er opprettet, sørger androidStudio automatisk for å parametrisere den i AndroidManifest.xml-filen, og der kan du også legge til filtre eller egenskaper for å bestemme flere handlinger av applikasjonen, for eksempel i forrige bilde kan du se at MainActivity er aktivitetssystem hoved (den som vises først) siden legges til den med eiendommen <action android:name="android.intent.action.MAIN" />

Aktivitets livssyklus.

En aktivitet går gjennom flere tilstander under utførelsen, disse tilstandene oppstår gjennom brukerinteraksjon med aktiviteten, for eksempel når den går inn, går ut, går inn igjen eller når den er lukket, lar android oss kontrollere hver av disse tilstandene gjennom en rekke definerte metoder som vi kan implementere for å administrere atferden, for eksempel kan du sette en videospiller på pause når du endrer skjerm eller avbryte tilkoblingsprosesser når du går ut av applikasjonen, på Android-utviklersiden finner vi detaljene til disse metodene (der kan vi også finne følgende diagram som viser hvordan det fungerer:

Her er et sammendrag av hver av statene:

• onCreate()

  Denne metoden opprettes som standard i aktiviteten og aktiveres når den begynner å referere til layouten som tilsvarer den grafiske delen gjennom setContentView() metoden, dette er den første metoden som utføres.

• onStart()

  Når onCreate() lukkes, endrer aktiviteten status fra opprettet til startet og presenteres for brukeren, det er her visningen og aktiviteten blir interaktiv.

• Kort oppsummert()

  Etter å ha startet aktiviteten endres tilstanden onResume() som er ansvarlig for å behandle brukerinteraksjonsinformasjon, her gjenkjennes og fanges opp alt brukeren skriver inn.

• onPause()

  I tilfelle aktiviteten mister fokus og blir avbrutt, kalles pausetilstanden, for eksempel når brukeren trykker på tilbakeknappen eller skifter skjerm, betyr det at aktiviteten fortsatt er delvis synlig mens aktiviteten lukkes.

  Fra denne tilstanden kan du gå tilbake til onResume() eller onStop() igjen

• onStop()

  Denne tilstanden starter når aktiviteten ikke lenger er synlig for brukeren, det kan være fordi aktiviteten ble slettet, en som ble stoppet blir reaktivert eller fordi en ny starter, i dette tilfellet er den stoppede aktiviteten ikke lenger synlig for bruker. brukeren, herfra kan du ringe onRestart() eller onDestroy()

• onRestart()

  Systemet går inn i denne tilstanden når en stoppet aktivitet skal startes igjen, her gjenopprettes aktivitetstilstanden fra det øyeblikket den ble stoppet og kallet til onStart() foretas.

• onDestroy()

  Til slutt kaller systemet denne metoden før den sletter aktiviteten, dette er den siste tilstanden aktiviteten går gjennom og implementeres når lukking eller frigjøring av alle ressurser til en aktivitet må garanteres.

Disse metodene kan implementeres i prosjektet som følger:

Så når du starter applikasjonen, vil vi se oppførselen i logcat.

Og det er det, med det ser vi hva aktivitetene består av og hvordan vi kan kontrollere livssyklusen, så kan vi jobbe videre med basisapplikasjonen.

Det kan også interessere deg.

Er det noe du vil legge til eller kommentere om denne oppføringen? gjør gjerne....Og hvis du likte det... Jeg inviterer deg til å dele Y Abonner ved å klikke på "Bli med på denne siden"-knappen for å høre flere innlegg som dette 😉