LifecycleOwner — ano ito, interface ng Jetpack at pag-subscribe sa mga event

Ano ang LifecycleOwner?

LifecycleOwner — ay isang interface mula sa androidx.lifecycle package na naglalaman ng iisang method na getLifecycle(), na nagbabalik ng Lifecycle object. Ang object na ito ay sumusubaybay sa kasalukuyang estado ng component (CREATED, STARTED, RESUMED, DESTROYED) at nagpapaalam sa lahat ng naka-subscribe na observer kapag nagbago ito. Ang LifecycleOwner ay bahagi ng Architecture Components at kasama sa lifecycle-runtime library.

Ang pangunahing gawain ng interface ay i-standardize ang access sa lifecycle. Bago ang pagdating ng Jetpack, ang mga developer ay gumagamit ng manu-manong pag-subscribe sa onStart at pag-unsubscribe sa onStop, na nagdulot ng pagdoble ng code at mga error. Nilulutas ng LifecycleOwner ang problemang ito sa pamamagitan ng pagbibigay ng pinag-isang mekanismo para sa lahat ng Android component. Sa halip na tahasang tumawag ng mga lifecycle method, ang developer ay nag-subscribe sa Lifecycle nang isang beses, at ang mga notification ay dumarating nang awtomatiko.

Ang interface ay dineklara sa Kotlin bilang isang functional interface na may isang abstract method:

interface LifecycleOwner {
    val lifecycle: Lifecycle
}

Dahil sa functional na katangian ng interface, madali itong implementasyon gamit ang delegado o lambda. Ito ay lalong maginhawa para sa paglikha ng Custom Views at ViewModel class na dapat tumugon sa mga pagbabago sa lifecycle ng host. Ang Lifecycle object na nakuha mula sa getLifecycle() ay nagbibigay ng mga addObserver at removeObserver method para sa pamamahala ng mga subscription.

Paano gumagana ang LifecycleOwner

LifecycleOwner ay gumagana kasama ng dalawang pangunahing class: Lifecycle at LifecycleObserver. Ang Lifecycle ay nag-iimbak ng kasalukuyang estado ng component bilang enum State (INITIALIZED, CREATED, STARTED, RESUMED, DESTROYED) at sinusubaybayan ang mga transition sa pagitan nila. Kapag nagbago ang estado, ang Lifecycle ay nagpapaalam sa lahat ng rehistradong observer, na tumatawag sa mga kaukulang annotated method. Ang mekanismong ito ay tinatawag na „lifecycle-aware" — ang code ay na-e-execute lamang kapag ang component ay nasa angkop na estado.

Ang mekanismo ng pagpapadala ng event ay batay sa Observer pattern. Ang LifecycleOwner ay gumaganap bilang Observable, at ang implementasyon ng LifecycleObserver ay gumaganap bilang Observer. Ang Activity o Fragment kapag nagbabago ang estado nito (onCreate → onStart → onResume → onPause → onStop → onDestroy) ay nagpapaalam sa Lifecycle sa pamamagitan ng panloob na mekanismo ng ReportFragment, na awtomatikong idinaragdag sa AndroidX system. Hindi kailangan ng developer na manu-manong tumawag ng Lifecycle method — lahat ay nangyayari nang awtomatiko.

Isang mahalagang detalye: Lifecycle ay ginagarantiyahan na ang mga event na ON_STOP at ON_DESTROY ay maihahatid kahit sa kaso ng abnormal na pagtatapos ng proseso. Ito ay ginagawang maaasahang tool ang LifecycleOwner para sa pagpapalaya ng mga kritikal na resource. Para sa ordinaryong pag-save ng estado, inirerekomenda ang paggamit ng SavedStateHandle sa ViewModel, ngunit ang LifecycleOwner ay nagbibigay ng batayang antas ng seguridad.

LifecycleObserver at DefaultLifecycleObserver

