लाइफ़साइकल की जानकारी वाले कॉम्पोनेंट के साथ, 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 की CoroutineScope को, ViewModel की viewModelScope प्रॉपर्टी के ज़रिए ऐक्सेस किया जा सकता है. जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

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

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

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

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

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

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

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

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

  • एंटर: कंपोज़ेबल के कंपोज़िशन में शामिल होने पर, कोरूटीन शुरू होता है.
  • एक्ज़िट: कंपोज़ेबल के कंपोज़िशन से बाहर निकलने पर, कोरूटीन रद्द हो जाता है.
  • रीलांच: अगर 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)
    }
}
SideEffectsSnippets.kt

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)
    /* ... */
}
StateHoistingSnippets.kt

एक साथ कई फ़्लो इकट्ठा करना

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 लेख पढ़ें.

अन्य संसाधन

Views कॉन्टेंट

सैंपल