ऐप्लिकेशन में स्थिति ऐसी कोई भी वैल्यू होती है जो समय के साथ बदल सकती है. यह एक बहुत ही व्यापक इसमें रूम डेटाबेस से लेकर वैरिएबल तक सब कुछ शामिल होता है क्लास.
सभी 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") } ) } }
यदि आप इसे चलाते हैं और पाठ दर्ज करने का प्रयास करते हैं, तो आप देखेंगे कि कुछ नहीं होता है. यह
क्योंकि 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") } ) } }
जहां 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"
}
-
collectAsState
,collectAsStateWithLifecycle
से मिलता-जुलता है, क्योंकि यह भीFlow
से वैल्यू इकट्ठा करता है और उसे कंपोज़State
में बदल देता है.प्लैटफ़ॉर्म-एग्नोस्टिक कोड के लिए इसके बजाय,
collectAsState
का इस्तेमाल करेंcollectAsStateWithLifecycle
, जो सिर्फ़ Android पर उपलब्ध है.collectAsState
के लिए अतिरिक्त डिपेंडेंसी की ज़रूरत नहीं है, क्योंकि यहcompose-runtime
में उपलब्ध है. -
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"
}
-
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"
}
-
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") }) } }
राज्य को HelloContent
से बाहर ले जाने से, यह समझना आसान हो जाता है कि
बनाने के लिए, उसका अलग-अलग स्थितियों में फिर से इस्तेमाल करें और टेस्ट करें. HelloContent
है
उसकी स्थिति को सेव करने के तरीके से अलग किया जाता है. डीकपलिंग का मतलब है कि यदि आप
HelloScreen
को बदलें, आपको HelloContent
का तरीका बदलने की ज़रूरत नहीं है
लागू किया गया.
![](https://developer.android.com/static/develop/ui/compose/images/udf-hello-screen.png?authuser=3&hl=hi)
जिस पैटर्न में स्थिति घटती है और इवेंट ऊपर जाते हैं उसे
एकतरफ़ा डेटा फ़्लो. इस मामले में, राज्य HelloScreen
से घट जाएगा
से HelloContent
तक और इवेंट HelloContent
से HelloScreen
तक ऊपर जाते हैं. इन्होंने बदलाव किया है
एकतरफ़ा डेटा फ़्लो के बाद, डिसप्ले पर दिखने वाले कंपोज़ेबल को अलग किया जा सकता है
आपके ऐप्लिकेशन के उन हिस्सों के यूज़र इंटरफ़ेस (यूआई) में उन हिस्सों की जानकारी जिन्हें स्टोर किया जा सकता है और उनकी स्थिति में बदलाव किया जा सकता है.
ज़्यादा जानकारी के लिए, कटाई कहां से लहराएं पेज पर जाएं.
Compose में स्टेटस को पहले जैसा किया जा रहा है
rememberSaveable
एपीआई, remember
की तरह ही काम करता है, क्योंकि यह
फिर से बनाने पर और गतिविधि या प्रक्रिया में भी स्थिति बरकरार रहती है
मनोरंजन के लिए, सेव किए गए इंस्टेंस की स्थिति का इस्तेमाल किया गया है. उदाहरण के लिए, ऐसा होता है,
जब स्क्रीन घुमाई जाती है.
डेटा सेव करने के तरीके
Bundle
में जोड़े गए सभी डेटा टाइप अपने-आप सेव हो जाते हैं. अगर आपको
कुछ ऐसा सेव करना चाहते हैं जिसे Bundle
में नहीं जोड़ा जा सकता. ऐसा करने के लिए कई
के विकल्प.
पार्सलाइज़
सबसे आसान समाधान यह है कि
@Parcelize
एनोटेशन को ऑब्जेक्ट के साथ जोड़ सकते हैं. ऑब्जेक्ट को पार्स किया जा सकता है और उसे बंडल किया जा सकता है. इसके लिए
उदाहरण के लिए, यह कोड पार्स किया जा सकने वाला City
डेटा टाइप बनाता है और इसे
राज्य.
@Parcelize data class City(val name: String, val country: String) : Parcelable @Composable fun CityScreen() { var selectedCity = rememberSaveable { mutableStateOf(City("Madrid", "Spain")) } }
मैप सेवर
अगर किसी कारण से @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")) } }
सूची सेव करने वाला बटन
मैप के लिए कुंजियां तय करने की ज़रूरत से बचने के लिए, 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")) } }
Compose में राज्य के मालिक
सिंपल स्टेट लिफ़्टिंग को कंपोज़ेबल फ़ंक्शन में मैनेज किया जा सकता है. हालांकि, अगर राज्य में होने वाली बढ़ोतरी पर नज़र रखना है या किसी कंपोज़ेबल फ़ंक्शन के ज़रिए परफ़ॉर्म करने की ज़रूरत नहीं पड़ती है. इसलिए, अन्य क्लास के लिए तर्क और राज्य की ज़िम्मेदारियां: राज्य के मालिक.
Compose में स्टेट होस्टिंग दस्तावेज़ देखें या आम तौर पर, ज़्यादा जानकारी के लिए, आर्किटेक्चर गाइड में राज्य के मालिक और यूज़र इंटरफ़ेस (यूआई) की स्थिति वाला पेज देखें.
कुंजियां बदलने पर याद रखने के लिए फिर से ट्रिगर करें
remember
एपीआई को MutableState
के साथ अक्सर इस्तेमाल किया जाता है:
var name by remember { mutableStateOf("") }
यहां, 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 ) ) }
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) ) { /* ... */ } }
अगले स्निपेट में, राज्य को प्लेन स्टेट होल्डर क्लास में ले जाया जाता है
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 ) { /* ... */ }
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)) ) }
ज़्यादा जानें
राज्य और Jetpack Compose के बारे में ज़्यादा जानने के लिए, ये देखें अतिरिक्त संसाधन शामिल करें.
सैंपल
कोड लैब
वीडियो
ब्लॉग
आपके लिए सुझाव
- ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
- अपना Compose यूज़र इंटरफ़ेस (यूआई) बनाना
- Compose में यूज़र इंटरफ़ेस (यूआई) की स्थिति सेव करना
- Compose में साइड-इफ़ेक्ट