Jetpack Compose में लाइफ़साइकल   Android Jetpack का हिस्सा.

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट, होस्ट ऐक्टिविटी के लाइफ़साइकल की स्थिति में बदलाव होने पर कार्रवाइयां करते हैं. androidx.lifecycle.compose आर्टफ़ैक्ट, खास एपीआई उपलब्ध कराता है. ये एपीआई, स्क्रीन से हटने या ऐप्लिकेशन के बैकग्राउंड में जाने पर संसाधनों को अपने-आप हटा देते हैं.

मुख्य एपीआई में ये शामिल हैं:

• मौजूदा Lifecycle.State के लिए फ़्लो.
• LifecycleEffects, इसकी मदद से किसी खास Lifecycle.Event के आधार पर ब्लॉक चलाया जा सकता है.

ये इंटिग्रेशन, Compose के हेरारकी में लाइफ़साइकल को मैनेज करने के लिए सुविधाजनक हुक उपलब्ध कराते हैं. इस दस्तावेज़ में बताया गया है कि इनका इस्तेमाल अपने ऐप्लिकेशन में कैसे किया जा सकता है.

फ़्लो की मदद से लाइफ़साइकल की स्थिति इकट्ठा करना

लाइफ़साइकल, currentStateFlow प्रॉपर्टी को दिखाता है. यह मौजूदा Lifecycle.State को Kotlin StateFlow के तौर पर दिखाता है. इस Flow को State के तौर पर इकट्ठा किया जा सकता है. इससे आपका ऐप्लिकेशन, कंपोज़िशन के दौरान लाइफ़साइकल में हुए बदलावों को पढ़ सकता है.

val lifecycleOwner = LocalLifecycleOwner.current
val stateFlow = lifecycleOwner.lifecycle.currentStateFlow
…
val currentLifecycleState by stateFlow.collectAsState()

ऊपर दिए गए उदाहरण को lifecycle-common मॉड्यूल का इस्तेमाल करके ऐक्सेस किया जा सकता है. currentStateAsState() मेथड, lifecycle-runtime-compose मॉड्यूल में उपलब्ध है. इससे, लाइफ़साइकल की मौजूदा स्थिति को एक लाइन में आसानी से पढ़ा जा सकता है. यहां दिए गए उदाहरण में इसे दिखाया गया है:

val lifecycleOwner = LocalLifecycleOwner.current
val currentLifecycleState = lifecycleOwner.lifecycle.currentStateAsState()

लाइफ़साइकल इवेंट पर कोड चलाना

DefaultLifecycleObserver को लागू करने वाली अलग क्लास बनाने और उसे मैन्युअल तरीके से लाइफ़साइकल में जोड़ने के बजाय, खास इफ़ेक्ट का इस्तेमाल करके लाइफ़साइकल लॉजिक को इनलाइन तौर पर एलान किया जा सकता है. LifecycleEffects की मदद से, किसी Lifecycle.Event के कंपोज़िशन में सीधे तौर पर शामिल होने पर, ब्लॉक को चलाया जा सकता है.

LifecycleEventEffect

किसी इवेंट के होने पर, कोड के ब्लॉक को चलाने के लिए LifecycleEventEffect का इस्तेमाल करें. यह एक बार होने वाले इवेंट के लिए सबसे सही है. जैसे, लॉगिंग या Analytics. इनमें न तो सफलता की ज़रूरत होती है और न ही तुरंत नतीजे की.

@Composable
fun AnalyticsTracker(screenName: String) {
    // Log an event when the app receives ON_RESUME (e.g. comes to foreground)
    LifecycleEventEffect(Lifecycle.Event.ON_RESUME) {
        Analytics.logView(screenName)
    }
}

LifecycleStartEffect

ऐप्लिकेशन के चालू होने पर शुरू/बंद होने वाली कार्रवाइयों के लिए LifecycleStartEffect का इस्तेमाल करें. ये कार्रवाइयां तब तक चलती हैं, जब तक ऐप्लिकेशन चालू रहता है (दिखता है). ऐप्लिकेशन के बंद होने पर (बैकग्राउंड में), ये कार्रवाइयां बंद हो जाती हैं.

