Livscykel i mobil utveckling: vad det är, vilka stadier och hur det fungerar

Appens livscykel (App Lifecycle)

Innan vi går in på livscykeln för enskilda skärmar är det viktigt att förstå livscykeln för hela applikationen. I iOS går appen igenom fem tillstånd: Not Running (inte igång), Inactive (i bakgrunden, tar inte emot händelser), Active (aktiv), Background (i bakgrunden, kod körs) och Suspended (i bakgrunden, kod pausad). Dessa tillstånd hanteras i AppDelegate genom metoderna applicationDidFinishLaunching, applicationDidBecomeActive, applicationWillResignActive, applicationDidEnterBackground och applicationWillTerminate.

I Android är motsvarigheten Application Lifecycle, som spåras via gränssnittet Application.ActivityLifecycleCallbacks. Android fokuserar dock mer på livscykeln för en Activity — en enskild appskärm. Detta beror på att en Android-app kan bestå av flera Activities, var och en med sin egen cykel.

Det moderna tillvägagångssättet i Android är att använda ProcessLifecycleOwner från lifecycle-process-biblioteket. Det gör det möjligt att spåra tillståndet för hela processen utan att vara bunden till en specifik Activity. I iOS används UISceneDelegate (sedan iOS 13) eller AppDelegate för att spåra appens tillstånd. SceneDelegate hanterar flera fönster (multiwindow) på iPad. Att förstå App Lifecycle är särskilt viktigt för IT Sectr när man utvecklar appar med bakgrundssynkronisering, streaming och VoIP-samtal.

Activity Lifecycle i Android

Activity är den grundläggande komponenten i en Android-app som representerar en skärm. Activity har en väldefinierad livscykel som hanteras av operativsystemet som svar på användaråtgärder och systemhändelser (skärmrotation, inkommande samtal, lågt minne).

Vad göra

Viktigt: onSaveInstanceState anropas före onStop för att spara tillfälligt tillstånd. Återställning sker i onCreate via Bundle savedInstanceState eller via SavedStateHandle i ViewModel. Utan korrekt livscykelhantering kommer appen att förlora all osparad data vid skärmrotation.

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putString("draft", draftText)
    }
    override fun onDestroy() {
        super.onDestroy()
        // Отписка от всех подписок
    }
}

Activity Lifecycle i Jetpack Compose

I Jetpack Compose förblir Activitys livscykel oförändrad, men Compose tillhandahåller ytterligare verktyg: Livscykelmedveten komposition via LifecycleOwner, LifecycleEventEffect och DisposableEffect för automatisk rensning av resurser vid förstöring.

Fragment Lifecycle i detalj

Fragment i Android lever inuti en Activity och har en egen livscykel som delvis överlappar Activity men lägger till nya metoder. Fragment kan läggas till, ersättas, tas bort utan att förstöra Activity, vilket gör dem mer flexibla men också mer komplexa.

Huvudmetoder för Fragment Lifecycle: onAttach — Fragment fäst vid Activity (första anropet); onCreate — datainitiering; onCreateView — skapa View; onViewCreated — View skapad, UI kan konfigureras; onStart — Fragment synligt; onResume — Fragment i fokus; onPause — Fragment förlorar fokus; onStop — Fragment inte synligt; onDestroyView — View förstörs; onDestroy — Fragment förstörs; onDetach — Fragment lossnat från Activity.

Huvudskillnad från Activity: onCreateView och onDestroyView kan anropas flera gånger (t.ex. vid växling av TabLayout), medan onCreate anropas en gång. Följaktligen bör View-initiering göras i onViewCreated, inte i onCreateView. View-relaterade resurser (som RecyclerView-adaptrar) bör rensas i onDestroyView.

ViewController Lifecycle i iOS

UIViewController är basklassen för att hantera skärmar i iOS. Dess livscykel består av en sekvens metoder som UIKit anropar automatiskt. Att förstå denna cykel är avgörande för korrekt UI-initiering, datahantering och minneshantering.

Typisk användning

Viktigt: viewDidLoad anropas bara en gång under en View Controllers livstid. För att uppdatera data vid varje visning, använd viewWillAppear. Om du prenumererar på NotificationCenter i viewWillAppear, se till att avsluta prenumerationen i viewDidDisappear för att undvika minnesläckor.

SwiftUI Lifecycle

SwiftUI hanterar livscykeln för Views via View-strukturer. Istället för callback-metoder använder SwiftUI modifierare onAppear och onDisappear. För globala apptillstånd används App Lifecycle via App- och Scene-protokollen. SwiftUI hanterar automatiskt skapande och förstöring av Views baserat på tillstånd, vilket förenklar utvecklingen men kräver förståelse för View-identitet och livslängd.

struct ContentView: View {
    var body: some View {
        Text("Hello")
            .onAppear {
                print("View появилась")
            }
            .onDisappear {
                print("View исчезла")
            }
    }
}

LifecycleOwner och LifecycleObserver i Android

LifecycleOwner är ett gränssnitt från Android Architecture Components som markerar ett objekt med en livscykel (Activity, Fragment). LifecycleObserver är ett gränssnitt som gör att ett objekt kan prenumerera på LifecycleOwner-händelser. Tillsammans utgör de grunden för reaktiv livscykelhantering i modern Android-utveckling.

Istället för att explicit anropa metoder i onStart/onStop rekommenderas att använda DefaultLifecycleObserver (ersättning för den föråldrade LifecycleObserver med @OnLifecycleEvent-annoteringar). Detta är det tillvägagångssätt som Google främjar för ViewModel och andra komponenter som behöver reagera på livscykeln utan att ha direkta referenser till Activity eller Fragment.

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Подписка на обновления
    }
    override fun onStop(owner: LifecycleOwner) {
        // Отписка
    }
}

På IT Sectr använder vi LifecycleOwner i alla Android-projekt. ViewModel prenumererar på Activitys LifecycleOwner via viewModelScope och lifecycleScope, vilket garanterar automatisk annullering av korutiner när Activity förstörs. Detta förhindrar minnesläckor och gör koden renare och säkrare.