lifecycleScope — mi ez, kapcsolódás a Lifecycle-hez és munka Androidban

Mi az a lifecycleScope Androidban?

lifecycleScope — egy kiterjesztési tulajdonság a LifecycleOwner (Activity, Fragment, Service) interfészen, amely egy kész CoroutineScope-ot biztosít, amely a komponens teljes életciklusához van kötve. Amikor a LifecycleOwner eléri a DESTROYED állapotot, a lifecycleScope automatikusan törli az összes aktív korutint.

// Fragmentben vagy Activity-ben
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Helló!")
}

A viewModelScope-tól eltérően a lifecycleScope minden LifecycleOwner megsemmisülésekor törlődik — beleértve a képernyő-forgatást is. Ez ideálissá teszi olyan műveletekhez, amelyeknek csak addig kell élniük, amíg egy adott képernyő látható.

Hol érhető el a lifecycleScope

lifecycleScope mindenhol elérhető, ahol LifecycleOwner van:

• Activity — AppCompatActivity örökli a LifecycleOwner-t
• Fragment — Fragment örökli a LifecycleOwner-t
• LifecycleService — szolgáltatás életciklussal
• ProcessLifecycleOwner — a teljes alkalmazás életciklusa
• Egyéni LifecycleOwner — bármely objektum, amely megvalósítja a LifecycleOwner-t

Hogyan működik a lifecycleScope: Lifecycle és automatikus törlés

A lifecycleScope automatikus törlésének mechanizmusa a Lifecycle eseményekre való feliratkozáson alapul. Amikor a Lifecycle a CREATED alá esik DESTROYED-be, a scope törlődik.

Lifecycle állapotok

A lifecycleScope belső felépítése

A lifecycleScope CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) ként jön létre, és a Lifecycle-en belül tárolódik. Amikor a Lifecycle DESTROYED állapotba lép, a scope.cancel() hívódik meg. A mechanizmus LifecycleEventObserver-n keresztül valósul meg, amely a scope első elérésekor feliratkozik az életciklus eseményekre.

Viselkedés forgatáskor

A képernyő forgatásakor az Activity megsemmisül (onDestroy) és újrateremtődik. A lifecycleScope törlődik a régi Activity-vel együtt, és egy új scope példány jön létre az új Activity számára. Ez alapvető különbség a viewModelScope-tól, amely megmarad forgatáskor.

lifecycleScope API: launch, launchWhen és repeatOnLifecycle

A Lifecycle könyvtár több módot kínál korutinok indítására a lifecycleScope-on keresztül. Tekintsük át az API evolúcióját az elavult módszerektől a modernekig.

lifecycleScope.launch — alap indítás

A legegyszerűbb mód — lifecycleScope.launch { ... }. A korutin azonnal elindul és DESTROYED-nél törlődik. Azonban kódot hajthat végre akkor is, amikor az UI nem látható (pl. háttérben onStop után). Ez nem mindig kívánatos.

Elavult: launchWhenCreated / launchWhenStarted / launchWhenResumed

Ezek a metódusok felfüggesztették a korutin végrehajtását, amikor a Lifecycle a megadott állapot alá esett, és folytatták visszatéréskor. Azonban @Deprecated-ként lettek megjelölve a lifecycle-runtime-ktx 2.6.0-ban, mert:

• Nem törölték a korutint — csak felfüggesztették
• Memóriát fogyasztó függő korutinok felhalmozódásához vezettek
• Versenyhelyzetet (race condition) hoztak létre gyors állapotváltáskor

Modern API: repeatOnLifecycle

repeatOnLifecycle — a Google által ajánlott mód az életciklussal szinkronizált korutinok indítására. Minden alkalommal törli és újraindítja a korutint, amikor a Lifecycle elér egy megadott állapotot.

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

A repeatOnLifecycle-be átadott korutin akkor indul, amikor a Lifecycle eléri a STARTED-et, és törlődik, amikor a STARTED alá esik. A STARTED-be való visszatéréskor a korutin újraindul. Ez biztonságos és hatékony — egyetlen korutin sem lóg a szünetben.

flowWithLifecycle — Flow-hoz

A Flow-ból történő adatgyűjtéshez az életciklus figyelembevételével létezik a flowWithLifecycle operátor. Automatikusan leállítja és folytatja a gyűjtést a Lifecycle állapotának változásakor:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

A flowWithLifecycle operátor — a legtömörebb mód a Flow biztonságos feliratkozására az UI rétegben.

Példák a lifecycleScope használatára