यह Compose के अन्य इफ़ेक्ट (जैसे कि LaunchedEffect) की तरह ही काम करता है. LifecycleStartEffect कुंजी स्वीकार करता है. जब कुंजी बदलती है, तो ब्लॉक फिर से चालू हो जाता है.

जब कोई Lifecycle.Event.ON_STOP इवेंट होता है या इफ़ेक्ट कंपोज़िशन से बाहर निकल जाता है, तो यह onStopOrDispose ब्लॉक को लागू करता है. इससे, शुरुआती ब्लॉक में किए गए काम को साफ़ किया जा सकता है.

@Composable
fun LocationMonitor(locationManager: LocationManager) {
    // Starts monitoring when ON_START is dispatched
    // Stops monitoring when ON_STOP is dispatched
    //   (or the composable leaves the screen)
    LifecycleStartEffect(locationManager) {
        val listener = LocationListener { location ->
            /* update UI */
        }
        locationManager.requestLocationUpdates(listener)
        // The cleanup block automatically runs on ON_STOP or on disposal
        onStopOrDispose {
            locationManager.removeUpdates(listener)
        }
    }
}

अन्य तरह के साइड इफ़ेक्ट के बारे में जानकारी के लिए, Compose में साइड-इफ़ेक्ट देखें.

LifecycleResumeEffect

LifecycleResumeEffect, LifecycleStartEffect की तरह ही काम करता है. हालांकि, यह Lifecycle.Event.ON_RESUME इवेंट से जुड़ा होता है. यह एक onPauseOrDispose ब्लॉक भी उपलब्ध कराता है. जब ON_PAUSE को डिसपैच किया जाता है या कंपोज़ेबल स्क्रीन से हट जाता है, तब यह ब्लॉक क्लीनअप करता है.

यह एपीआई उन संसाधनों के लिए काम का है जिन्हें सिर्फ़ तब चालू होना चाहिए, जब उपयोगकर्ता ऐप्लिकेशन से इंटरैक्ट कर रहा हो. उदाहरण के लिए, कैमरे या ऐनिमेशन.

@Composable
fun CameraPreview(cameraController: CameraController) {
    LifecycleResumeEffect(cameraController) {
        cameraController.startPreview()

        onPauseOrDispose {
            cameraController.stopPreview()
        }
    }
}

LifecycleOwner को ऐक्सेस करना

Compose में, LifecycleOwner, LocalLifecycleOwner नाम के CompositionLocal के ज़रिए इंप्लिसिट तौर पर उपलब्ध होता है. डिफ़ॉल्ट रूप से, आपकी कंपोज़िशन हैरारकी का रूट होस्ट, यह मालिक उपलब्ध कराता है.

val lifecycleOwner = LocalLifecycleOwner.current

कई ऐप्लिकेशन के लिए, डिफ़ॉल्ट मालिक की जांच करना या उसे लाइफ़साइकल के बारे में जानने वाले इफ़ेक्ट में पास करना काफ़ी होता है. हालांकि, कस्टम नेविगेशन या जटिल लेआउट के लिए, आपको अपना LifecycleOwner बनाना पड़ सकता है, ताकि यूज़र इंटरफ़ेस (यूआई) के खास सेक्शन के लिए लाइफ़साइकल की स्थितियां तय की जा सकें. उदाहरण के लिए, नेविगेशन लाइब्रेरी (जैसे कि Navigation 3) ऐसा अपने-आप करती हैं, ताकि हर स्क्रीन का अपना लाइफ़साइकल हो.

कस्टम LifecycleOwner बनाना

rememberLifecycleOwner() एपीआई की मदद से, कस्टम LifecycleOwner बनाया और सेव किया जा सकता है. यह खास तौर पर HorizontalPager जैसे कॉम्पोनेंट के लिए फ़ायदेमंद है. इनमें आपको सिर्फ़ दिखने वाले, सेटल किए गए पेज को RESUMED करना होता है. वहीं, आस-पास के, स्क्रीन से बाहर के पेजों के लिए STARTED का maxState सेट करना होता है.

