कंपोज़ की सुविधा के बारे में सोचें

Jetpack Compose, Android के लिए जानकारी देने वाला एक आधुनिक यूज़र इंटरफ़ेस (यूआई) टूलकिट है. लिखने से ग्राहक डिक्लेरेटिव एपीआई उपलब्ध कराकर, ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) को लिखना और उसे मैनेज करना आसान होता है जिसकी मदद से आप फ़्रंटएंड में बदलाव किए बिना अपने ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) को रेंडर कर सकते हैं देखे जाने की संख्या. इस शब्दावली के लिए कुछ स्पष्टीकरण की आवश्यकता है, लेकिन इसके निष्कर्ष एक अहम जानकारी होती है.

डिक्लेरेटिव प्रोग्रामिंग मॉडल

अब तक, Android व्यू की हैरारकी को यूज़र इंटरफ़ेस (यूआई) के ट्री के तौर पर दिखाया जाता रहा है विजेट. ऐप्लिकेशन के स्टेटस में उपयोगकर्ता जैसी चीज़ों की वजह से बदलाव होता है इंटरैक्शन के लिए, मौजूदा डेटा दिखाने के लिए यूज़र इंटरफ़ेस (यूआई) की हैरारकी को अपडेट करना होगा. यूज़र इंटरफ़ेस (यूआई) को अपडेट करने का सबसे आम तरीका, इस तरह के फ़ंक्शन का इस्तेमाल करके ट्री को टहलना है findViewById(), और कॉल करने के तरीके, जैसे कि button.setText(String), से नोड बदलें container.addChild(View) या img.setImageBitmap(Bitmap). ये तरीके विजेट की अंदरूनी स्थिति बदलने के लिए.

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

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

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

आसानी से कंपोज़ेबल फ़ंक्शन

Compose का इस्तेमाल करके अपना यूज़र इंटरफ़ेस बनाया जा सकता है. इसके लिए, कंपोज़ेबल फ़ंक्शन जो डेटा को इकट्ठा करके, यूज़र इंटरफ़ेस (यूआई) एलिमेंट बनाते हैं. एक आसान उदाहरण एक Greeting विजेट है, जो String को लेता है और Text विजेट का उत्सर्जन करता है जिस पर वेलकम मैसेज दिखेगा.

फ़ोन का स्क्रीनशॉट, जिसमें यह टेक्स्ट दिख रहा है

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

इस फ़ंक्शन के बारे में ध्यान देने वाली कुछ बातें:

  • फ़ंक्शन के बारे में @Composable एनोटेशन के साथ जोड़ी गई है. सभी कंपोज़ेबल फ़ंक्शन में यह एनोटेशन होना चाहिए; यह एनोटेशन, Compose के बारे में बताता है कंपाइल करें कि इस फ़ंक्शन का मकसद डेटा को यूज़र इंटरफ़ेस (यूआई) में बदलना है.

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

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

  • फ़ंक्शन कुछ भी नहीं दिखाता है. ऐसे फ़ंक्शन लिखें जो यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल करते हैं किसी भी आइटम को लौटाना ज़रूरी है, क्योंकि इनसे स्क्रीन पर आपकी पसंद की स्थिति के बारे में पता चलता है तो मुझे यह सुविधा मिलेगी.

  • यह फ़ंक्शन तेज़ है, बेकार, और वीडियो में साइड-इफ़ेक्ट न हो.

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

    सामान्य तौर पर, सभी कंपोज़ेबल फ़ंक्शन को इनके साथ लिखा जाना चाहिए प्रॉपर्टी. इनके बारे में बदलाव में बताया गया है.

डिक्लेरेटिव पैराडाइम शिफ़्ट

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

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

Compose के यूज़र इंटरफ़ेस (यूआई) में डेटा के फ़्लो की इमेज. इसमें, हाई लेवल ऑब्जेक्ट से लेकर उनके बच्चों तक का डेटा शामिल है.

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

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

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

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

लगातार अपडेट होने वाला कॉन्टेंट

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

@Composable
fun Greeting(names: List<String>) {
    for (name in names) {
        Text("Hello $name")
    }
}
ThinkingInComposeSnippets.kt

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

क्रम में बदलाव करें

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

उदाहरण के लिए, बटन दिखाने वाले इस कंपोज़ेबल फ़ंक्शन को आज़माएं:

@Composable
fun ClickCounter(clicks: Int, onClick: () -> Unit) {
    Button(onClick = onClick) {
        Text("I've been clicked $clicks times")
    }
}
ThinkingInComposeSnippets.kt

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