Mayroong dalawang paraan upang mag-subscribe sa mga event ng LifecycleOwner: klasikong LifecycleObserver na may mga annotation at modernong DefaultLifecycleObserver na may tahasang method. Ang pangalawang paraan ay inirerekomenda ng Google mula noong 2022, dahil nagbibigay ito ng mas mahusay na type safety at iniiwasan ang reflection na ginamit sa annotation approach. Ang DefaultLifecycleObserver ay nangangailangan ng Java 8+ o Kotlin at mas pinipili para sa mga bagong proyekto.

Halimbawa ng pag-subscribe sa pamamagitan ng DefaultLifecycleObserver:

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Pagsisimula ng GPS tracking kapag ang component ay aktibo lamang
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        // Ligtas na paghinto kapag lumipat sa background mode
        stopLocationUpdates()
    }
}

// Koneksyon:
lifecycleOwner.lifecycle.addObserver(MyObserver())

Ang bawat method ng DefaultLifecycleObserver ay tumatanggap ng LifecycleOwner bilang parameter. Ito ay nagpapahintulot sa observer na ma-access ang konteksto ng executing component nang hindi kinakailangang ipasa ito nang hiwalay. Ang ganitong paraan ay ginagawang mas modular at testable ang code — ang Observer ay hindi nakadepende sa konkretong implementasyon ng Activity o Fragment, kundi gumagana sa abstraction ng LifecycleOwner.

Annotation approach ng LifecycleObserver

Ang lumang paraan gamit ang annotation na @OnLifecycleEvent ay matatagpuan pa rin sa legacy projects, ngunit ang paggamit nito ay hindi inirerekomenda para sa bagong code. Ang reflection na kinakailangan para sa pagproseso ng mga annotation ay nagdadagdag ng overhead at maaaring humantong sa mga error na hindi natutukoy sa compilation stage. Opisyal na inirerekomenda ng Google ang pag-migrate sa DefaultLifecycleObserver.

// Lumang paraan — hindi inirerekomenda para sa mga bagong proyekto
class MyLegacyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        startLocationUpdates()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        stopLocationUpdates()
    }
}

Ang annotation approach ay may makabuluhang kakulangan: kawalan ng kontrol sa lifespan ng Observer. Kung nakalimutan ng developer na i-unsubscribe ang Observer kapag nawasak ang LifecycleOwner, ang Observer object ay mananatili sa memory hanggang sa tawagin ang garbage collector. Nilulutas ng DefaultLifecycleObserver ang problemang ito — ang Observer ay nakatali sa Lifecycle at awtomatikong nag-a-unsubscribe kapag lumipat sa estado ng DESTROYED.

LifecycleOwner sa Activity at Fragment

Mula sa AppCompat 1.1.0 at AndroidX Fragment 1.2.0, lahat ng Activity at Fragment na nagmamana ng AppCompatActivity o Fragment ay awtomatikong LifecycleOwner. Ito ay nangangahulugan na ang getLifecycle() method ay available sa kanila bilang default, at ang pag-subscribe sa lifecycle event ay gumagana nang walang karagdagang configuration. Ang developer ay kailangan lamang tumawag ng lifecycle.addObserver() mula sa kahit saang lugar sa Activity o Fragment.

Tingnan natin ang halimbawa ng integrasyon ng LifecycleOwner sa Activity:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(LocationObserver(this))
    }
}

Sa halimbawang ito ang lifecycle ay isang extension property, na available dahil sa AndroidX Activity. Ang Observer na LocationObserver ay awtomatikong makakatanggap ng mga notification tungkol sa pagsisimula (ON_START) at paghinto (ON_STOP) ng Activity. Sa pag-ikot ng screen, ang Observer ay inaalam tungkol sa ON_DESTROY at pagkatapos ay ON_CREATE, na nagpapahintulot ng tamang paghawak ng configuration changes nang walang karagdagang code.

LifecycleOwner sa Fragment