val pagerState = rememberPagerState(pageCount = { 10 })

HorizontalPager(state = pagerState) { pageNum ->
    val pageLifecycleOwner = rememberLifecycleOwner(
        maxState = if (pagerState.settledPage == pageNum) {
            Lifecycle.State.RESUMED
        } else {
            Lifecycle.State.STARTED
        }
    )

    CompositionLocalProvider(LocalLifecycleOwner provides pageLifecycleOwner) {
        // Your pages here. Their lifecycle-aware components respect the
        // custom maxState defined above.
    }
}

CompositionLocal के बारे में ज़्यादा जानने के लिए, CompositionLocal के साथ स्थानीय तौर पर स्कोप किया गया डेटा देखें.

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट इस्तेमाल करने के सबसे सही तरीके

• अपने यूज़र इंटरफ़ेस (यूआई) कंट्रोलर को जितना हो सके उतना छोटा रखें. उन्हें अपना डेटा हासिल करने की कोशिश नहीं करनी चाहिए. इसके बजाय, ऐसा करने के लिए ViewModel का इस्तेमाल करना चाहिए. साथ ही, यूज़र इंटरफ़ेस (यूआई) में बदलावों को दिखाने के लिए, StateFlow ऑब्जेक्ट का इस्तेमाल करना चाहिए.
• डेटा पर आधारित यूज़र इंटरफ़ेस (यूआई) लिखें. इनमें यूज़र इंटरफ़ेस (यूआई) कंट्रोलर की ज़िम्मेदारी यह होती है कि डेटा में बदलाव होने पर यूज़र इंटरफ़ेस (यूआई) को अपडेट किया जाए या उपयोगकर्ता की कार्रवाइयों के बारे में ViewModel को सूचना दी जाए.
• अपने डेटा लॉजिक को ViewModel क्लास में रखें. ViewModel को आपके यूज़र इंटरफ़ेस (यूआई) कंट्रोलर और आपके ऐप्लिकेशन के बाकी हिस्सों के बीच कनेक्टर के तौर पर काम करना चाहिए. हालांकि, ध्यान रखें कि डेटा फ़ेच करना (उदाहरण के लिए, नेटवर्क से) ViewModel की ज़िम्मेदारी नहीं है. इसके बजाय, ViewModel को डेटा फ़ेच करने के लिए सही कॉम्पोनेंट को कॉल करना चाहिए. इसके बाद, यूज़र इंटरफ़ेस (यूआई) कंट्रोलर को नतीजा देना चाहिए.
• लंबे समय तक चलने वाले टास्क और अन्य कार्रवाइयों को मैनेज करने के लिए, Kotlin कोरूटीन का इस्तेमाल करें. ये कार्रवाइयां एसिंक्रोनस तरीके से चल सकती हैं.
• स्टार्ट/स्टॉप करने की लॉजिक को उस कंपोज़ेबल के अंदर रखें जिसकी ज़रूरत है. इस तरह, अगर उस यूज़र इंटरफ़ेस (यूआई) एलिमेंट को स्क्रीन से हटा दिया जाता है, तो लॉजिक अपने-आप हट जाता है. उदाहरण के लिए, नेविगेशन ग्राफ़ में या जब दिखने की स्थिति शर्त के हिसाब से होती है.
• डेटा के लिए collectAsStateWithLifecycle का इस्तेमाल करें. लाइफ़साइकल इवेंट के आधार पर, Flow कलेक्शन को मैन्युअल तरीके से शुरू या बंद न करें. इसके बजाय, स्ट्रीम को यूज़र इंटरफ़ेस (यूआई) की स्थिति में आसानी से बदलने के लिए, collectAsStateWithLifecycle का इस्तेमाल करें. इससे बैटरी और संसाधनों की बचत होती है, क्योंकि ऐप्लिकेशन के बैकग्राउंड में होने पर Flow रुक जाते हैं.

Flow के बारे में ज़्यादा जानने के लिए, स्टेट के अन्य टाइप लेख पढ़ें.

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के इस्तेमाल के उदाहरण

लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट की मदद से, कई मामलों में लाइफ़साइकल को मैनेज करना आपके लिए बहुत आसान हो सकता है. यहां कुछ उदाहरण दिए गए हैं:

• जगह की जानकारी को अपडेट करने के लिए, मोटे तौर पर और सटीक तौर पर जानकारी पाने की सुविधा के बीच स्विच करना. LifecycleStartEffect का इस्तेमाल करके, ऐप्लिकेशन के दिखने (ON_START) के दौरान जगह की सटीक जानकारी के अपडेट पाने की सुविधा चालू करें. साथ ही, जब ऐप्लिकेशन बैकग्राउंड में हो (ON_STOP), तब लिसनर को अपने-आप बंद कर दें या जगह की सामान्य जानकारी के अपडेट पाने की सुविधा पर स्विच कर दें.
• वीडियो बफ़र होने की प्रोसेस को रोकना और शुरू करना. LifecycleResumeEffect का इस्तेमाल करके, वीडियो को तब तक न चलाएं, जब तक ऐप्लिकेशन पूरी तरह से फ़ोरग्राउंड में न आ जाए और इंटरैक्टिव न हो जाए (ON_RESUME). साथ ही, यह पक्का करें कि जब ऐप्लिकेशन बैकग्राउंड में हो (ON_PAUSE), तब वीडियो चलना बंद हो जाए और संसाधन रिलीज़ हो जाएं.
• नेटवर्क स्ट्रीमिंग शुरू और बंद करना. डेटा की लगातार स्ट्रीम को देखने के लिए, collectAsStateWithLifecycle का इस्तेमाल करें. जैसे, नेटवर्क सॉकेट से Kotlin फ़्लो. इससे ऐप्लिकेशन के फ़ोरग्राउंड में होने पर, आपको लाइव अपडेट मिलता है. साथ ही, ऐप्लिकेशन के बैकग्राउंड में जाने पर, डेटा इकट्ठा करने की प्रोसेस अपने-आप रद्द हो जाती है.
• ज़्यादा संसाधन इस्तेमाल करने वाले टास्क को रोकना और फिर से शुरू करना. ऐप्लिकेशन के बैकग्राउंड में होने पर, विज़ुअल अपडेट को रोकने और ऐप्लिकेशन के फ़ोरग्राउंड में होने पर उन्हें फिर से शुरू करने के लिए, LifecycleResumeEffect का इस्तेमाल करें.

ON_STOP इवेंट को सुरक्षित तरीके से हैंडल करना

Compose को ON_STOP इवेंट को सुरक्षित तरीके से हैंडल करने के लिए डिज़ाइन किया गया है.

• स्टेट सुरक्षित है: ऐप्लिकेशन के बैकग्राउंड में होने पर भी, MutableState को कभी भी अपडेट किया जा सकता है. उदाहरण के लिए, uiState.value = ... का इस्तेमाल करके. बदलावों को रेंडर करने के लिए, कंपोज़ तब तक इंतज़ार करता है, जब तक ऐप्लिकेशन दिखने न लगे.
• अपने-आप क्लीनअप होने की सुविधा: LifecycleStartEffect जैसे इफ़ेक्ट के साथ, आपका क्लीनअप ब्लॉक (onStopOrDispose) ठीक उसी समय चलता है, जब लाइफ़साइकल STOPPED पर पहुंचता है. इससे ऐप्लिकेशन के बैकग्राउंड में चलने के दौरान, कैमरा या जगह की जानकारी जैसे ज़्यादा संसाधन इस्तेमाल करने से रोका जा सकता है.

MutableState के बारे में ज़्यादा जानने के लिए, स्टेट और Jetpack Compose लेख पढ़ें.

अन्य संसाधन

लाइफ़साइकल के बारे में जानकारी रखने वाले कॉम्पोनेंट की मदद से लाइफ़साइकल मैनेज करने के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें.

कॉन्टेंट देखता है

• लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट (व्यू) की मदद से लाइफ़साइकल मैनेज करना