जैसा कि हमने ऊपर चर्चा की है, पूरे यूज़र इंटरफ़ेस (यूआई) ट्री को फिर से कंपोज़िशन के तौर पर इनमें ज़्यादा बैटरी लाइफ़ होती है, जो कंप्यूटिंग पावर और बैटरी लाइफ़ का इस्तेमाल करती है. Compose की मदद से इसे हल किया जा सकता है इस समझदारी से बदलाव के साथ समस्या थी.

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

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

  • किसी शेयर किए गए ऑब्जेक्ट की प्रॉपर्टी में लिखना
  • ViewModel में मॉनिटर किया जा सकने वाला एलिमेंट अपडेट किया जा रहा है
  • शेयर की गई प्राथमिकताएं अपडेट की जा रही हैं

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

उदाहरण के लिए, यह कोड किसी वैल्यू को अपडेट करने के लिए एक कंपोज़ेबल बनाता है SharedPreferences. कंपोज़ेबल को शेयर किए गए कॉन्टेंट से पढ़ना या लिखना नहीं चाहिए प्राथमिकताएँ तय करें. इसके बजाय, यह कोड 'रीड और राइट' को ViewModel पर ले जाता है बैकग्राउंड कोरूटीन में. ऐप्लिकेशन लॉजिक, मौजूदा वैल्यू को कॉलबैक का इस्तेमाल करें.

@Composable
fun SharedPrefsToggle(
    text: String,
    value: Boolean,
    onValueChanged: (Boolean) -> Unit
) {
    Row {
        Text(text)
        Checkbox(checked = value, onCheckedChange = onValueChanged)
    }
}
ThinkingInComposeSnippets.kt

इस दस्तावेज़ में ऐसी कई चीज़ों के बारे में बताया गया है जिनके बारे में आपको 'लिखें' सुविधा का इस्तेमाल करते समय ध्यान रखना चाहिए:

  • कंपोज़ेबल फ़ंक्शन को किसी भी क्रम में लागू किया जा सकता है.
  • कंपोज़ेबल फ़ंक्शन साथ-साथ एक्ज़ीक्यूट किए जा सकते हैं.
  • छोटे-छोटे हिस्सों को फिर से बनाने पर, ज़्यादा से ज़्यादा कंपोज़ेबल फ़ंक्शन और Lambdas फ़ंक्शन को स्किप किया जा सकता है.
  • क्रम में बदलाव करने की उम्मीद है और इसे रद्द किया जा सकता है.
  • कंपोज़ेबल फ़ंक्शन को कई बार, हर फ़्रेम के हिसाब से, कई बार चलाया जा सकता है एक ऐनिमेशन है.

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

कंपोज़ेबल फ़ंक्शन को किसी भी क्रम में लागू किया जा सकता है

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

उदाहरण के लिए, मान लें कि किसी टैब में तीन स्क्रीन बनाने के लिए आपके पास इस तरह का कोड है लेआउट:

@Composable
fun ButtonRow() {
    MyFancyNavigation {
        StartScreen()
        MiddleScreen()
        EndScreen()
    }
}
ThinkingInComposeSnippets.kt

StartScreen, MiddleScreen, और EndScreen पर किसी भी कॉल में कॉल किया जा सकता है ऑर्डर. उदाहरण के लिए, इसका मतलब है कि आप StartScreen() को दुनिया भर में (एक साइड-इफ़ेक्ट) है और MiddleScreen() को इससे फ़ायदा होगा बदलें. इसके बजाय, इनमें से हर फ़ंक्शन अपने-आप में पूरा होने चाहिए.

कंपोज़ेबल फ़ंक्शन साथ-साथ काम करते हैं

कंपोज़ की सुविधा, कंपोज़ेबल फ़ंक्शन को साथ-साथ चलाकर, कंपोज़िशन को ऑप्टिमाइज़ कर सकती है. इससे, Compose की सुविधा कई कोर का इस्तेमाल करने और कंपोज़ेबल फ़ंक्शन को चलाने में मदद करती है नहीं होना चाहिए.

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

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

जब कंपोज़ेबल फ़ंक्शन को शुरू किया जाता है, तो बोला जाने वाला कोड किसी अन्य कॉलर का थ्रेड. इसका मतलब है कि वह कोड जो किसी कंपोज़ेबल में वैरिएबल में बदलाव करता है Lambda फ़ंक्शन से बचना चाहिए. ऐसा इसलिए, क्योंकि इस तरह के कोड थ्रेड के लिए सुरक्षित नहीं होते. साथ ही, कंपोज़ेबल लैम्डा की क्षमता पर इसका कोई असर नहीं होगा.

यहां एक उदाहरण दिया गया है, जिसमें कंपोज़ेबल को दिखाया गया है. इसमें लिस्ट और उसकी संख्या दिखाई गई है:

@Composable
fun ListComposable(myList: List<String>) {
    Row(horizontalArrangement = Arrangement.SpaceBetween) {
        Column {
            for (item in myList) {
                Text("Item: $item")
            }
        }
        Text("Count: ${myList.size}")
    }
}
ThinkingInComposeSnippets.kt

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

