lifecycleScope — ano ito, pagkakaugnay sa Lifecycle at paggawa sa Android

Ano ang lifecycleScope sa Android?

lifecycleScope — ay isang extension property sa interface ng LifecycleOwner (Activity, Fragment, Service) na nagbibigay ng handa nang CoroutineScope na nakaugnay sa buong lifecycle ng component. Kapag naabot ng LifecycleOwner ang estado na DESTROYED, awtomatikong kinakansela ng lifecycleScope ang lahat ng aktibong coroutine.

// Sa Fragment o Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("Kumusta!")
}

Hindi tulad ng viewModelScope, kinakansela ang lifecycleScope sa bawat pagkasira ng LifecycleOwner — kabilang ang pag-ikot ng screen. Ginagawa nitong perpekto para sa mga operasyon na dapat mabuhay lamang habang nakikita ang isang partikular na screen.

Saan available ang lifecycleScope

Available ang lifecycleScope saanman mayroong LifecycleOwner:

• Activity — AppCompatActivity ay nagmamana ng LifecycleOwner
• Fragment — Fragment ay nagmamana ng LifecycleOwner
• LifecycleService — serbisyo na may lifecycle
• ProcessLifecycleOwner — lifecycle ng buong aplikasyon
• Custom na LifecycleOwner — anumang bagay na nagpapatupad ng LifecycleOwner

Paano gumagana ang lifecycleScope: Lifecycle at awtomatikong pagkansela

Ang mekanismo ng awtomatikong pagkansela ng lifecycleScope ay batay sa subscription sa mga pangyayari sa Lifecycle. Kapag bumaba ang Lifecycle sa ibaba ng CREATED patungong DESTROYED, kinakansela ang scope.

Mga estado ng Lifecycle

Panloob na istruktura ng lifecycleScope

Ang lifecycleScope ay nilikha bilang CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) at iniimbak sa loob ng Lifecycle. Kapag lumipat ang Lifecycle sa estado na DESTROYED, tinatawag ang scope.cancel(). Ang mekanismo ay ipinatupad sa pamamagitan ng LifecycleEventObserver, na nag-subscribe sa mga pangyayari sa lifecycle sa unang pag-access sa scope.

Pag-uugali sa pag-ikot

Sa pag-ikot ng screen, nawasak ang Activity (onDestroy) at muling nilikha. Kinakansela ang lifecycleScope kasama ang lumang Activity, at isang bagong instance ng scope ang nilikha para sa bagong Activity. Ito ay pangunahing pagkakaiba mula sa viewModelScope, na pinapanatili sa pag-ikot.

API ng lifecycleScope: launch, launchWhen at repeatOnLifecycle

Ang library ng lifecycle ay nagbibigay ng ilang paraan upang magpatakbo ng mga coroutine sa pamamagitan ng lifecycleScope. Tingnan natin ang ebolusyon ng API mula sa mga lumang pamamaraan patungo sa moderno.

lifecycleScope.launch — batayang paglunsad

Ang pinakasimpleng paraan — lifecycleScope.launch { ... }. Agad na magsisimula ang coroutine at kinakansela sa DESTROYED. Gayunpaman, maaari itong mag-execute ng code kahit hindi nakikita ang UI (halimbawa, sa background pagkatapos ng onStop). Ito ay hindi palaging kanais-nais.

Luma: launchWhenCreated / launchWhenStarted / launchWhenResumed

Ang mga pamamaraang ito ay nagpa-pause ng pagpapatupad ng coroutine kapag bumaba ang Lifecycle sa ibaba ng tinukoy na estado at nagpatuloy sa pagbabalik. Gayunpaman, minarkahan ang mga ito bilang @Deprecated sa lifecycle-runtime-ktx 2.6.0, dahil:

• Hindi kinakansela ang coroutine — pinapa-pause lamang
• Nagdulot ng akumulasyon ng mga nakabitin na coroutine na kumukonsumo ng memorya
• Lumikha ng race condition sa mabilis na paglipat ng estado

Modernong API: repeatOnLifecycle

repeatOnLifecycle — ang inirerekomendang paraan ng Google para magpatakbo ng mga coroutine na naka-synchronize sa lifecycle. Kinakansela at ni-restart nito ang coroutine sa bawat oras na maabot ng Lifecycle ang isang tinukoy na estado.

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

Ang coroutine na ipinasa sa repeatOnLifecycle ay magsisimula kapag naabot ng Lifecycle ang STARTED at kinakansela kapag bumaba ito sa ibaba ng STARTED. Sa pagbabalik sa STARTED, magsisimula muli ang coroutine. Ito ay ligtas at mahusay — walang coroutine na nakabitin sa pause.

flowWithLifecycle — para sa Flow

Para sa pagkolekta ng data mula sa Flow na isinasaalang-alang ang lifecycle, mayroong operator na flowWithLifecycle. Awtomatiko nitong itinitigil at ipinagpapatuloy ang pagkolekta kapag nagbago ang estado ng Lifecycle:

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

Ang operator na flowWithLifecycle — ang pinakamaikling paraan ng ligtas na subscription sa Flow sa UI layer.

