स्थिति और Jetpack Compose

ऐप्लिकेशन में मौजूद कोई भी वैल्यू, समय के साथ बदल सकती है. यह एक बहुत ही व्यापक परिभाषा है. इसमें Room डेटाबेस से लेकर किसी क्लास में मौजूद वैरिएबल तक, सब कुछ शामिल है.

सभी Android ऐप्लिकेशन, उपयोगकर्ता को स्थिति दिखाते हैं. Android ऐप्लिकेशन की स्थिति के कुछ उदाहरण:

• स्नैकबार, जो नेटवर्क कनेक्शन न होने पर दिखता है.
• ब्लॉग पोस्ट और उससे जुड़ी टिप्पणियां.
• बटन पर रिपल एनिमेशन, जो उपयोगकर्ता के क्लिक करने पर चलता है.
• वे स्टिकर जिन्हें उपयोगकर्ता इमेज के ऊपर बना सकता है.

Jetpack Compose की मदद से, यह साफ़ तौर पर बताया जा सकता है कि Android ऐप्लिकेशन में स्टेट को कहां और कैसे सेव किया जाता है और उसका इस्तेमाल कैसे किया जाता है. इस गाइड में, स्टेट और कॉम्पोज़ेबल के बीच के कनेक्शन के साथ-साथ उन एपीआई पर फ़ोकस किया गया है जो Jetpack Compose, स्टेट के साथ आसानी से काम करने के लिए उपलब्ध कराता है.

स्थिति और कंपोज़िशन

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

@Composable
private fun HelloContent() {
    Column(modifier = Modifier.padding(16.dp)) {
        Text(
            text = "Hello!",
            modifier = Modifier.padding(bottom = 8.dp),
            style = MaterialTheme.typography.bodyMedium
        )
        OutlinedTextField(
            value = "",
            onValueChange = { },
            label = { Text("Name") }
        )
    }
}
StateOverviewSnippets.kt

इसे चलाने और टेक्स्ट डालने की कोशिश करने पर, आपको कुछ नहीं दिखेगा. ऐसा इसलिए होता है, क्योंकि TextField अपने-आप अपडेट नहीं होता. यह value पैरामीटर बदलने पर अपडेट होता है. ऐसा इस वजह से होता है कि कंपोज़िशन और रिकंपोज़िशन, कंपोज़िशन में कैसे काम करते हैं.

शुरुआत में कंपोज़िशन और उसे फिर से बनाने के बारे में ज़्यादा जानने के लिए, लिखें की सुविधा के बारे में सोचना लेख पढ़ें.

कंपोज़ेबल में स्टेट

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

mutableStateOf एक ऑब्ज़र्वेबल MutableState<T> बनाता है, जो Compose रनटाइम के साथ इंटिग्रेट किया गया ऑब्ज़र्वेबल टाइप है.

interface MutableState<T> : State<T> {
    override var value: T
}

value में किए गए किसी भी बदलाव से, value को पढ़ने वाले सभी कंपोजेबल फ़ंक्शन फिर से कॉम्पोज़ किए जाते हैं.

किसी कॉम्पोज़ेबल में MutableState ऑब्जेक्ट का एलान करने के तीन तरीके हैं:

• val mutableState = remember { mutableStateOf(default) }
• var value by remember { mutableStateOf(default) }
• val (value, setValue) = remember { mutableStateOf(default) }

ये एलान एक जैसे हैं और इन्हें स्टेट के अलग-अलग इस्तेमाल के लिए सिंटैक्स शुगर के तौर पर उपलब्ध कराया जाता है. आपको वह विकल्प चुनना चाहिए जिससे आपके लिखे जा रहे कॉम्पोज़ेबल में, सबसे आसानी से पढ़ा जा सकने वाला कोड जनरेट हो.

by डेलिगेट सिंटैक्स के लिए, इन इंपोर्ट की ज़रूरत होती है:

import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue

सेव की गई वैल्यू का इस्तेमाल, अन्य कॉम्पोज़ेबल के लिए पैरामीटर के तौर पर किया जा सकता है. इसके अलावा, स्टेटमेंट में लॉजिक के तौर पर भी इसका इस्तेमाल किया जा सकता है, ताकि यह बदला जा सके कि कौनसे कॉम्पोज़ेबल दिखाए जाएं. उदाहरण के लिए, अगर नाम खाली होने पर आपको अभिवादन नहीं दिखाना है, तो if स्टेटमेंट में राज्य का इस्तेमाल करें:

