LifecycleOwner — यह क्या है, Jetpack इंटरफ़ेस और ईवेंट सदस्यता

LifecycleOwner क्या है?

LifecycleOwner androidx.lifecycle पैकेज से एक इंटरफ़ेस है जिसमें एक ही विधि getLifecycle() है, जो एक Lifecycle ऑब्जेक्ट लौटाता है। यह ऑब्जेक्ट घटक की वर्तमान अवस्था (CREATED, STARTED, RESUMED, DESTROYED) को ट्रेक करता है और बदलने पर सभी सदस्य प्रेक्षकों को सूचित करता है। LifecycleOwner Architecture Components का हिस्सा है और lifecycle-runtime लायब्रेरी में शामिल है।

इस इंटरफ़ेस का मुख्य उद्देश्य जीवन चक्र तक पहुंच को मानकीकृत करना है। Jetpack से पहले, डिवेलपर मैनुअली onStart में सदस्यता लेते थे और onStop में सदस्यता समाप्त करते थे, जिससे कोड दुहराव और त्रुटियाँ होती थीं। LifecycleOwner सभी Android घटकों के लिए एकीकृत तंत्र प्रदान करके इस समस्या को हल करता है। जीवन चक्र विधियों को स्पष्ट रूप से बुलाने के बजाय, डिवेलपर एक बार Lifecycle में सदस्यता लेता है, और सूचनाएँ स्वचालित रूप से आती हैं।

इंटरफ़ेस को Kotlin में एक एक्ल अमूर्त विधि के साथ एक कार्यात्मक इंटरफ़ेस के रूप में घोषित किया गया है:

interface LifecycleOwner {
    val lifecycle: Lifecycle
}

इंटरफ़ेस की कार्यात्मक प्रकृति के कारण, इसे डिलेगेट या लैम्ब्डा का उपयोग करके लागू करना आसान है। यह विशेष रूप से Custom Views और ViewModel वर्ग बनाने के लिए उपयोगी है जो होस्ट के जीवन चक्र में बदलाव के प्रति अभिक्रिया दे सकें। getLifecycle() से प्राप्त Lifecycle ऑब्जेक्ट सदस्यताओं को प्रबंधित करने के लिए addObserver और removeObserver विधियाँ प्रदान करता है।

LifecycleOwner कैसे काम करता है

LifecycleOwner दो मुख्य वर्गों के साथ मिलकर काम करता है: Lifecycle और LifecycleObserver। Lifecycle घटक की वर्तमान स्थिति को State एनम (INITIALIZED, CREATED, STARTED, RESUMED, DESTROYED) के रूप में संग्रहीत करता है और उनके बीच संक्रमणों को ट्रेक करता है। जब स्थिति बदलती है, Lifecycle सभी पंजीकृत प्रेक्षकों को संबंधित एनोटेटेड विधियों को बुलाकर सूचित करता है। इस तंत्र को “जीवन चक्र-जागरूक” कहा जाता है — कोड केवल तब निष्पादित होता है जब घटक उपयुक्त अवस्था में हो।

ईवेंट वितरण तंत्र Observer पैटर्न पर आधारित है। LifecycleOwner Observable के रूप में कार्य करता है, और LifecycleObserver कार्यान्वयन Observer के रूप में कार्य करता है। जब Activity या Fragment अपनी अवस्था बदलती है (onCreate → onStart → onResume → onPause → onStop → onDestroy), तो यह आंतरिक ReportFragment तंत्र के माध्यम से Lifecycle को सूचित करती है, जो स्वचालित रूप से AndroidX सिस्टम में जोड़ा जाता है। डिवेलपर को Lifecycle विधियों को मैनुअली कॉल करने की आवश्यकता नहीं है — सबकुछ स्वचालित रूप से होता है।

एक महत्वपूर्ण विवरण: Lifecycle गारंटी देता है कि ON_STOP और ON_DESTROY ईवेंट प्रक्रिया क्रैश की स्थिति में भी पहुंचाए जाएँगे। यह LifecycleOwner को महत्वपूर्ण संसाधनों को मुक्त करने के लिए एक विश्वसनीय उपकरण बनाता है। नियमित स्थिति संरक्षण के लिए, ViewModel में SavedStateHandle का उपयोग करने की अनुशंसा है, लेकिन LifecycleOwner बुनियादी स्तर की सुरक्षा प्रदान करता है।

