स्किप करने का बेहतर मोड

स्ट्रॉन्ग स्किपिंग, Compose कंपाइलर में उपलब्ध एक मोड है. इसे चालू करने पर, कंपाइलर के व्यवहार को दो तरह से बदलता है:

• स्थिर पैरामीटर वाले कंपोज़ेबल को स्किप किया जा सकता है
• अस्थिर कैप्चर वाले लैम्डा को याद रखा जाता है

स्किप करने वाला मोड चालू करें

Gradle मॉड्यूल को ज़ोर से स्किप करने की सुविधा चालू करने के लिए, नीचे दिया गया विकल्प शामिल करें आपके Gradle कॉन्फ़िगरेशन का composeCompiler ब्लॉक:

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

आसानी से मैनेज और स्किप किया जा सकता है

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

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

कब नहीं

यह तय करने के लिए कि कॉम्पोनेंट को फिर से बनाने के दौरान, किसी कंपोज़ेबल को छोड़ना है या नहीं. हर पैरामीटर की वैल्यू, उनकी पिछली वैल्यू के साथ मिलती है. तुलना का टाइप पैरामीटर की स्थिरता पर निर्भर करता है.

• इंस्टेंस इक्वलिटी (===) का इस्तेमाल करके, स्थिर न किए जा सकने वाले पैरामीटर की तुलना की जाती है
• स्थिर पैरामीटर की तुलना, ऑब्जेक्ट के बराबर की रफ़्तार का इस्तेमाल करके की जाती है (Object.equals())

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

ऐसा हो सकता है कि आप किसी कंपोज़ेबल को स्किप करने की सुविधा से ऑप्ट आउट करना चाहें. इसका मतलब है कि आपको रीस्टार्ट करने लायक, लेकिन स्किप न किया जा सकने वाला कंपोज़ेबल चाहिए. इस स्थिति में, @NonSkippableComposable एनोटेशन.

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

क्लास के तौर पर ऐसी व्याख्या करें कि वे अच्छी तरह काम कर रही हैं

अगर आपको इंस्टेंस बराबरी के बजाय ऑब्जेक्ट बराबरी का इस्तेमाल करने वाले किसी ऑब्जेक्ट की ज़रूरत है, दी गई क्लास के बारे में @Stable के साथ एनोटेट करना जारी रखें. उदाहरण के लिए, जब आप ऐसा तब करना पड़ता है, जब ऑब्जेक्ट की पूरी सूची, डेटा सोर्स, क्योंकि कमरा किसी भी समय, सूची में मौजूद हर आइटम के लिए नए ऑब्जेक्ट असाइन करेगा बदलाव नहीं करता.

Lambda मेमोाइज़ेशन

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

उदाहरण

ज़्यादा स्किप करने की सुविधा का इस्तेमाल करते समय, कंपोज़ेबल में लैम्डा को याद रखने के लिए, कंपाइलर remember कॉल से आपके लैम्डा को रैप कर देता है. यह लैम्डा को कैप्चर कर लिया है.

नीचे दिए गए उदाहरण की तरह, ऐसे मामले पर विचार करें जिसमें आपके पास Lambda फ़ंक्शन है:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = {
        use(unstableObject)
        use(stableObject)
    }
}

तेज़ स्किप करने की सुविधा चालू होने पर, कंपाइलर लैम्डा को रैप करके याद कर लेता है एक remember कॉल:

@Composable
fun MyComposable(unstableObject: Unstable, stableObject: Stable) {
    val lambda = remember(unstableObject, stableObject) {
        {
            use(unstableObject)
            use(stableObject)
        }
    }
}

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

यादगार बनाना और उसे फिर से बनाना

इस ऑप्टिमाइज़ेशन से, कंपोज़ेबल की संख्या काफ़ी बढ़ जाती है स्किप कर दिया जाता है. याद रखे बिना, रनटाइम की संभावना ज़्यादा है किसी भी कंपोज़ेबल को नया Lambda फ़ंक्शन असाइन करने के लिए, जो लैम्डा पैरामीटर लेता है शॉर्ट वीडियो में बदलाव करना. इस वजह से, नए Lambda फ़ंक्शन में ऐसे पैरामीटर हैं जो इसके बराबर नहीं हैं आखिरी कंपोज़िशन. इस वजह से, शॉर्ट वीडियो को दोबारा इस्तेमाल किया जाता है.

याद रखने से बचें

अगर आपके पास कोई लैम्डा है, जिसे आपको याद नहीं रखना है, तो @DontMemoize का उपयोग करें एनोटेशन.

val lambda = @DontMemoize {
    ...
}

APK का आकार

कंपाइल किए जाने पर, स्किप किए जा सकने वाले कंपोज़ेबल के नतीजे के तौर पर जनरेट किए गए कोड ऐसे कंपोज़ेबल जिन्हें स्किप नहीं किया जा सकता. ज़ोर से स्किप करने की सुविधा चालू होने पर, कंपाइलर करीब सभी कंपोज़ेबल को स्किप किया जा सकता है और सभी लैम्डा को remember{...}. इस वजह से, स्किप करने के मज़बूत मोड को चालू करने से आपके ऐप्लिकेशन के APK के साइज़ पर पड़ने वाले असर के बारे में बताता है.

अब Android में में तेज़ी से स्किप करने की सुविधा चालू करने से APK की संख्या बढ़ गई है 4kB तक. साइज़ में अंतर, काफ़ी हद तक पिछली इमेज की संख्या पर निर्भर करता है स्किप न किए जा सकने वाले ऐसे कंपोज़ेबल जो दिए गए ऐप्लिकेशन में मौजूद थे, लेकिन बहुत मामूली होता है.