@Composable
fun HelloContent() {
    Column(modifier = Modifier.padding(16.dp)) {
        var name by remember { mutableStateOf("") }
        if (name.isNotEmpty()) {
            Text(
                text = "Hello, $name!",
                modifier = Modifier.padding(bottom = 8.dp),
                style = MaterialTheme.typography.bodyMedium
            )
        }
        OutlinedTextField(
            value = name,
            onValueChange = { name = it },
            label = { Text("Name") }
        )
    }
}
StateOverviewSnippets.kt

remember की मदद से, कॉन्फ़िगरेशन में हुए बदलावों के दौरान उसकी स्थिति को बरकरार नहीं रखा जा सकता. इसके लिए, आपको rememberSaveable का इस्तेमाल करना होगा. rememberSaveable, Bundle में सेव की जा सकने वाली किसी भी वैल्यू को अपने-आप सेव कर देता है. अन्य वैल्यू के लिए, कस्टम सेवर ऑब्जेक्ट पास किया जा सकता है.

काम करने वाली अन्य स्थितियां

Compose में, स्टेटस को सेव करने के लिए MutableState<T> का इस्तेमाल करना ज़रूरी नहीं है. यह, ऑब्ज़र्व किए जा सकने वाले अन्य टाइप के साथ काम करता है. Compose में किसी दूसरे ऑब्ज़र्वेबल टाइप को पढ़ने से पहले, आपको उसे State<T> में बदलना होगा, ताकि स्टेटस में बदलाव होने पर, कॉम्पोज़ेबल अपने-आप फिर से कॉम्पोज़ हो सकें.

Compose, फ़ंक्शन के साथ शिप होता है, ताकि Android ऐप्लिकेशन में इस्तेमाल होने वाले सामान्य ऑब्ज़र्वेबल टाइप से State<T> बनाया जा सके. इन इंटिग्रेशन का इस्तेमाल करने से पहले, यहां बताए गए तरीके से सही आर्टफ़ैक्ट जोड़ें:

• Flow: collectAsStateWithLifecycle()

  collectAsStateWithLifecycle(), लाइफ़ साइकल के हिसाब से Flow से वैल्यू इकट्ठा करता है. इससे आपके ऐप्लिकेशन को ऐप्लिकेशन के संसाधनों को बचाने में मदद मिलती है. यह Compose State से उत्सर्जित की गई सबसे नई वैल्यू दिखाता है. Android ऐप्लिकेशन पर फ़्लो इकट्ठा करने के लिए, सुझाए गए तरीके के तौर पर इस एपीआई का इस्तेमाल करें.

  build.gradle फ़ाइल में यह डिपेंडेंसी ज़रूरी है. यह 2.6.0-beta01 या उससे नया वर्शन होना चाहिए:

dependencies {
      ...
      implementation("androidx.lifecycle:lifecycle-runtime-compose:2.8.7")
}

dependencies {
      ...
      implementation "androidx.lifecycle:lifecycle-runtime-compose:2.8.7"
}

• Flow: collectAsState()

  collectAsState, collectAsStateWithLifecycle से मिलता-जुलता है, क्योंकि यह Flow से भी वैल्यू इकट्ठा करता है और उन्हें कंपोज़ State में बदल देता है.

  सिर्फ़ Android के लिए इस्तेमाल किए जाने वाले collectAsStateWithLifecycle के बजाय, collectAsState का इस्तेमाल करें.

  collectAsState के लिए, अतिरिक्त डिपेंडेंसी की ज़रूरत नहीं है, क्योंकि यह compose-runtime में उपलब्ध है.

• LiveData: observeAsState()

  observeAsState() इस LiveData को मॉनिटर करना शुरू कर देता है और State के ज़रिए इसकी वैल्यू दिखाता है.

  build.gradle फ़ाइल में, यह डिपेंडेंसी ज़रूरी है:

dependencies {
      ...
      implementation("androidx.compose.runtime:runtime-livedata:1.7.8")
}

dependencies {
      ...
      implementation "androidx.compose.runtime:runtime-livedata:1.7.8"
}