LifecycleObserver और DefaultLifecycleObserver

LifecycleOwner ईवेंट की सदस्यता लेने के दो तरीके हैं: एनोटेशन के साथ क्लासिकी LifecycleObserver और स्पष्ट विधियों के साथ आधुनिक DefaultLifecycleObserver। Google 2022 से दूसरे दृष्टिकोण की अनुशंसा करता है, क्योंकि यह बेहतर प्रकार सुरक्षा प्रदान करता है और एनोटेशन-आधारित दृष्टिकोण में उपयोग होने वाले परावर्तन से बचता है। DefaultLifecycleObserver को Java 8+ या Kotlin की आवश्यकता है और नए प्रोजेक्टों के लिए यह पसंदीदा विकल्प है।

DefaultLifecycleObserver के माध्यम से सदस्यता का उदाहरण:

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // घटक सक्रिय होने पर ही GPS ट्रैकिंग शुरू करें
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        // पृष्ठभूमि में जाने पर सुरक्षित रूकना
        stopLocationUpdates()
    }
}

// कनेक्शन:
lifecycleOwner.lifecycle.addObserver(MyObserver())

DefaultLifecycleObserver की प्रत्येक विधि एक LifecycleOwner पैरामिटर के रूप में लेती है। यह प्रेक्षक को इसे अलग से पास किए बिना निष्पादित घटक के संदर्भ तक पहुंचने की अनुमति देता है। यह दृष्टिकोण कोड को अधिक मॉड्यूलर और परीक्षणयोग्य बनाता है — Observer Activity या Fragment के विशिष्ट कार्यान्वयन पर निर्भर नहीं करता, बल्कि LifecycleOwner एब्सट्रैक्शन के साथ काम करता है।

एनोटेशन-आधारित LifecycleObserver दृष्टिकोण

@OnLifecycleEvent एनोटेशन का उपयोग करने वाला पुराना तरीका अभी भी लेगसी प्रोजेक्टों में पाया जाता है, लेकिन नए कोड के लिए इसका उपयोग अनुशंसित नहीं है। एनोटेशन को संसाधित करने के लिए आवश्यक परावर्तन ओवरहेड बढ़ाता है और त्रुटियों का कारण बन सकता है जो कंपाइल टाइम पर पकड़ी नहीं जातीं। Google आधिकारिक रूप से DefaultLifecycleObserver में स्थानांतरित होने की सलाह देता है।

// पुराना दृष्टिकोण — नए प्रोजेक्टों के लिए अनुशंसित नहीं
class MyLegacyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        startLocationUpdates()
    }

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

एनोटेशन-आधारित दृष्टिकोण में एक महत्वपूर्ण खामी है: Observer जीवनकाल नियंत्रण का अभाव। यदि डिवेलपर LifecycleOwner के नष्ट होने पर Observer की सदस्यता रद्द करना भूल जाता है, तो Observer ऑब्जेक्ट कचरा संग्रहक चलने तक मेमरी में रहता है। DefaultLifecycleObserver इस समस्या को हल करता है — Observer Lifecycle से बंधा होता है और DESTROYED अवस्था में जाने पर स्वचालित रूप से सदस्यता समाप्त कर देता है।

Activity और Fragment में LifecycleOwner

AppCompat 1.1.0 और AndroidX Fragment 1.2.0 से, AppCompatActivity या Fragment को बढ़ाने वाली सभी Activity और Fragment स्वचालित रूप से LifecycleOwners हैं। इसका मतलब है कि getLifecycle() विधि डिफ़ॉल्ट रूप से उपलब्ध है, और जीवन चक्र ईवेंट की सदस्यता बिना किसी अतिरिक्त सेटअप के काम करती है। डिवेलपर को बस Activity या Fragment में कहीं से भी lifecycle.addObserver() कॉल करनी है।

आइए Activity में LifecycleOwner के एकीकरण का उदाहरण देखें:

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

