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

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

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

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

android { ... }

composeCompiler {
   enableStrongSkippingMode = true
}

स्किप किया जा सकने वाला कॉम्पोज़ेबल

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

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

कब स्किप करें

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

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

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

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

@NonSkippableComposable
@Composable
fun MyNonSkippableComposable {}

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

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

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

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

उदाहरण

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

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

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

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

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

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

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

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

मेमोइज़ेशन से बचना

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

val lambda = @DontMemoize {
    ...
}

APK का साइज़

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

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