@Composable
@Deprecated("Example with bug")
fun ListWithBug(myList: List<String>) {
    var items = 0

    Row(horizontalArrangement = Arrangement.SpaceBetween) {
        Column {
            for (item in myList) {
                Text("Item: $item")
                items++ // Avoid! Side-effect of the column recomposing.
            }
        }
        Text("Count: $items")
    }
}
ThinkingInComposeSnippets.kt

इस उदाहरण में, items में हर बार बदलाव करते समय बदलाव किया गया है. यह काम हो सकता है ऐनिमेशन के हर फ़्रेम के लिए या सूची अपडेट होने पर. दोनों ही मामलों में, यूज़र इंटरफ़ेस (यूआई) गलत संख्या दिखाता है. इस वजह से, इस तरह के लिखने की सुविधा लिखना; उन लिखने पर पाबंदी लगाकर, हम फ़्रेमवर्क को उन थ्रेड को बदलने की अनुमति देते हैं कंपोज़ेबल lambdas को एक्ज़ीक्यूट करने के लिए.

जहां तक हो सके, शॉर्ट वीडियो को फिर से क्रम में लगाने की कोशिश न करें

जब आपके यूज़र इंटरफ़ेस (यूआई) के कुछ हिस्से अमान्य होते हैं, तो Compose सिर्फ़ उन हिस्सों को फिर से लिखने की कोशिश करता है जो जिन्हें अपडेट करने की ज़रूरत है. इसका मतलब यह है कि उसे स्किप करके, किसी सिंगल विंडो को फिर से चलाया जा सकता है बटन को इस तरह से कंपोज़ किया जा सकता है कि उसके ऊपर या नीचे के किसी भी कंपोज़ेबल को एक्ज़ीक्यूट न किया जा सके पर क्लिक करें.

हर कंपोज़ेबल फ़ंक्शन और Lambda फ़ंक्शन अपने-आप रिकंपोज़ कर सकते हैं. यह रही उदाहरण, जो दिखाता है कि रीकंपोज़िशन में कुछ एलिमेंट को कैसे छोड़ा जा सकता है सूची रेंडर करते समय:

/**
 * Display a list of names the user can click with a header
 */
@Composable
fun NamePicker(
    header: String,
    names: List<String>,
    onNameClicked: (String) -> Unit
) {
    Column {
        // this will recompose when [header] changes, but not when [names] changes
        Text(header, style = MaterialTheme.typography.bodyLarge)
        Divider()

        // LazyColumn is the Compose version of a RecyclerView.
        // The lambda passed to items() is similar to a RecyclerView.ViewHolder.
        LazyColumn {
            items(names) { name ->
                // When an item's [name] updates, the adapter for that item
                // will recompose. This will not recompose when [header] changes
                NamePickerItem(name, onNameClicked)
            }
        }
    }
}

/**
 * Display a single name the user can click.
 */
@Composable
private fun NamePickerItem(name: String, onClicked: (String) -> Unit) {
    Text(name, Modifier.clickable(onClick = { onClicked(name) }))
}
ThinkingInComposeSnippets.kt

रीकंपोज़िशन के दौरान सिर्फ़ इनमें से हर स्कोप को एक्ज़ीक्यूट किया जा सकता है. कंपोज़िशन अपने किसी भी पैरंट एलिमेंट को लागू किए बिना, Column Lambda फ़ंक्शन पर जा सकती है जब header में बदलाव होता है. Column को एक्ज़ीक्यूट करते समय, Compose आपकी पसंद के हिसाब से काम कर सकता है अगर names नहीं बदलता है, तो LazyColumn के आइटम छोड़ दें.

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

शॉर्ट वीडियो को बेहतर बनाने की प्रोसेस उम्मीद के मुताबिक है

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

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

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

कंपोज़ेबल फ़ंक्शन कई बार चल सकते हैं

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

उदाहरण के लिए, अगर आपके विजेट ने डिवाइस की सेटिंग पढ़ने की कोशिश की, तो उन सेटिंग को एक सेकंड में कई बार पढ़ें. इन सेटिंग पर, ऐप्लिकेशन की परफ़ॉर्मेंस कैसी है.

अगर आपके कंपोज़ेबल फ़ंक्शन को डेटा की ज़रूरत है, तो उसे डेटा के लिए पैरामीटर तय करने चाहिए. फिर आप महंगे काम को इसके बाहर, किसी दूसरे थ्रेड में ले जा सकते हैं कंपोज़िशन का इस्तेमाल कर सकता है और mutableStateOf या LiveData का इस्तेमाल करके डेटा को Compose में भेज सकता है.

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

लिखने और कंपोज़ेबल फ़ंक्शन में इस्तेमाल करने के तरीके के बारे में ज़्यादा जानने के लिए, यहां जाएं इन अतिरिक्त संसाधनों को पूरा करें.

वीडियो

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