इस उदाहरण में, lifecycle AndroidX Activity के कारण उपलब्ध एक एक्सटेंशन प्रॉपर्टी है। LocationObserver स्वचालित रूप से Activity के शुरू (ON_START) और रुकने (ON_STOP) की सूचनाएँ प्राप्त करेगा। स्क्रीन घूमने पर, Observer को ON_DESTROY और फिर ON_CREATE की सूचना दी जाती है, जो बिना अतिरिक्त कोड के कॉन्फ़िगरेशन परिवर्तनों को सही ढंग से संभालने की अनुमति देता है।

Fragment में LifecycleOwner

Fragment अपने इंटरफ़ेस के माध्यम से LifecycleOwner को लागू करता है, और इसका Lifecycle पैरेंट Activity के बजाय Fragment के जीवन चक्र से बंधा होता है। यह महत्वपूर्ण है: Fragment का Lifecycle DESTROYED में तब जाता है जब Fragment को ट्रैंजेक्शन से हटाया जाता है, जबकि Activity RESUMED में रह सकती है। यह अंतर प्रेक्षकों को प्रत्येक घटक के जीवन चक्र में अलग-अलग सदस्यता लेने की अनुमति देता है।

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

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

Fragment में LifecycleOwner का उपयोग करने का एक महत्वपूर्ण लाभ Fragment के DESTROYED में जाने पर स्वचालित सदस्यता समाप्ति है। यह विशेष रूप से ViewPager के लिए प्रासंगिक है, जहाँ Fragments गतिशील रूप से बनाए और नष्ट किए जा सकते हैं। इस परिदृश्य में मैनुअल सदस्यता प्रबंधन अत्यन्त जटिल और त्रुटि-प्रवण होगा।

कस्टम LifecycleOwner बनाना

LifecycleOwner इंटरफ़ेस किसी भी ऐसे वर्ग में लागू किया जा सकता है जिसका जीवन चक्र हो। यह Custom Views, Services और यहाँ तक कुछ आर्किटेक्चरल समाधानों में ViewModel के लिए उपयोगी है। Google सहायक वर्ग LifecycleRegistry प्रदान करता है, जो Lifecycle अवस्था का प्रबंधन करता है और ईवेंट उत्पन्न करता है। डिवेलपर को घटक की अवस्था बदलने पर LifecycleRegistry की उपयुक्त विधियों को मैनुअली कॉल करने की आवश्यकता है।

Custom View में LifecycleOwner के कार्यान्वयन का उदाहरण:

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

इस उदाहरण में, LifecycleRegistry अवस्था भंडार के रूप में कार्य करता है। onStart/onStop विधियों को पैरेंट घटक (जैसे Activity) द्वारा कॉल किया जाना चाहिए जब Custom View दिखाई दे या छिप जाए। LifecycleRegistry अवस्थाओं के बीच संक्रमण के लिए आवश्यक ईवेंट की स्वचालित गणना करता है और सभी सदस्य प्रेक्षकों को सूचित करता है।

कस्टम LifecycleOwner लागू करते समय नियम का पालन करना महत्वपूर्ण है: LifecycleRegistry अवस्था को सभी अन्य कार्यों के बाद, संबंधित जीवन चक्र विधि में सबसे अंत में अपडेट किया जाना चाहिए। यह सुनिश्चित करता है कि प्रेक्षकों को तब सूचना मिले जब घटक नई अवस्था के लिए पूर्ण रूप से तैयार हो। LifecycleRegistry.createUnsafe का एक विकल्प के रूप में उपयोग भी संभव है, लेकिन थ्रेड के साथ सावधानी बरतने की आवश्यकता है।

Jetpack घटकों में LifecycleOwner

LifecycleOwner कई मुख्य Android Jetpack घटकों की नींव है। LiveData सक्रिय अवस्था निर्धारित करने और घटक के नष्ट होने पर स्वचालित रूप से सदस्यता समाप्त करने के लिए LifecycleOwner का उपयोग करता है। ViewModel सीधे LifecycleOwner को लागू नहीं करता, लेकिन SavedStateHandle के माध्यम से Lifecycle प्राप्त कर सकता है। Navigation Component NavBackStackEntry में सदस्यताओं के प्रबंधन के लिए LifecycleOwner का उपयोग करता है। इस संबंध को समझना एप्लिकेशन आर्किटेक्चर को एक ठोस नींव पर बनाने में मदद करता है।