• RxJava2: subscribeAsState()

  subscribeAsState() ऐसे एक्सटेंशन फ़ंक्शन हैं जो RxJava2 की रिऐक्टिव स्ट्रीम (उदाहरण के लिए, Single, Observable, Completable) को Compose State में बदल देते हैं.

  build.gradle फ़ाइल में, यह डिपेंडेंसी ज़रूरी है:

dependencies {
      ...
      implementation("androidx.compose.runtime:runtime-rxjava2:1.7.8")
}

dependencies {
      ...
      implementation "androidx.compose.runtime:runtime-rxjava2:1.7.8"
}

• RxJava3: subscribeAsState()

  subscribeAsState() ऐसे एक्सटेंशन फ़ंक्शन हैं जो RxJava3 की रिऐक्टिव स्ट्रीम (जैसे, Single, Observable, Completable) को Compose State में बदल देते हैं.

  build.gradle फ़ाइल में, यहां दी गई डिपेंडेंसी ज़रूरी है:

dependencies {
      ...
      implementation("androidx.compose.runtime:runtime-rxjava3:1.7.8")
}

dependencies {
      ...
      implementation "androidx.compose.runtime:runtime-rxjava3:1.7.8"
}

स्टेटफ़ुल बनाम स्टेटलेस

किसी ऑब्जेक्ट को सेव करने के लिए remember का इस्तेमाल करने वाला कॉम्पोज़ेबल, इंटरनल स्टेटस बनाता है. इससे कॉम्पोज़ेबल स्टेटफ़ुल हो जाता है. HelloContent, स्टेटफ़ुल कॉम्पोज़ेबल का एक उदाहरण है, क्योंकि यह अपने name स्टेटस को अंदरूनी तौर पर सेव और बदलता है. यह सुविधा उन स्थितियों में काम आ सकती है जहां कॉलर को स्थिति को कंट्रोल करने की ज़रूरत नहीं होती और वह खुद स्थिति को मैनेज किए बिना इसका इस्तेमाल कर सकता है. हालांकि, इंटरनल स्टेट वाले कॉम्पोज़ेबल को फिर से इस्तेमाल करना मुश्किल होता है और उनकी जांच करना भी मुश्किल होता है.

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

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

स्टेट होइस्टिंग

Compose में स्टेटस को होस्ट करने का मतलब, स्टेटस को कॉम्पोज़ेबल के कॉलर पर ले जाना है. इससे कॉम्पोज़ेबल को स्टेटलेस बनाया जा सकता है. Jetpack Compose में स्टेटस को होस्ट करने का सामान्य पैटर्न, स्टेटस वैरिएबल को दो पैरामीटर से बदलना है:

• value: T: दिखाई जाने वाली मौजूदा वैल्यू
• onValueChange: (T) -> Unit: वैल्यू बदलने का अनुरोध करने वाला इवेंट, जहां T सुझाई गई नई वैल्यू है

हालांकि, आप onValueChange तक सीमित नहीं हैं. अगर कंपोज़ेबल के लिए ज़्यादा सटीक इवेंट सही हैं, तो आपको उन्हें लैम्ब्डा का इस्तेमाल करके तय करना चाहिए.

इस तरह होस्ट की गई स्थिति की कुछ अहम प्रॉपर्टी हैं:

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

उदाहरण के मामले में, HelloContent से name और onValueChange को निकाला जाता है और उन्हें ट्री में ऊपर, HelloScreen कॉम्पोज़ेबल में ले जाया जाता है, जो HelloContent को कॉल करता है.

@Composable
fun HelloScreen() {
    var name by rememberSaveable { mutableStateOf("") }

    HelloContent(name = name, onNameChange = { name = it })
}

@Composable
fun HelloContent(name: String, onNameChange: (String) -> Unit) {
    Column(modifier = Modifier.padding(16.dp)) {
        Text(
            text = "Hello, $name",
            modifier = Modifier.padding(bottom = 8.dp),
            style = MaterialTheme.typography.bodyMedium
        )
        OutlinedTextField(value = name, onValueChange = onNameChange, label = { Text("Name") })
    }
}
StateOverviewSnippets.kt