Mga halimbawa ng paggamit ng lifecycleScope

Tingnan natin ang tatlong totoong senaryo ng paggamit ng lifecycleScope sa isang Android application sa Kotlin.

Halimbawa 1: Subscription sa mga update sa lokasyon kapag nakikita lamang ang screen

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)
                }
            }
        }
    }
}

Magsisimula ang coroutine kapag naging nakikita ang fragment (STARTED) at kinakansela kapag umalis ito sa screen (STOPPED). Kung lumipat ang user sa ibang application, ang mga update sa lokasyon ay hindi kumokonsumo ng baterya.

Halimbawa 2: Pagpapatakbo ng animation sa pagsisimula ng fragment

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

Ang animation ay tumatakbo lamang kapag ang fragment ay nasa foreground (RESUMED). Kung i-minimize ng user ang application habang tumatakbo ang animation, kinakansela ang coroutine, at sa pagbabalik ay magsisimula muli ang animation.

Halimbawa 3: Pana-panahong pag-sync ng data sa nakikitang screen

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

Naka-sync ang data bawat 30 segundo, ngunit kapag nakikita lamang ang screen. Sinusuri ng isActive kung hindi kinansela ang coroutine, na tinitiyak ang ligtas na paglabas mula sa loop kapag umalis sa screen.

lifecycleScope vs viewModelScope: mga senaryo ng aplikasyon

Ang parehong scope ay nakaugnay sa lifecycle, ngunit sa magkaibang aspeto nito. Ang pag-unawa sa pagkakaiba ay kritikal para sa tamang arkitektura ng mga Android application.

Pangunahing pagkakaiba

viewModelScope ay nakaugnay sa ViewModel, na nabubuhay sa pag-ikot ng screen. lifecycleScope ay nakaugnay sa LifecycleOwner (Activity/Fragment), na sa pag-ikot ay nawasak at muling nilikha. Tinutukoy nito ang mga senaryo ng kanilang aplikasyon.

Kailan gagamitin ang lifecycleScope

• Subscription sa mga system event (lokasyon, sensor, camera)
• Mga animation at UI effect na nakaugnay sa isang partikular na screen
• Pag-load ng data ng naka-chunk na isinasaalang-alang ang visibility ng screen
• Mga operasyon na dapat huminto kapag umalis sa screen

Kailan gagamitin ang viewModelScope

• Pag-load ng data mula sa Repository
• Business logic na dapat mabuhay sa pag-ikot
• Caching at pagproseso ng data
• Anumang operasyon na ang resulta ay kailangan pagkatapos ng pag-ikot

Pinagsamang paggamit

Sa praktika, ang kumbinasyon ng parehong scope ay madalas na makita: viewModelScope ay naglo-load ng data at namamahala ng estado, lifecycleScope ay nag-subscribe sa Flow mula sa ViewModel na isinasaalang-alang ang lifecycle ng screen. Ang paghihiwalay na ito ng responsibilidad ay itinuturing na best practice sa modernong pag-develop ng Android.

Mga karaniwang pagkakamali sa paggamit ng lifecycleScope

Tingnan natin ang apat na pinakakaraniwang pagkakamali na ginagawa ng mga developer kapag gumagamit ng lifecycleScope.

Pagkakamali 1: Paggamit ng lifecycleScope sa halip na viewModelScope para sa pag-load ng data

Kung sisimulan mo ang pag-load ng data sa lifecycleScope.launch, sa pag-ikot ng screen ay makakansela ang coroutine at kailangang i-load muli ang data. Gumamit ng viewModelScope para sa matagal na operasyon. lifecycleScope — para lamang sa mga gawaing nauugnay sa UI.

Pagkakamali 2: Pagkolekta ng Flow nang walang repeatOnLifecycle

Ang direktang tawag sa viewModel.someFlow.collect { ... } sa loob ng lifecycleScope.launch ay patuloy na nangongolekta ng data kahit hindi nakikita ang screen. Ito ay maaaring humantong sa mga update ng UI sa background at hindi kinakailangang overhead. Laging gamitin ang repeatOnLifecycle o flowWithLifecycle.

Pagkakamali 3: Pagkalimot sa pagkansela kapag umalis sa screen

Bagama't kinakansela ang lifecycleScope sa DESTROYED, ang code pagkatapos ng suspend point ay maaaring hindi maisakatuparan sa biglaang pagkansela. Huwag umasa sa pagpapatupad ng code pagkatapos ng suspend call, maliban kung gumagamit ka ng NonCancellable.

Pagkakamali 4: Paggamit ng lumang launchWhenStarted sa halip na repeatOnLifecycle

Ang launchWhenStarted at mga analog nito ay hindi kinakansela ang coroutine, pinapa-pause lamang ito. Kung ang screen ay lumipat nang maraming beses sa pagitan ng foreground at background, ang coroutine ay nag-iipon ng mga ipinagpaliban na tawag. Lumipat sa repeatOnLifecycle — ito ang tanging tamang paraan ng pag-sync sa Lifecycle.