कंपोज़ में स्थिरता

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

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

• स्टेबल पैरामीटर: अगर किसी कंपोज़ेबल में ऐसे पैरामीटर हैं जो स्थिर हैं बदल गया है, तो लिखें बटन को स्किप कर देता है.
• अस्टेबल पैरामीटर: अगर किसी कंपोज़ेबल के पैरामीटर में उतार-चढ़ाव नहीं हो रहा है, तो ‘लिखें’ जब कॉम्पोनेंट को पैरंट की ज़रूरत होती है, तब यह हमेशा उसे फिर से कंपोज़ करता है.

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

इस दस्तावेज़ में बताया गया है कि बेहतर बनाने के लिए, ऐप्लिकेशन की स्थिरता कैसे बढ़ाई जा सकती है उपयोगकर्ता अनुभव को बेहतर बनाने के लिए किया जा सकता है.

नहीं बदली जा सकने वाली चीज़ें

नीचे दिए गए स्निपेट, स्थिरता और स्थिरता के सामान्य सिद्धांतों के बारे में बताते हैं शॉर्ट वीडियो में बदलाव करना.

Contact क्लास, ऐसी डेटा क्लास है जिसमें बदलाव नहीं किया जा सकता. ऐसा इसलिए है, क्योंकि पैरामीटर, val कीवर्ड की मदद से तय किए गए प्रिमिटिव हैं. बनाने के बाद Contact के इंस्टेंस के लिए, आप ऑब्जेक्ट की प्रॉपर्टी की वैल्यू नहीं बदल सकते. अगर आपने ऐसा करने की कोशिश की, तो एक नया ऑब्जेक्ट बनेगा.

data class Contact(val name: String, val number: String)

ContactRow कंपोज़ेबल में Contact टाइप का पैरामीटर है.

@Composable
fun ContactRow(contact: Contact, modifier: Modifier = Modifier) {
   var selected by remember { mutableStateOf(false) }

   Row(modifier) {
      ContactDetails(contact)
      ToggleButton(selected, onToggled = { selected = !selected })
   }
}

देखें कि जब उपयोगकर्ता, टॉगल बटन पर क्लिक करता है और selected के स्टेटस में बदलाव:

1. Compose यह आकलन करता है कि इसे ContactRow में कोड को फिर से कंपोज़ करना चाहिए या नहीं.
2. ऐसा देखा गया है कि ContactDetails के लिए तर्क सिर्फ़ Contact टाइप का है.
3. Contact में एक ऐसी डेटा क्लास है जिसमें बदलाव नहीं किया जा सकता. इसलिए, Compose को पता है कि इनमें से कोई भी ContactDetails के लिए तर्क बदल गए हैं.
4. इस वजह से, कंपोज़ की सुविधा ContactDetails को स्किप कर देती है और उसे फिर से कंपोज़ नहीं करती.
5. वहीं दूसरी ओर, ToggleButton के आर्ग्युमेंट बदल गए हैं, और Compose उस कॉम्पोनेंट को फिर से कंपोज़ करता है.

बदले जा सकने वाले ऑब्जेक्ट

पिछले उदाहरण में, नहीं बदले जा सकने वाले ऑब्जेक्ट का इस्तेमाल किया गया है. हालांकि, ऐसा करके बदला जा सकने वाला ऑब्जेक्ट है. यहां दिए गए स्निपेट का इस्तेमाल करें:

data class Contact(var name: String, var number: String)

Contact का हर पैरामीटर अब एक var है, इसलिए क्लास में बदलाव नहीं किया जा सकता. अगर इसकी प्रॉपर्टी बदल जाती हैं, तो कंपोज़ की जानकारी नहीं दिखेगी. ऐसा इसलिए है, क्योंकि 'लिखें' स्टेट ऑब्जेक्ट में किए गए बदलावों को सिर्फ़ ट्रैक करता है.

Compose सुविधा का इस्तेमाल करने पर यह क्लास में कुछ गड़बड़ी के तौर पर दिखती है. कंपोज़िशन ने इसे फिर से क्रम में लगाने का विकल्प नहीं चुना क्लास में गड़बड़ी. अगर Contact को इस तरह परिभाषित किया जाता है, तो ContactRow ऊपर दिए गए उदाहरण में, selected के बदलने पर जब भी बदलाव किया जाएगा, तब उसे फिर से शामिल किया जाएगा.

Compose में लागू करने की सुविधा

यह इस बात पर विचार करने में मदद कर सकता है: 'लिखें' किस तरह का है यह तय करता है कि फिर से बनाने के दौरान किन फ़ंक्शन को छोड़ना है.

जब Compose कंपाइलर आपके कोड पर चलता है, तो वह हर फ़ंक्शन और टाइप को मार्क करता है का इस्तेमाल करें. ये टैग बताते हैं कि Compose, फ़ंक्शन को कैसे हैंडल करता है या डिज़ाइन करने के दौरान टाइप करें.

ध्यान दें: ये टैग, वीडियो के क्रम को समझने के लिए ज़रूरी नहीं हैं और जैसा कि इस दस्तावेज़ के पिछले सेक्शन में बताया गया है. हालांकि, स्थिरता से जुड़ी समस्याओं को डीबग करने में ज़्यादा मदद मिलती है.

फ़ंक्शन

कंपोज़ की सुविधा, फ़ंक्शन को skippable या restartable के तौर पर मार्क कर सकती है. ध्यान दें कि यह किसी फ़ंक्शन को इनमें से एक, दोनों या दोनों में से कोई नहीं के तौर पर मार्क करें:

• स्किप किया जा सकने वाला: अगर कंपाइलर किसी कंपोज़ेबल को स्किप किया जा सकने वाला मार्क करता है, तो Compose यह कर सकता है अगर इसके सभी तर्क इसके बराबर हैं, तो फिर से कंपोज़िशन के दौरान इसे स्किप कर दें पिछली वैल्यू.
• रीस्टार्ट किया जा सकने वाला: रीस्टार्ट किया जा सकने वाला कंपोज़ेबल, "स्कोप" के तौर पर काम करता है जहां फ़ोटो को क्रम में लगाने की प्रोसेस शुरू हो सकती है. दूसरे शब्दों में, फ़ंक्शन वह एंट्री जहां कंपोज़ की सुविधा के बाद, जगह बदलने के लिए कोड को फिर से एक्ज़ीक्यूट करना शुरू किया जा सकता है राज्य में बदलाव.

प्रकार

मार्क को ऐसे टाइप के तौर पर लिखें जिन्हें बदला नहीं जा सकता या स्थिर नहीं है. हर टाइप एक या अन्य:

• अम्यूटेबल: लिखने पर किसी टाइप की वैल्यू में बदलाव होने पर, उसे नहीं बदला जा सकता के तौर पर मार्क किया जाता है प्रॉपर्टी कभी नहीं बदली जा सकतीं और सभी तरीके संदर्भ के हिसाब से पारदर्शी होते हैं.
  • ध्यान रखें कि सभी प्रिमिटिव टाइप को नहीं बदला जा सकने वाला मार्क किया गया है. इनमें ये शामिल हैं String, Int, और Float.
• स्टेबल: इससे यह पता चलता है कि किस टाइप की प्रॉपर्टी, कंस्ट्रक्शन के बाद बदल सकती हैं. अगर रनटाइम के दौरान ये प्रॉपर्टी बदल जाती हैं, तो कंपोज़ की सुविधा को बदलाव नहीं कर सकते.

ध्यान दें: यह ज़रूरी नहीं है कि कंपोज़ेबल के पैरामीटर में, कंपोज़ेबल में बदला न जा सके स्किप किया जा सकता है. इन्हें तब तक बदला जा सकता है, जब तक 'लिखें' रनटाइम सभी बदलावों की सूचना दी गई. ज़्यादातर प्रकारों के लिए यह एक अव्यावहारिक अनुबंध होगा, जिसमें मज़बूत बनाना. हालांकि, Compose में ऐसी बदली जा सकने वाली क्लास मौजूद हैं जो इस समझौते के हिसाब से काम करती हैं जैसे कि MutableState, SnapshotStateMap, और SnapshotStateList.

डीबग की स्थिरता

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

स्थिरता से जुड़ी जटिल समस्याओं का पता लगाने के तरीके के बारे में ज़्यादा जानकारी लिखने के लिए, डीबग स्थिरता गाइड देखें.

स्थिरता से जुड़ी समस्याएं ठीक करना

Compose की सुविधा लागू करने के दौरान उसे क्रैश या फ़्रीज़ होने से बचाने के तरीके के बारे में जानने के लिए, यहां जाएं स्थिरता से जुड़ी समस्याएं ठीक करें गाइड.

खास जानकारी

कुल मिलाकर, आपको इन बातों पर ध्यान देना चाहिए:

• पैरामीटर: लिखने की सुविधा आपके कारोबार के हर पैरामीटर की स्थिरता तय करती है कंपोज़ेबल, ताकि यह तय किया जा सके कि कौनसे कंपोज़ेबल को इस दौरान स्किप करना चाहिए शॉर्ट वीडियो में बदलाव करना.
• तुरंत किए जाने वाले सुधार: अगर आपको लगता है कि आपके कंपोज़ेबल को स्किप नहीं किया जा रहा है और इससे परफ़ॉर्मेंस में समस्या आ रही है, तो आपको इसकी सही वजहों की जांच करनी चाहिए पहले var पैरामीटर जैसी स्थिरता नहीं आती.
• कंपाइलर रिपोर्ट: कंपाइलर रिपोर्ट का इस्तेमाल इन कामों के लिए किया जा सकता है यह तय करते हैं कि आपकी क्लास के बारे में किस स्थिरता का अनुमान लगाया जा रहा है.
• कलेक्शन: कंपोज़ की सुविधा, कभी-कभी कलेक्शन क्लास को ठीक से काम नहीं करती. जैसे, List, Set और Map के तौर पर. ऐसा इसलिए है, क्योंकि इस बात की गारंटी नहीं दी जा सकती कि नहीं बदले जा सकते. इसके बजाय, Kotlinx के बदले जा सकने वाले कलेक्शन का इस्तेमाल करें या अपनी क्लास में @Immutable या @Stable के तौर पर व्याख्या करें.
• अन्य मॉड्यूल: अगर कोई वैल्यू पहले से मौजूद है, तो कंपोज़ की वैल्यू हमेशा रुक जाती है ऐसे मॉड्यूल जिनमें कंपोज़ कंपाइलर नहीं चलता. क्लास को यूज़र इंटरफ़ेस (यूआई) में रैप करें मॉडल क्लास का इस्तेमाल करें.

इसके बारे में और पढ़ें

• परफ़ॉर्मेंस: ‘Compose की परफ़ॉर्मेंस’ के बारे में ज़्यादा जानकारी डीबग करने के बारे में जानने के लिए, यहां जाएं हमारी सबसे सही तरीकों की गाइड और I/O से जुड़ी जानकारी.