स्थिति और Jetpack Compose

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

सभी 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 पैरामीटर में किए गए बदलाव. ऐसा इसलिए होता है, क्योंकि कंपोज़िशन और रिकंपोज़िशन, लिखें.

शुरुआती कंपोज़िशन और बनावट के बारे में ज़्यादा जानने के लिए देखें Compose में थिरकना.

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

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

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

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 में सेव किया गया. अन्य वैल्यू के लिए, कस्टम सेवर ऑब्जेक्ट जनरेट किया जा सकता है.

अन्य ऐसे स्टेटस जिन्हें इस्तेमाल किया जा सकता है

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

सामान्य मॉनिटर किए जा सकने वाले फ़ंक्शन से State<T> बनाने के लिए, शिप कंपोज़ करें किस तरह के हैं. इंटिग्रेशन का इस्तेमाल करने से पहले, जैसा कि नीचे बताया गया है, सही आर्टफ़ैक्ट

  • Flow: collectAsStateWithLifecycle()

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

    build.gradle फ़ाइल में नीचे दी गई डिपेंडेंसी ज़रूरी है (यह कोड ऐसा होना चाहिए 2.6.0-beta01 या इसके बाद का वर्शन होना चाहिए):

Kotlin

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

ग्रूवी

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

  • Flow: collectAsState()

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

    प्लैटफ़ॉर्म-एग्नोस्टिक कोड के लिए इसके बजाय, collectAsState का इस्तेमाल करें collectAsStateWithLifecycle, जो सिर्फ़ Android पर उपलब्ध है.

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

  • LiveData: observeAsState()

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

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

Kotlin

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

ग्रूवी

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

  • RxJava2: subscribeAsState()

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

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

Kotlin

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

ग्रूवी

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

  • RxJava3: subscribeAsState()

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

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

Kotlin

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

ग्रूवी

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

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

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

स्टेटलेस कंपोज़ेबल ऐसे कंपोज़ेबल को कहते हैं जिसमें कोई स्टेट नहीं हो. एक आसान स्टेटलेस हासिल करने का तरीका, state लिफ़्टिंग.

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

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

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

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

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

इस तरह से फहराने वाले राज्य में कुछ महत्वपूर्ण गुण होते हैं:

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

उदाहरण वाले मामले में, name और onValueChange को एक्सट्रैक्ट किया जा सकता है HelloContent और उन्हें ट्री के ऊपर ऐसे 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 एनोटेशन को ऑब्जेक्ट के साथ जोड़ सकते हैं. ऑब्जेक्ट को पार्स किया जा सकता है और उसे बंडल किया जा सकता है. इसके लिए उदाहरण के लिए, यह कोड पार्स किया जा सकने वाला City डेटा टाइप बनाता है और इसे state.

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

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

मैप सेवर

अगर किसी कारण से @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 का भी इस्तेमाल किया जा सकता है और इसके इंडेक्स का इस्तेमाल कुंजियों के तौर पर करें:

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 में राज्य के मालिक

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

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 API, एक key या keys पैरामीटर. अगर इनमें से किसी भी बटन में बदलाव होता है, तो अगली बार फ़ंक्शन फिर से कंपोज़ करता है, remember कैश मेमोरी को अमान्य कर देता है और कैलकुलेशन की प्रोसेस लागू करता है लैम्डा ब्लॉक फिर से खोलें. यह तरीका आपको किसी प्रॉडक्ट के लाइफ़टाइम में कंपोज़िशन में एक ऑब्जेक्ट है. इनपुट तब तक मान्य रहता है, जब तक कि इनपुट नहीं जोड़े जाते सेव की गई वैल्यू जब तक कंपोज़िशन से बाहर न हो जाए, तब तक बदलाव करना ज़रूरी नहीं है.

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

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

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

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

यहां दिए गए उदाहरण में rememberSaveable, userTypedQuery को तब तक सेव करेगा, जब तक कि typedQuery परिवर्तन:

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

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

राज्य और Jetpack Compose के बारे में ज़्यादा जानने के लिए, ये देखें अतिरिक्त संसाधन शामिल करें.

सैंपल

कोड लैब

वीडियो

ब्लॉग

{% endverba नया %} {% verbatim %}