HelloContent से स्टेट को हॉइस्ट करने पर, कॉम्पोज़ेबल के बारे में आसानी से जानकारी मिलती है. साथ ही, इसे अलग-अलग स्थितियों में फिर से इस्तेमाल किया जा सकता है और टेस्ट किया जा सकता है. HelloContent को, उसकी स्थिति को सेव करने के तरीके से अलग किया गया है. अलग करने का मतलब है कि अगर HelloScreen में बदलाव किया जाता है या उसे बदल दिया जाता है, तो आपको HelloContent को लागू करने के तरीके में बदलाव करने की ज़रूरत नहीं है.

जिस पैटर्न में स्टेटस कम होता है और इवेंट बढ़ते हैं उसे एकतरफ़ा डेटा फ़्लो कहा जाता है. इस मामले में, स्टेटस HelloScreen से HelloContent पर चला जाता है और इवेंट HelloContent से HelloScreen पर चले जाते हैं. एकतरफ़ा डेटा फ़्लो का इस्तेमाल करके, यूज़र इंटरफ़ेस (यूआई) में दिखने वाले कंपोज़ेबल को आपके ऐप्लिकेशन के उन हिस्सों से अलग किया जा सकता है जो स्टोर में मौजूद होते हैं और उनकी स्थिति बदलते हैं.

ज़्यादा जानने के लिए, स्टेटस को कहां होस्ट करना है पेज देखें.

Compose में स्टेटस को पहले जैसा किया जा रहा है

rememberSaveable एपीआई, remember की तरह ही काम करता है. ऐसा इसलिए होता है, क्योंकि यह फिर से कॉम्पोज़ करने के दौरान स्थिति को बनाए रखता है. साथ ही, सेव किए गए इंस्टेंस की स्थिति के तरीके का इस्तेमाल करके, गतिविधि या प्रोसेस को फिर से बनाने के दौरान भी स्थिति को बनाए रखता है. उदाहरण के लिए, ऐसा तब होता है, जब स्क्रीन को घुमाया जाता है.

स्टेटस सेव करने के तरीके

Bundle में जोड़े गए सभी डेटा टाइप अपने-आप सेव हो जाते हैं. अगर आपको Bundle में जोड़ी जा सकने वाली कोई जानकारी सेव करनी है, तो इसके लिए कई विकल्प हैं.

Parcelize

इसका सबसे आसान तरीका यह है कि ऑब्जेक्ट में @Parcelize एनोटेशन जोड़ा जाए. ऑब्जेक्ट को पार्सल किया जा सकता है और उसे बंडल किया जा सकता है. उदाहरण के लिए, यह कोड, पार्सल किए जा सकने वाले City डेटा टाइप बनाता है और उसे राज्य में सेव करता है.

@Parcelize
data class City(val name: String, val country: String) : Parcelable

@Composable
fun CityScreen() {
    var selectedCity = rememberSaveable {
        mutableStateOf(City("Madrid", "Spain"))
    }
}
StateOverviewSnippets.kt

MapSaver

अगर किसी वजह से @Parcelize सही नहीं है, तो किसी ऑब्जेक्ट को वैल्यू के ऐसे सेट में बदलने के लिए, mapSaver का इस्तेमाल करके अपना नियम तय किया जा सकता है जिसे सिस्टम Bundle में सेव कर सकता है.

data class City(val name: String, val country: String)

val CitySaver = run {
    val nameKey = "Name"
    val countryKey = "Country"
    mapSaver(
        save = { mapOf(nameKey to it.name, countryKey to it.country) },
        restore = { City(it[nameKey] as String, it[countryKey] as String) }
    )
}

@Composable
fun CityScreen() {
    var selectedCity = rememberSaveable(stateSaver = CitySaver) {
        mutableStateOf(City("Madrid", "Spain"))
    }
}
StateOverviewSnippets.kt

ListSaver

मैप के लिए कुंजियों को तय करने की ज़रूरत न पड़े, इसके लिए listSaver का इस्तेमाल किया जा सकता है. साथ ही, इसके इंडेक्स को कुंजियों के तौर पर इस्तेमाल किया जा सकता है:

data class City(val name: String, val country: String)

val CitySaver = listSaver<City, Any>(
    save = { listOf(it.name, it.country) },
    restore = { City(it[0] as String, it[1] as String) }
)

@Composable
fun CityScreen() {
    var selectedCity = rememberSaveable(stateSaver = CitySaver) {
        mutableStateOf(City("Madrid", "Spain"))
    }
}
StateOverviewSnippets.kt

