App Lifecycle: mi ez, az alkalmazás állapotai iOS-ben és Android-ban

Mi az App Lifecycle?

App Lifecycle — egy véges automata, amely leírja a mobilalkalmazás összes lehetséges állapotát és a köztük lévő átmeneteket. Minden állapot meghatározza, hogy az alkalmazás végrehajthat-e kódot, megjeleníthet-e UI-t és fogyaszthat-e erőforrásokat. Az iOS és Android hasonló, de nem azonos modellel rendelkezik — a különbségek az operációs rendszer architektúrájából adódnak: az iOS szigorú memóriakontrollt használ (suspended állapot), az Android — rugalmas folyamatkezelést az onSaveInstanceState-n keresztül.

iOS-ben a lifecycle szorosan kötődik a foreground/background-hoz: az alkalmazás vagy aktív, vagy felfüggesztett. Android-ban a lifecycle granulárisabb — az Activity/Window 6+ állapoton megy keresztül, és magának a folyamatnak van egy további lifecycle-je a ProcessLifecycleOwner-en keresztül. A modern alkalmazások (2024-től) egyre gyakrabban használnak lifecycle-alapú architektúrális mintákat: SwiftUI Lifecycle (iOS 16+) a .scenePhase környezeten keresztül, Compose Lifecycle a LifecycleEventObserver-en keresztül. Ezek a minták automatikusan kezelik a kontextusváltást és megakadályozzák a memóriaszivárgást. A Google szerint a lifecycle helyes kezelése Android-ban 30–40%-kal csökkenti a memóriafogyasztást háttérmunka során.

iOS életciklus: AppDelegate és SceneDelegate

iOS-ben az alkalmazás lifecycle-jét a UIApplicationDelegate (AppDelegate) osztály kezeli. Fő metódusok: application(_:didFinishLaunchingWithOptions:) — inicializálás az első indításkor; applicationDidBecomeActive — az alkalmazás látható és készen áll az interakcióra; applicationWillResignActive — átmenet inaktív állapotba (bejövő hívás, függöny bezárása); applicationDidEnterBackground — az alkalmazás rejtett, ~5 másodperc van az adatok mentésére; applicationWillEnterForeground — visszatérés a háttérből; applicationWillTerminate — befejezés (csak a régi, suspended nélküli alkalmazásoknál hívódik meg).

Az iOS 13-tól kezdve az Apple bevezette a SceneDelegate-et (UISceneDelegate) a többablakos alkalmazások támogatására iPad-en és macOS Catalyst-en. A SceneDelegate kezeli az egyes jelenetek (ablakok) lifecycle-jét: scene(_:willConnectTo:options:) — jelenet létrehozása; sceneDidBecomeActive — jelenet aktív; sceneWillResignActive — jelenet elveszti a fókuszt; sceneDidEnterBackground — jelenet rejtett. Az AppDelegate felelős a globális eseményekért (adatbetöltés, push értesítések), a SceneDelegate pedig — az egyes ablakok UI állapotáért. SwiftUI-ben a lifecycle a @Environment(\.scenePhase) környezeti értéken keresztül kezelődik: .active, .inactive, .background — ez egységes API-t biztosít a SwiftUI és UIKit alkalmazások számára.

Android életciklus: Application és ProcessLifecycleOwner

Android-ban a lifecycle az Application osztállyal kezdődik — egy singleton, amely bármely Activity előtt létrejön. Az Application.onCreate() metódus — az első belépési pont, globális inicializálásra használatos (Analytics, DI, Crash Reporting). Ezután az Activity elindul a következő sorrendben: onCreate() → onStart() → onResume(). Minimalizáláskor: onPause() → onStop() → onSaveInstanceState(). Megsemmisítéskor: onDestroy(). Visszatéréskor: onRestart() → onStart() → onResume().

ProcessLifecycleOwner (az AndroidX Lifecycle 2.2+-ből) a teljes folyamat lifecycle-jét követi, nem az egyes Activity-két. Két állapotot biztosít: ON_RESUME (alkalmazás foreground-ban) és ON_STOP (alkalmazás rejtett). A ProcessLifecycleOwner megoldja a "mikor ment az alkalmazás háttérbe" problémát folyamat szinten — ez kritikus az SDK-k, könyvtárak és moduláris alkalmazások számára. A Jetpack Compose-ban a lifecycle a LifecycleEventObserver és a collectAsStateWithLifecycle segítségével kezelődik, amely automatikusan szünetelteti az adatgyűjtést háttérmódban. Az Android 14 (API 34) hozzáadta a foreground service lifecycle értesítést a Service.onTimeout-on keresztül — a szolgáltatásnak 6 órán belül be kell fejeződnie, különben a rendszer kényszerítetten leállítja.

