App Lifecycle: vad det är, applikationstillstånd i iOS och Android

Vad är App Lifecycle?

App Lifecycle — en ändlig tillståndsmaskin som beskriver alla möjliga tillstånd för en mobilapplikation och övergångarna mellan dem. Varje tillstånd bestämmer om applikationen kan exekvera kod, visa UI och förbruka resurser. iOS och Android har en liknande men inte identisk modell — skillnaderna beror på operativsystemets arkitektur: iOS använder strikt minneskontroll (suspended-tillstånd), Android — flexibel processhantering via onSaveInstanceState.

I iOS är lifecycle tätt kopplad till foreground/background: applikationen är antingen aktiv eller pausad. I Android är lifecycle mer granulär — Activity/Window går igenom 6+ tillstånd och själva processen har en extra lifecycle via ProcessLifecycleOwner. Moderna applikationer (från 2024) använder allt oftare arkitekturmönster baserade på lifecycle: SwiftUI Lifecycle (iOS 16+) via .scenePhase environment, Compose Lifecycle via LifecycleEventObserver. Dessa mönster hanterar automatiskt kontextväxling och förhindrar minnesläckor. Enligt Google minskar korrekt lifecycle-bearbetning i Android minnesförbrukningen med 30–40% under bakgrundsarbete.

iOS livscykel: AppDelegate och SceneDelegate

I iOS hanteras applikationens lifecycle via klassen UIApplicationDelegate (AppDelegate). Huvudmetoder: application(_:didFinishLaunchingWithOptions:) — initiering vid första start; applicationDidBecomeActive — applikationen synlig och redo för interaktion; applicationWillResignActive — övergång till inaktivt tillstånd (inkommande samtal, stängning av gardin); applicationDidEnterBackground — applikationen dold, det finns ~5 sekunder att spara data; applicationWillEnterForeground — återkomst från bakgrunden; applicationWillTerminate — avslutning (anropas endast för gamla applikationer utan suspended).

Från och med iOS 13 introducerade Apple SceneDelegate (UISceneDelegate) för stöd av flerfönsterapplikationer på iPad och macOS Catalyst. SceneDelegate hanterar lifecycle för varje enskild scen (fönster): scene(_:willConnectTo:options:) — skapande av scen; sceneDidBecomeActive — scen aktiv; sceneWillResignActive — scen förlorar fokus; sceneDidEnterBackground — scen dold. AppDelegate ansvarar för globala händelser (dataladdning, push-notiser) och SceneDelegate — för UI-status för varje fönster. I SwiftUI hanteras lifecycle via environment-värdet @Environment(\.scenePhase): .active, .inactive, .background — detta ger ett enhetligt API för SwiftUI- och UIKit-applikationer.

Android livscykel: Application och ProcessLifecycleOwner

I Android börjar lifecycle med klassen Application — en singleton som skapas före någon Activity. Metoden Application.onCreate() — första startpunkten, används för global initiering (Analytics, DI, Crash Reporting). Därefter startas Activity med sekvensen: onCreate() → onStart() → onResume(). Vid minimering: onPause() → onStop() → onSaveInstanceState(). Vid förstöring: onDestroy(). Vid återkomst: onRestart() → onStart() → onResume().

ProcessLifecycleOwner (från AndroidX Lifecycle 2.2+) spårar lifecycle för hela processen, inte för enskild Activity. Tillhandahåller två tillstånd: ON_RESUME (applikation i foreground) och ON_STOP (applikation dold). ProcessLifecycleOwner löser problemet "när gick applikationen till bakgrunden" på processnivå — detta är kritiskt för SDK:er, bibliotek och modulära applikationer. I Jetpack Compose hanteras lifecycle via LifecycleEventObserver och collectAsStateWithLifecycle, som automatiskt pausar datainsamling i bakgrundsläge. Android 14 (API 34) lade till notifikation om foreground service lifecycle via Service.onTimeout — tjänsten måste slutföras inom 6 timmar, annars stoppar systemet den tvångsmässigt.

Jämförelse av iOS och Android lifecycle

Huvudskillnad: iOS tvingar applikationen till Suspended (kod exekveras inte) 5-10 sekunder efter övergång till bakgrunden. Android tillåter bakgrundsarbete (tjänster, WorkManager) under längre tid men med Doze Mode-begränsningar (Android 6+) och bakgrundsbegränsningar (Android 12+). ProcessLifecycleOwner i Android — motsvarighet till UIApplicationDidEnterBackgroundNotification i iOS med skillnaden att den utlöses vid varje övergång till bakgrunden, inte bara efter fokusförlust.

Kodexempel

iOS: AppDelegate med lifecycle-metoder

Grundläggande implementering av AppDelegate med hantering av alla livscykeltillstånd. Datalagring vid övergång till bakgrunden och UI-uppdatering vid återkomst.