Compose में राज्य के मालिक

सिंपल स्टेट लिफ़्टिंग को कंपोज़ेबल फ़ंक्शन में मैनेज किया जा सकता है. हालांकि, अगर ट्रैक करने के लिए स्टेटस की संख्या बढ़ जाती है या कॉम्पोज़ेबल फ़ंक्शन में काम करने के लिए लॉजिक की ज़रूरत पड़ती है, तो लॉजिक और स्टेटस की ज़िम्मेदारियों को दूसरी क्लास को सौंपना एक अच्छा तरीका है: स्टेटस होल्डर.

ज़्यादा जानकारी के लिए, कंपोज़ की सुविधा में स्टेट होस्टिंग दस्तावेज़ देखें. इसके अलावा, आम तौर पर, राज्य के मालिक और यूआई स्टेट पेज पर जाकर, आर्किटेक्चर गाइड में जानकारी दी गई है.

कुंजियां बदलने पर याद रखने के लिए फिर से ट्रिगर करें

remember एपीआई का इस्तेमाल अक्सर MutableState के साथ किया जाता है:

var name by remember { mutableStateOf("") }
StateOverviewSnippets.kt

यहां remember फ़ंक्शन का इस्तेमाल करने से, MutableState वैल्यू फिर से कॉम्पोनेंट में बंटने के बाद भी बनी रहती है.

आम तौर पर, remember में calculation Lambda पैरामीटर इस्तेमाल किया जाता है. जब remember पहली बार चलाया जाता है, तो यह calculation लैम्ब्डा फ़ंक्शन को कॉल करता है और उसका नतीजा सेव करता है. फिर से कॉम्पोज़ करने के दौरान, remember वह वैल्यू दिखाता है जिसे पिछली बार सेव किया गया था.

स्टेटस को कैश मेमोरी में सेव करने के अलावा, remember का इस्तेमाल करके कॉम्पोज़िशन में किसी ऐसे ऑब्जेक्ट या ऑपरेशन का नतीजा भी सेव किया जा सकता है जिसे शुरू करने या कैलकुलेट करने में ज़्यादा समय लगता है. ऐसा हो सकता है कि आप हर बार बदलाव में इस कैलकुलेशन को न दोहराएं. उदाहरण के लिए, यह ShaderBrush ऑब्जेक्ट बनाना, जो महंगा ऑपरेशन है:

val brush = remember {
    ShaderBrush(
        BitmapShader(
            ImageBitmap.imageResource(res, avatarRes).asAndroidBitmap(),
            Shader.TileMode.REPEAT,
            Shader.TileMode.REPEAT
        )
    )
}
StateOverviewSnippets.kt

remember में वैल्यू तब तक सेव रहती है, जब तक वह कंपोज़िशन में नहीं रहती. हालांकि, कैश मेमोरी में सेव की गई वैल्यू को अमान्य करने का एक तरीका है. remember एपीआई में key या keys पैरामीटर भी शामिल होता है. अगर इनमें से कोई भी कुंजी बदलती है, तो अगली बार फ़ंक्शन फिर से बनने पर, remember कैश मेमोरी को अमान्य कर देता है और कैलकुलेशन के लिए lambda ब्लॉक को फिर से चलाता है. इस तरीके से, कॉम्पोज़िशन में किसी ऑब्जेक्ट के लाइफ़टाइम को कंट्रोल किया जा सकता है. कैलकुलेशन तब तक मान्य रहती है, जब तक इनपुट में बदलाव नहीं हो जाता. वह वैल्यू तब तक मान्य रहती है, जब तक याद रखी गई वैल्यू कंपोज़िशन से बाहर न निकल जाए.

नीचे दिए गए उदाहरणों में बताया गया है कि यह तरीका कैसे काम करता है.

इस स्निपेट में, एक ShaderBrush बनाया गया है और इसका इस्तेमाल Box कॉम्पोज़ेबल के बैकग्राउंड के पेंट के तौर पर किया गया है. remember, ShaderBrush इंस्टेंस को सेव करता है, क्योंकि इसे फिर से बनाने में ज़्यादा खर्च होता है. remember, avatarRes को key1 पैरामीटर के तौर पर लेता है. यह पैरामीटर, चुनी गई बैकग्राउंड इमेज होती है. अगर avatarRes बदलता है, तो ब्रश नई इमेज के साथ फिर से कॉम्पोज़ हो जाता है और Box पर फिर से लागू हो जाता है. ऐसा तब हो सकता है, जब उपयोगकर्ता पिकर से बैकग्राउंड के लिए कोई दूसरी इमेज चुनता है.