Fragment ay nag-iimplementa ng LifecycleOwner sa pamamagitan ng interface, at ang Lifecycle nito ay nakatali sa lifecycle ng Fragment, hindi sa parent na Activity. Ito ay mahalaga: ang Lifecycle ng Fragment ay napupunta sa DESTROYED kapag ang Fragment ay tinanggal mula sa transaction, habang ang Activity ay maaaring manatili sa RESUMED. Ang pagkakaibang ito ay nagpapahintulot sa Observer na mag-subscribe nang hiwalay sa lifecycle ng bawat component.

class MyFragment : Fragment() {
    private val uiStateObserver = UiStateObserver()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        lifecycle.addObserver(uiStateObserver)
    }
}

Isang mahalagang bentahe ng paggamit ng LifecycleOwner sa Fragment ay ang awtomatikong pag-unsubscribe kapag ang Fragment ay pumasok sa DESTROYED. Ito ay lalong mahalaga para sa ViewPager, kung saan ang mga Fragment ay maaaring dynamic na malikha at masira. Ang manu-manong pamamahala ng mga subscription sa sitwasyong ito ay lubhang kumplikado at madaling kapitan ng error.

Paglikha ng sariling LifecycleOwner

Ang interface na LifecycleOwner ay maaaring implementasyon sa anumang class na may lifecycle. Ito ay kapaki-pakinabang para sa Custom Views, Service, at kahit ViewModel sa ilang architectural solution. Nagbibigay ang Google ng helper class na LifecycleRegistry na namamahala sa estado ng Lifecycle at bumubuo ng mga event. Kailangan ng developer na manu-manong tumawag ng mga kaukulang method ng LifecycleRegistry kapag nagbago ang estado ng component.

Halimbawa ng implementasyon ng LifecycleOwner sa Custom View:

class MyCustomView(
    context: Context,
    attrs: AttributeSet?
) : FrameLayout(context, attrs), LifecycleOwner {

    private val lifecycleRegistry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry

    fun onStart() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED)
    }

    fun onStop() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED)
    }
}

Sa halimbawang ito ang LifecycleRegistry ay gumaganap bilang imbakan ng estado. Ang mga method na onStart/onStop ay dapat tawagin ng parent component (hal., Activity) kapag ang Custom View ay naging visible o nakatago. Ang LifecycleRegistry ay awtomatikong nagkakalkula ng mga kinakailangang event para sa transition sa pagitan ng mga estado at nagpapaalam sa lahat ng naka-subscribe na Observer.

Sa pag-iimplementa ng sariling LifecycleOwner, mahalagang sundin ang panuntunan: ang estado ng LifecycleRegistry ay dapat na-update na pinakahuli sa kaukulang lifecycle method, pagkatapos ng lahat ng iba pang operasyon. Ito ay ginagarantiyahan na ang mga Observer ay makakatanggap ng notification kapag ang component ay ganap nang handa para sa bagong estado. Ang paggamit ng LifecycleRegistry.createUnsafe bilang alternatibo ay posible rin, ngunit nangangailangan ng pag-iingat sa mga thread.

LifecycleOwner sa Jetpack component

LifecycleOwner ay pundasyon para sa ilang pangunahing Android Jetpack component. LiveData ay gumagamit ng LifecycleOwner para sa pagtukoy ng aktibong estado at awtomatikong pag-unsubscribe kapag nawasak ang component. ViewModel ay hindi direktang nag-iimplementa ng LifecycleOwner, ngunit maaaring makatanggap ng Lifecycle sa pamamagitan ng SavedStateHandle. Navigation Component ay gumagamit ng LifecycleOwner para sa pamamahala ng mga subscription sa NavBackStackEntry. Ang pag-unawa sa ugnayang ito ay tumutulong sa pagbuo ng architecture ng application sa matibay na pundasyon.

Interaksyon ng LiveData sa LifecycleOwner:

class ExampleActivity : AppCompatActivity() {
    private val viewModel: ExampleViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        viewModel.userData.observe(this) { data ->
            // this — LifecycleOwner (Activity)
            // Ang code ay na-e-execute lamang kapag ang Activity ay nasa estado ng RESUMED
            updateUI(data)
        }
    }
}

Ang LiveData ay nangangailangan ng LifecycleOwner sa observe() method dahil ito ay ginagarantiyahan na ang mga update sa UI ay mangyayari lamang sa aktibong estado. Kung ang Activity ay nasa background, ang LiveData ay nag-iimbak ng huling halaga ngunit hindi nagpapaalam sa Observer. Sa pagbalik sa RESUMED, ang Observer ay tumatanggap ng kasalukuyang halaga nang walang karagdagang kahilingan sa network o database.

DataBinding ay gumagamit din ng LifecycleOwner para sa pagbubuklod ng observable field sa lifecycle ng Activity o Fragment. Ito ay nagpapahintulot na maiwasan ang memory leaks sa kombinasyon ng ViewModel + DataBinding — lahat ng subscription ay awtomatikong nililinis kapag nawasak ang LifecycleOwner. Ang ganitong paraan ay ginagawang deklaratibo at ligtas ang code.

Mga rekomendasyon sa paggamit

Ang tamang paggamit ng LifecycleOwner ay nangangailangan ng pagsunod sa ilang pangunahing panuntunan. Una at pinakamahalaga: palaging mag-subscribe ng Observer sa onCreate/onViewCreated, hindi mamaya. Ito ay ginagarantiyahan na ang Observer ay makakatanggap ng paunang estado ng Lifecycle (CREATED pagkatapos ng onCreate) at hindi makaligtaan ang mga event. Pangalawang panuntunan: gamitin ang DefaultLifecycleObserver sa halip na annotation approach para sa lahat ng bagong proyekto.

• Huwag mag-imbak ng reference sa LifecycleOwner sa static field o singleton — ito ay nagdudulot ng pagtagas ng buong Activity
• Suriin ang estado ng Lifecycle sa pamamagitan ng getCurrentState() bago magsagawa ng mga operasyong sensitibo sa estado
• Huwag lumikha ng Observer sa loob ng lambda — bawat recomposition ay lilikha ng bagong object, at ang mga lumang Observer ay hindi awtomatikong mag-a-unsubscribe
• Gamitin ang repeatOnLifecycle para sa coroutine — ang block ay magsisimula kapag pumasok sa tinukoy na estado at kakanselahin kapag lumabas dito
• Huwag tawagin ang setCurrentState sa LifecycleRegistry mula sa background thread — ito ay lumalabag sa single-thread na garantiya ng lifecycle

Ang modernong paraan sa pagtatrabaho sa coroutine at LifecycleOwner — ang extension na repeatOnLifecycle:

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

Ang pattern na ito ay ginagarantiyahan na ang collect sa Flow ay aktibo lamang sa estado ng STARTED o RESUMED. Sa paglipat sa STOPPED, ang koleksyon ay awtomatikong kakanselahin, at sa pagbalik sa STARTED — muling sisimulan. Ang repeatOnLifecycle ay pumapalit sa manu-manong pag-unsubscribe mula sa Flow sa Fragment at ang inirerekomendang paraan ng Google para sa pagtatrabaho sa asynchronous data stream sa UI component.

Isa pang mahalagang rekomendasyon: huwag abusuhin ang LifecycleObserver para sa lohika na hindi nauugnay sa lifecycle. Kung ang component ay dapat magsagawa ng aksyon sa isang partikular na estado ngunit hindi nangangailangan ng pag-unsubscribe kapag nawasak, mas mainam na gamitin ang tahasang pagtawag ng mga method sa onStart/onStop. Ang LifecycleObserver ay makatwiran para sa mahabang-buhay na component (LocationListener, SensorManager), kung saan ang manu-manong pamamahala ng subscription ay kumplikado at madaling kapitan ng error.