LiveData का 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)
            // कोड केवल तब चलता है जब Activity RESUMED अवस्था में हो
            updateUI(data)
        }
    }
}

LiveData को observe() विधि में एक LifecycleOwner की आवश्यकता होती है क्योंकि यह गारंटी देता है कि UI अपडेट केवल सक्रिय अवस्था में होंगे। यदि Activity पृष्ठभूमि में है, LiveData अंतिम मान रखता है लेकिन Observer को सूचित नहीं करता है। RESUMED में लौटने पर, Observer बिना नेटवर्क या डेटाबेस अनुरोधों के वर्तमान मान प्राप्त करता है।

DataBinding भी प्रेक्षणीय क्षेत्रों को Activity या Fragment के जीवन चक्र से बांधने के लिए LifecycleOwner का उपयोग करता है। यह ViewModel + DataBinding संयोजन में मेमरी लीक से बचने में मदद करता है — LifecycleOwner के नष्ट होने पर सभी सदस्यताएँ स्वचालित रूप से साफ़ हो जाती हैं। यह दृष्टिकोण कोड को घोषणात्मक और सुरक्षित बनाता है।

सबसे अच्छी प्रथाएँ

LifecycleOwner का सही उपयोग कई मुख्य नियमों का पालन करने की मांग करता है। पहला और सबसे महत्वपूर्ण: हमेशा Observer की सदस्यता onCreate/onViewCreated में लें, बाद में नहीं। यह सुनिश्चित करता है कि Observer को Lifecycle की प्रारंभिक अवस्था (onCreate के बाद CREATED) प्राप्त हो और ईवेंट न छूटे। दूसरा नियम: सभी नए प्रोजेक्टों के लिए एनोटेशन-आधारित दृष्टिकोण के बजाय DefaultLifecycleObserver का उपयोग करें।

• LifecycleOwner का संदर्भ स्थैतिक क्षेत्रों या सिंगलटन में संग्रहीत न करें — इससे पूरी Activity लीक हो जाती है
• अवस्था-संवेदनशील संचालन करने से पहले Lifecycle अवस्था की जाँच getCurrentState() के माध्यम से करें
• लैम्ब्डा के अंदर Observer न बनाएँ — प्रत्येक पुनर्गठन एक नया ऑब्जेक्ट बनाएगा, और पुराने Observer स्वचालित रूप से सदस्यता समाप्त नहीं करेंगे
• कोरूटीन के लिए repeatOnLifecycle का उपयोग करें — निर्दिष्ट अवस्था में प्रवेश करने पर ब्लॉक शुरू होता है और इससे बाहर निकलने पर रद्द हो जाता है
• पृष्ठभूमि थ्रेड से LifecycleRegistry पर setCurrentState कॉल न करें — यह जीवन चक्र की एकल-थ्रेड गारंटी का उल्लंघन करता है

कोरूटीन और LifecycleOwner के साथ काम करने का आधुनिक तरीका repeatOnLifecycle एक्सटेंशन है:

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

यह पैटर्न गारंटी देता है कि Flow पर collect केवल STARTED या RESUMED अवस्था में सक्रिय है। STOPPED में जाने पर, संग्रह स्वचालित रूप से रद्द हो जाता है, और STARTED में लौटने पर पुनर्शुरू होता है। repeatOnLifecycle Fragment में Flow से मैनुअल सदस्यता समाप्ति को बदलता है और UI घटकों में असिंक्रोनस डेटा स्ट्रीम के साथ काम करने का Google का अनुशंसित तरीका है।

एक और महत्वपूर्ण अनुशंसा: जीवन चक्र से असंबंधित तर्क के लिए LifecycleObserver का अति उपयोग न करें। यदि किसी घटक को किसी विशिष्ट अवस्था पर कार्रवाई करने की आवश्यकता है लेकिन नष्ट होने पर सदस्यता समाप्ति की आवश्यकता नहीं है, तो onStart/onStop में स्पष्ट विधि कॉल का उपयोग करना बेहतर है। LifecycleObserver लंबे समय तक चलने वाले घटकों (LocationListener, SensorManager) के लिए उचित है जहाँ मैनुअल सदस्यता प्रबंधन जटिल और त्रुटि-प्रवण है।