import UIKit
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    func application(_: UIApplication, didFinishLaunchingWithOptions lo: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { Analytics.shared.initialize(); return true }
    func applicationDidBecomeActive(_: UIApplication) { NotificationCenter.default.post(name: .appDidBecomeActive, object: nil) }
    func applicationWillResignActive(_: UIApplication) { NotificationCenter.default.post(name: .appWillResignActive, object: nil) }
    func applicationDidEnterBackground(_: UIApplication) { CoreDataManager.shared.saveContext(); UserDefaults.standard.synchronize() }
    func applicationWillEnterForeground(_: UIApplication) { NetworkManager.shared.refreshSession() }
}

AppDelegate — central punkt för lifecycle. applicationDidEnterBackground — kritisk metod: iOS ger ~5 sekunder att spara data. applicationDidBecomeActive — uppdatera UI, starta om animationer. För SceneDelegate (iOS 13+) fördelas lifecycle-logiken över scener: sceneDidBecomeActive / sceneDidEnterBackground hanterar enskilda fönster.

iOS: SceneDelegate (iOS 13+)

SceneDelegate för flerfönster iPad-applikationer. Varje scen har sin egen lifecycle, oberoende av andra fönster.

import UIKit
class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    func scene(_: UIScene, willConnectTo s: UISceneSession, options o: UIScene.ConnectionOptions) {
        guard let ws = (_ as? UIWindowScene) else { return }
        window = UIWindow(windowScene: ws)
        window?.rootViewController = ViewController()
        window?.makeKeyAndVisible()
    }
    func sceneDidBecomeActive(_: UIScene) { PlayerManager.shared.resume() }
    func sceneDidEnterBackground(_: UIScene) { PlayerManager.shared.pause(); CoreDataManager.shared.saveContext() }
    func sceneDidDisconnect(_: UIScene) { PlayerManager.shared.cleanup() }
}

SceneDelegate hanterar lifecycle för enskild scen. sceneDidBecomeActive / sceneDidEnterBackground — motsvarighet till AppDelegate-metoder för ett specifikt fönster. sceneDidDisconnect anropas när scenen stängs (användaren stängde fönstret på iPad). För att bibehålla kompatibilitet med iOS 12 och äldre måste AppDelegate duplicera SceneDelegate-logiken. I iOS 17+ kan du använda @Observable för automatisk pausning/återupptagning av uppgifter baserat på scenePhase.

Android: Application med ProcessLifecycleOwner

ProcessLifecycleOwner spårar när applikationen är i foreground/background på processnivå. Detta är det optimala sättet för global lifecycle-hantering.

import android.app.Application
import androidx.lifecycle.ProcessLifecycleOwner
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleObserver
import androidx.lifecycle.OnLifecycleEvent
class MainApplication : Application() {
    override fun onCreate() { super.onCreate(); ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver()) }
}
class AppLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START) fun onEnterForeground() { Analytics.shared.onForeground(); NetworkMonitor.shared.start() }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP) fun onEnterBackground() { Analytics.shared.onBackground(); NetworkMonitor.shared.stop() }
}

ProcessLifecycleOwner — det enda korrekta sättet att spåra bakgrundsövergång på applikationsnivå. ON_START utlöses när applikationen blir synlig (foreground), ON_STOP — när den är helt dold (background). Till skillnad från Activity lifecycle är ProcessLifecycleOwner inte bunden till en specifik skärm. För Jetpack Compose använd LifecycleResumeEffect eller collectAsStateWithLifecycle istället för manuell observation.

Android: Activity Lifecycle med ViewModel

ViewModel + Lifecycle — korrekt Android-arkitektur för att arbeta med lifecycle. ViewModel rensas automatiskt vid onDestroy, förhindrar minnesläckor.

import androidx.lifecycle.ViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
class TimerViewModel : ViewModel() {
    private val _time = MutableLiveData<Long>()
    val time: LiveData<Long> = _time
    private var startTime = System.currentTimeMillis()
    init { updateTime() }
    private fun updateTime() { _time.value = System.currentTimeMillis() - startTime }
    override fun onCleared() { super.onCleared(); Logger.d("ViewModel cleared — frigör resurser") }
}
// I Activity
class TimerActivity : AppCompatActivity() {
    private val viewModel: TimerViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState); Logger.d("Activity created") }
    override fun onResume() { super.onResume(); viewModel.time.observe(this) { Logger.d("Time: $it") } }
    override fun onPause() { super.onPause(); Logger.d("Activity paused — pausa animationer") }
    override fun onDestroy() { super.onDestroy(); Logger.d("Activity destroyed — rensning") }
}

ViewModel överlever skärmrotation och förstörs endast vid finish() Activity. onCleared() — plats för att frigöra resurser, avsluta prenumerationer. LiveData pausar automatiskt observation vid onPause och återupptar vid onResume — ger skydd mot läckor och krascher under bakgrundsarbete. I Compose använd collectAsStateWithLifecycle() för samma ändamål.