Vad är Android-aktiviteter och vad är deras livscykel?

Ett av huvudkoncepten i utvecklingen av mobila applikationer är konceptet Activity, dessa är grunden för applikationen, denna gång ska vi se vad de består av och vad som är deras livscykel.

På den officiella Android-utvecklarsidan kan vi hitta en mer detaljerad förklaring av vad aktiviteterna representerar (https://developer.android.com/guide/components/activities/intro-activities) här kommer vi att se en allmänhet om dem och deras livscykel.

Vi har redan sett att en Android-applikation är uppbyggd av olika grafiska komponenter eller vyer och dessutom har de en katalogstruktur som gör att det grafiska gränssnittet kan vara oberoende av applikationens logik, skärmarna hanteras genom xml-filerna som innehåller layouterna eller innehållshanterarna och logiken bearbetas i Aktiviteter som motsvarar klassen Aktivitet, det finns även ett annat koncept som kallas fragment som lever inuti aktiviteter, men det är något vi kommer att ta upp senare.

Aktivitetsklassen är en av huvudkomponenterna i en applikation. De är just grunden för att bygga appar, eftersom de hanterar systemlogiken och vad användaren ska interagera med. En Android-applikation startar med en instans av en aktivitet som har en definierad livscykel för att hålla applikationen igång.

Innan du dyker in i livscykeln är det mycket viktigt att göra det klart att hur en mobilapp fungerar skiljer sig från hur andra appar fungerar, en mobilapp har ingen specifik utgångspunkt, till skillnad från en stationär app som startar genom en main()-metod, en applikation kan startas från vilken som helst av dess skärmar (det betyder inte att vi inte kan ge en startorder).

Internt, när vi byter skärm, är det som görs ett anrop mellan aktiviteter (eller så byts fragmenten ut i samma aktivitet) och när vi byter mellan applikationer på samma sätt anropas applikationen genom att anropa dess initiala aktivitet.

En applikation är vanligtvis sammansatt av flera skärmar, vilket motsvarar att ha flera aktiviteter som kommunicerar med varandra, även om det redan har nämnts att applikationen kan startas från vilken aktivitet som helst, en aktivitet definieras alltid som huvudaktiviteten MainActivity (även om inte måste nödvändigtvis vara den första som visas) och därifrån markera startpunkten för navigering i systemet som anropar nya aktiviteter eller fragment.

Manifestfil (AndroidManifest.xml)

I ett tidigare inlägg pratade vi om manifestfilen, detta är en konfigurationsfil som låter dig parametrera applikationens huvudelement, här hittar du information som applikations-ID, namn, ikon, aktiviteterna den innehåller, behörigheterna, bland andra viktiga saker.

När en aktivitet skapas tar androidStudio automatiskt hand om att parametrera den i filen AndroidManifest.xml och där kan du även lägga till filter eller egenskaper för att bestämma ytterligare åtgärder för applikationen, till exempel i föregående bild kan du se att MainActivity är aktivitetssystem huvud (det som visas först) sedan läggs till den med fastigheten <action android:name="android.intent.action.MAIN" />

Aktivitetens livscykel.

En aktivitet går igenom flera tillstånd under dess exekvering, dessa tillstånd uppstår genom användarinteraktion med aktiviteten, till exempel när den går in, går ut, går in igen eller när den stängs, låter android oss kontrollera vart och ett av dessa tillstånd genom en serie definierade metoder som vi kan implementera för att hantera beteendet, till exempel kan du pausa en videospelare när du byter skärm eller avbryta anslutningsprocesser när du avslutar applikationen, på Android-utvecklarsidan hittar vi detaljerna om dessa metoder (där kan vi också hitta följande diagram som visar hur det fungerar:

Här är en sammanfattning av var och en av delstaterna:

• onCreate()

  Denna metod skapas som standard i aktiviteten och aktiveras när den börjar referera till layouten som motsvarar den grafiska delen genom metoden setContentView(), detta är den första metoden som exekveras.

• onStart()

  När onCreate() stängs ändras aktiviteten från skapad till startad och presenteras för användaren, det är här vyn och aktiviteten blir interaktiva.

• Kortfattat()

  Efter att ha startat aktiviteten ändras tillståndet onResume() som ansvarar för att bearbeta användarinteraktionsinformation, här identifieras och fångas allt användaren anger.

• onPause()

  Om aktiviteten tappar fokus och avbryts, anropas paustillståndet, till exempel när användaren trycker på bakåtknappen eller byter skärm, betyder det att aktiviteten fortfarande är delvis synlig medan aktiviteten stängs.

  Från detta tillstånd kan du återgå till onResume() eller onStop()

• onStop()

  Detta tillstånd startar när aktiviteten inte längre är synlig för användaren, det kan bero på att aktiviteten raderades, en som stoppades återaktiveras eller för att en ny startar, i det här fallet är den stoppade aktiviteten inte längre synlig för användare. användaren, härifrån kan du anropa onRestart() eller onDestroy()

• onRestart()

  Systemet går in i detta tillstånd när en stoppad aktivitet ska startas igen, här återställs aktivitetstillståndet från det ögonblick den stoppades och anropet till onStart() görs.

• onDestroy()

  Slutligen anropar systemet denna metod innan aktiviteten tas bort, detta är det sista tillståndet som aktiviteten går igenom och implementeras när stängning eller frigöring av alla resurser för en aktivitet måste garanteras.

Dessa metoder kan implementeras i projektet enligt följande:

Så när vi startar programmet kommer vi att se beteendet i logcat.

Och det är det, med det ser vi vad aktiviteterna består av och hur vi kan styra livscykeln, sedan kan vi jobba vidare med grundapplikationen.

Det kan också intressera dig.

Finns det något du vill lägga till eller kommentera om det här inlägget? gör gärna....Och om du gillade det... Jag inbjuder dig att dela y Prenumerera genom att klicka på knappen "Gå med på den här webbplatsen" för att höra fler inlägg som detta 😉