Tekintsünk három valós forgatókönyvet a lifecycleScope használatára egy Android alkalmazásban Kotlin nyelven.

1. példa: Helyzetfrissítésekre feliratkozás csak amikor a képernyő látható

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

A korutin akkor indul, amikor a fragment láthatóvá válik (STARTED), és törlődik, amikor elhagyja a képernyőt (STOPPED). Ha a felhasználó másik alkalmazásra vált, a helyzetfrissítések nem fogyasztják az akkumulátort.

2. példa: Animáció indítása a fragment indulásakor

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

Az animáció csak akkor indul, amikor a fragment az előtérben van (RESUMED). Ha a felhasználó minimalizálja az alkalmazást az animáció alatt, a korutin törlődik, és visszatéréskor az animáció újraindul.

3. példa: Időszakos adatszinkronizálás a látható képernyőn

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

Az adatok 30 másodpercenként szinkronizálódnak, de csak amikor a képernyő látható. Az isActive ellenőrzi, hogy a korutin nem lett-e törölve, biztosítva a biztonságos kilépést a ciklusból a képernyő elhagyásakor.

lifecycleScope vs viewModelScope: alkalmazási forgatókönyvek

Mindkét scope az életciklushoz van kötve, de annak különböző aspektusaihoz. A különbség megértése kritikus fontosságú az Android alkalmazások helyes architektúrájához.

Fő különbség

viewModelScope a ViewModel-hez van kötve, amely túléli a képernyő-forgatást. lifecycleScope a LifecycleOwner-hez (Activity/Fragment) van kötve, amely forgatáskor megsemmisül és újrateremtődik. Ez határozza meg alkalmazási forgatókönyveiket.

Mikor használjunk lifecycleScope-ot

• Rendszereseményekre feliratkozás (helyzet, érzékelők, kamera)
• Egy adott képernyőhöz kötött animációk és UI effektusok
• Adatok részletekben történő betöltése a képernyő láthatóságának figyelembevételével
• Műveletek, amelyeknek abba kell hagyniuk a képernyő elhagyásakor

Mikor használjunk viewModelScope-ot

• Adatok betöltése Repository-ból
• Üzleti logika, amelynek túl kell élnie a forgatást
• Gyorsítótárazás és adatfeldolgozás
• Bármely művelet, amelynek eredménye forgatás után szükséges

Kombinált használat

A gyakorlatban mindkét scope kombinációja gyakran előfordul: a viewModelScope betölti az adatokat és kezeli az állapotot, a lifecycleScope feliratkozik a Flow-ra a ViewModel-ből a képernyő életciklusának figyelembevételével. Ezt a felelősségi szétválasztást best practice-nek tekintik a modern Android fejlesztésben.

Gyakori hibák a lifecycleScope használatakor

Tekintsük át a négy leggyakoribb hibát, amelyeket a fejlesztők elkövetnek a lifecycleScope használatakor.

1. hiba: lifecycleScope használata viewModelScope helyett adatok betöltésére

Ha az adatbetöltést lifecycleScope.launch-ban indítja, a képernyő forgatásakor a korutin törlődik, és az adatokat újra be kell tölteni. Hosszú élettartamú műveletekhez használjon viewModelScope-ot. lifecycleScope — csak UI-hoz kapcsolódó feladatokhoz.

2. hiba: Flow gyűjtése repeatOnLifecycle nélkül

A viewModel.someFlow.collect { ... } közvetlen meghívása lifecycleScope.launch-on belül akkor is folytatja az adatgyűjtést, amikor a képernyő nem látható. Ez háttérben történő UI-frissítésekhez és szükségtelen többletterheléshez vezethet. Mindig használjon repeatOnLifecycle-ot vagy flowWithLifecycle-ot.

3. hiba: A törlés elfelejtése a képernyő elhagyásakor

Bár a lifecycleScope DESTROYED-nél törlődik, a felfüggesztési pont (suspend) utáni kód nem biztos, hogy végrehajtódik hirtelen törléskor. Ne támaszkodjon a kód végrehajtására suspend hívás után, hacsak nem használ NonCancellable-t.

4. hiba: Elavult launchWhenStarted használata repeatOnLifecycle helyett

A launchWhenStarted és analógjai nem törlik a korutint, csak felfüggesztik. Ha a képernyő többször vált előtér és háttér között, a korutin felhalmozza az elhalasztott hívásokat. Váltson repeatOnLifecycle-ra — ez az egyetlen helyes mód a Lifecycle-lel való szinkronizálásra.