iOS és Android lifecycle összehasonlítása

Fő különbség: az iOS kényszerítetten Suspended állapotba helyezi az alkalmazást (kód nem fut) 5-10 másodperccel a háttérbe kerülés után. Az Android hosszabb ideig engedélyezi a háttérmunkát (szolgáltatások, WorkManager), de a Doze Mode (Android 6+) és háttérkorlátozások (Android 12+) mellett. ProcessLifecycleOwner Android-ban — az iOS UIApplicationDidEnterBackgroundNotification megfelelője azzal a különbséggel, hogy minden háttérbe lépéskor aktiválódik, nem csak a fókuszvesztés után.

Kódpéldák

iOS: AppDelegate lifecycle metódusokkal

Az AppDelegate alap implementációja az életciklus összes állapotának kezelésével. Adatok mentése háttérbe lépéskor és UI frissítése visszatéréskor.

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 — a lifecycle központi pontja. applicationDidEnterBackground — kritikus metódus: az iOS ~5 másodpercet ad az adatok mentésére. applicationDidBecomeActive — frissítse a UI-t, indítsa újra az animációkat. A SceneDelegate (iOS 13+) esetében a lifecycle logika jelenetekre van osztva: a sceneDidBecomeActive / sceneDidEnterBackground az egyes ablakokat kezeli.

iOS: SceneDelegate (iOS 13+)

SceneDelegate többablakos iPad alkalmazásokhoz. Minden jelenet saját lifecycle-szel rendelkezik, függetlenül a többi ablaktól.

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 kezeli az egyes jelenetek lifecycle-jét. sceneDidBecomeActive / sceneDidEnterBackground — az AppDelegate metódusok megfelelői egy adott ablakhoz. sceneDidDisconnect akkor hívódik meg, amikor a jelenet bezárul (a felhasználó bezárta az ablakot iPad-en). Az iOS 12 és régebbi verziókkal való kompatibilitás megőrzéséhez az AppDelegate-nek duplikálnia kell a SceneDelegate logikáját. iOS 17+ -ban használhatja a @Observable-t a feladatok automatikus szüneteltetéséhez/folytatásához a scenePhase alapján.

Android: Application ProcessLifecycleOwner-rel

A ProcessLifecycleOwner követi, hogy az alkalmazás foreground/background-ban van-e folyamat szinten. Ez az optimális mód a globális lifecycle kezelésére.

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 — az egyetlen helyes mód a háttérbe lépés követésére alkalmazás szinten. Az ON_START akkor aktiválódik, amikor az alkalmazás láthatóvá válik (foreground), az ON_STOP — amikor teljesen rejtett (background). Az Activity lifecycle-től eltérően a ProcessLifecycleOwner nem kötődik egy adott képernyőhöz. Jetpack Compose-hoz használja a LifecycleResumeEffect vagy a collectAsStateWithLifecycle függvényt a manuális megfigyelés helyett.

Android: Activity Lifecycle ViewModel-lel

ViewModel + Lifecycle — a helyes Android architektúra a lifecycle-szel való munkához. A ViewModel automatikusan törlődik onDestroy-kor, megakadályozva a memóriaszivárgást.

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 — erőforrások felszabadítása") }
}
// Activity-ben
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 — animációk szüneteltetése") }
    override fun onDestroy() { super.onDestroy(); Logger.d("Activity destroyed — tisztítás") }
}

ViewModel túléli a képernyő elforgatását és csak a finish() Activity-nél semmisül meg. Az onCleared() — hely az erőforrások felszabadítására, a streamekről való leiratkozásra. A LiveData automatikusan szünetelteti a megfigyelést onPause-kor és folytatja onResume-kor — védelmet nyújt a szivárgások és összeomlások ellen háttérmunka során. A Compose-ban ugyanerre a célra használja a collectAsStateWithLifecycle()-et.