लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के साथ, Kotlin कोरूटीन इस्तेमाल करें

Kotlin कोरूटीन एक ऐसा एपीआई उपलब्ध कराता है जिसकी मदद से एसिंक्रोनस कोड लिखा जा सकता है. Kotlin कोरूटीन की मदद से, CoroutineScope को तय किया जा सकता है. इससे आपको यह मैनेज करने में मदद मिलती है कि आपके कोरूटीन कब चलने चाहिए. हर एसिंक्रोनस ऑपरेशन, एक खास स्कोप में चलता है.

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

डिपेंडेंसी जोड़ें

इस विषय में बताए गए पहले से मौजूद कोरूटीन स्कोप, लाइफ़साइकल एपीआई में शामिल होते हैं. इन स्कोप का इस्तेमाल करते समय, ज़रूरी डिपेंडेंसी जोड़ना न भूलें.

  • Compose में ViewModel की सुविधाओं के लिए, implementation("androidx.lifecycle:lifecycle-viewmodel-compose:$lifecycle_version") का इस्तेमाल करें.
  • Compose में लाइफ़साइकल यूटिलिटी के लिए, implementation("androidx.lifecycle:lifecycle-runtime-compose:$lifecycle_version") का इस्तेमाल करें.

लाइफ़साइकल के हिसाब से काम करने वाले कोरूटीन स्कोप

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

ViewModelScope

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

ViewModel की viewModelScope प्रॉपर्टी का इस्तेमाल करके, ViewModel के CoroutineScope को ऐक्सेस किया जा सकता है. इसका उदाहरण यहां दिया गया है:

class MyViewModel: ViewModel() {
    init {
        viewModelScope.launch {
            // Coroutine that will be canceled when the ViewModel is cleared.
        }
    }
}

ज़्यादा ऐडवांस इस्तेमाल के उदाहरणों के लिए, ViewModel के कंस्ट्रक्टर में सीधे तौर पर कस्टम CoroutineScope पास किया जा सकता है. इससे डिफ़ॉल्ट viewModelScope को बदला जा सकता है. इस तरीके से, आपको ज़्यादा कंट्रोल और सुविधा मिलती है. खास तौर पर:

  • टेस्टिंग: इसकी मदद से, TestScope को इंजेक्ट किया जा सकता है. इससे समय को कंट्रोल करना और यूनिट टेस्ट में कोरूटीन के व्यवहार की पुष्टि करना आसान हो जाता है.

  • कस्टम कॉन्फ़िगरेशन: ViewModel के काम शुरू करने से पहले, स्कोप को किसी खास CoroutineDispatcher (जैसे, ज़्यादा कंप्यूटेशन के लिए Dispatchers.Default) या कस्टम CoroutineExceptionHandler के साथ कॉन्फ़िगर किया जा सकता है.

कंपोज़िशन से जुड़े स्कोप

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

Compose, LaunchedEffect एपीआई उपलब्ध कराता है, ताकि कंपोज़िशन के स्कोप को डिक्लेरेटिव तरीके से मैनेज किया जा सके.

LaunchedEffect, CoroutineScope बनाता है, जिससे आपको suspend फ़ंक्शन चलाने की सुविधा मिलती है. स्कोप, कंपोज़ेबल के कंपोज़िशन लाइफ़साइकल से जुड़ा होता है, न कि होस्ट ऐक्टिविटी के लाइफ़साइकल से.

  • Enter: जब कंपोज़ेबल, कंपोज़िशन में शामिल होता है, तब कोरूटीन शुरू होता है.
  • एग्ज़िट: जब कंपोज़ेबल, कंपोज़िशन से बाहर निकलता है, तो कोरूटीन रद्द हो जाता है.
  • फिर से लॉन्च करना: अगर LaunchedEffect को पास की गई कोई भी कुंजी बदलती है, तो मौजूदा कोरूटीन रद्द कर दिया जाता है और एक नया कोरूटीन लॉन्च किया जाता है.

नीचे दिए गए उदाहरण में, LaunchedEffect का इस्तेमाल करके पल्सिंग ऐनिमेशन बनाने का तरीका बताया गया है. कोरूटीन, कंपोज़िशन में कंपोज़ेबल की मौजूदगी से जुड़ा होता है. साथ ही, यह कॉन्फ़िगरेशन में होने वाले बदलावों पर प्रतिक्रिया देता है:

// Allow the pulse rate to be configured, so it can be sped up if the user is running
// out of time
var pulseRateMs by remember { mutableLongStateOf(3000L) }
val alpha = remember { Animatable(1f) }
LaunchedEffect(pulseRateMs) { // Restart the effect when the pulse rate changes
    while (isActive) {
        delay(pulseRateMs) // Pulse the alpha every pulseRateMs to alert the user
        alpha.animateTo(0f)
        alpha.animateTo(1f)
    }
}

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

लाइफ़साइकल के हिसाब से फ़्लो कलेक्शन

Jetpack Compose में फ़्लो को सुरक्षित तरीके से इकट्ठा करने के लिए, collectAsStateWithLifecycle एपीआई का इस्तेमाल करें. यह फ़ंक्शन, Flow को Compose State ऑब्जेक्ट में बदलता है. साथ ही, आपके लिए लाइफ़साइकल की सदस्यता को अपने-आप मैनेज करता है. डिफ़ॉल्ट रूप से, डेटा इकट्ठा करने की प्रोसेस तब शुरू होती है, जब लाइफ़साइकल STARTED हो और तब बंद होती है, जब लाइफ़साइकल STOPPED हो. इस डिफ़ॉल्ट व्यवहार को बदलने के लिए, अपनी पसंद के लाइफ़साइकल तरीके के साथ minActiveState पैरामीटर पास करें, जैसे कि Lifecycle.State.RESUMED.

यहां दिए गए उदाहरण में, कंपोज़ेबल में ViewModel के StateFlow को इकट्ठा करने का तरीका बताया गया है:

@Composable
private fun ConversationScreen(
    conversationViewModel: ConversationViewModel = viewModel()
) {

    val messages by conversationViewModel.messages.collectAsStateWithLifecycle()

    ConversationScreen(
        messages = messages,
        onSendMessage = { message: Message -> conversationViewModel.sendMessage(message) }
    )
}

@Composable
private fun ConversationScreen(
    messages: List<Message>,
    onSendMessage: (Message) -> Unit
) {

    MessagesList(messages, onSendMessage)
    /* ... */
}

एक साथ कई फ़्लो का कलेक्शन

Compose में, एक से ज़्यादा स्टेट वैरिएबल का एलान करके, एक साथ कई फ़्लो इकट्ठा किए जा सकते हैं. collectAsStateWithLifecycle अपने मौजूदा स्कोप को खुद मैनेज करता है. इसलिए, पैरलल कलेक्शन अपने-आप मैनेज होता है:

@Composable
fun DashboardScreen(viewModel: DashboardViewModel = viewModel()) {
    // Both flows are collected safely in parallel and will emit updates when either changes, the composables will recompose
    val userData by viewModel.userFlow.collectAsStateWithLifecycle()
    val feedData by viewModel.feedFlow.collectAsStateWithLifecycle()

    // ...
}

फ़्लो का इस्तेमाल करके, एसिंक्रोनस तरीके से वैल्यू कैलकुलेट करना

जब आपको एसिंक्रोनस तरीके से वैल्यू का हिसाब लगाना हो, तो stateIn ऑपरेटर के साथ StateFlow का इस्तेमाल करें.

यहां दिए गए स्निपेट में, स्टैंडर्ड Flow का इस्तेमाल किया गया है, जिसे StateFlow में बदला गया है. WhileSubscribed(5000) पैरामीटर, कॉन्फ़िगरेशन में हुए बदलावों को मैनेज करने के लिए, यूज़र इंटरफ़ेस (यूआई) के गायब होने के बाद भी सदस्यता को पांच सेकंड तक चालू रखता है.

val uiState: StateFlow<Result> = flow {
    emit(repository.fetchData())
}
.stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5_000),
    initialValue = Result.Loading
)

इकट्ठा की गई वैल्यू को Compose State में बदलने के लिए, collectAsStateWithLifecycle का इस्तेमाल करें. इससे डेटा में बदलाव होने पर, आपका यूज़र इंटरफ़ेस (यूआई) अपने-आप अपडेट हो सकता है.

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

अन्य संसाधन

कॉन्टेंट देखना

सैंपल