@Composable
private fun BackgroundBanner(
    @DrawableRes avatarRes: Int,
    modifier: Modifier = Modifier,
    res: Resources = LocalContext.current.resources
) {
    val brush = remember(key1 = avatarRes) {
        ShaderBrush(
            BitmapShader(
                ImageBitmap.imageResource(res, avatarRes).asAndroidBitmap(),
                Shader.TileMode.REPEAT,
                Shader.TileMode.REPEAT
            )
        )
    }

    Box(
        modifier = modifier.background(brush)
    ) {
        /* ... */
    }
}
StateOverviewSnippets.kt

अगले स्निपेट में, स्टेट को सामान्य स्टेट होल्डर क्लास पर होस्ट किया गया है MyAppState. यह remember का इस्तेमाल करके, कक्षा के किसी इंस्टेंस को शुरू करने के लिए rememberMyAppState फ़ंक्शन को एक्सपोज़ करता है. कंपोज़िशन में इस तरह के फ़ंक्शन को दिखाकर, एक ऐसा इंस्टेंस बनाया जाता है जो बनाए रखने में मदद करता है. rememberMyAppState फ़ंक्शन को windowSizeClass मिलता है, जो remember के लिए key पैरामीटर के तौर पर काम करता है. अगर यह पैरामीटर बदलता है, तो ऐप्लिकेशन को नई वैल्यू के साथ, प्लैन स्टेट होल्डर क्लास को फिर से बनाना होगा. उदाहरण के लिए, ऐसा तब हो सकता है, जब उपयोगकर्ता डिवाइस को घुमाए.

@Composable
private fun rememberMyAppState(
    windowSizeClass: WindowSizeClass
): MyAppState {
    return remember(windowSizeClass) {
        MyAppState(windowSizeClass)
    }
}

@Stable
class MyAppState(
    private val windowSizeClass: WindowSizeClass
) { /* ... */ }
StateOverviewSnippets.kt

Compose, क्लास के equals लागू करने का इस्तेमाल करके यह तय करता है कि किसी कुंजी में बदलाव हुआ है या नहीं. साथ ही, सेव की गई वैल्यू को अमान्य कर देता है.

आइटम को फिर से बनाने के अलावा, दूसरी कुंजियों को स्टोर करने की स्थिति

rememberSaveable एपीआई, remember के चारों ओर मौजूद एक रैपर है. यह Bundle में डेटा सेव कर सकता है. इस एपीआई की मदद से, स्टेटस को फिर से कॉम्पोज़ करने के साथ-साथ, ऐक्टिविटी को फिर से शुरू करने और सिस्टम से शुरू की गई प्रोसेस के बंद होने के बाद भी बनाए रखा जा सकता है. rememberSaveable को उसी मकसद के लिए input पैरामीटर मिलते हैं जिसके लिए remember को keys मिलते हैं. किसी भी इनपुट में बदलाव होने पर, कैश मेमोरी अमान्य हो जाती है. अगली बार जब फ़ंक्शन को फिर से बनाया जाता है, तो rememberSaveable कैलकुलेशन वाले लैम्डा ब्लॉक को फिर से लागू करता है.

नीचे दिए गए उदाहरण में, rememberSaveable userTypedQuery को तब तक सेव करता है, जब तक कि typedQuery में बदलाव नहीं होता:

var userTypedQuery by rememberSaveable(typedQuery, stateSaver = TextFieldValue.Saver) {
    mutableStateOf(
        TextFieldValue(text = typedQuery, selection = TextRange(typedQuery.length))
    )
}
StateOverviewSnippets.kt

ज़्यादा जानें

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

सैंपल

कोडलैब

• Jetpack Compose में स्टेट का इस्तेमाल करना

वीडियो

• कॉम्पोज़ करने के लिए सही मनोदशा

ब्लॉग

• Compose में TextField के लिए, स्टेट को असरदार तरीके से मैनेज करना