आजकल, Android ऐप्लिकेशन डेवलपमेंट में, उपयोगकर्ताओं की यह बुनियादी ज़रूरत है कि उन्हें छोटा, तेज़, और सुरक्षित ऐप्लिकेशन मिले. Android बिल्ड सिस्टम का मुख्य टूल, R8 ऑप्टिमाइज़र है. यह कंपाइलर, इस्तेमाल न होने वाले कोड और संसाधनों को हटाने का काम करता है. इससे कोड को छोटा किया जाता है, कोड का नाम बदला जाता है या उसे छोटा किया जाता है, और ऐप्लिकेशन को ऑप्टिमाइज़ किया जाता है.

ऐप्लिकेशन को रिलीज़ करने के लिए, R8 को चालू करना एक ज़रूरी चरण है. हालांकि, इसके लिए डेवलपर को "सुरक्षित रखने के नियम" के तौर पर दिशा-निर्देश देने होते हैं.

इस लेख को पढ़ने के बाद, YouTube पर R8 ऑप्टिमाइज़र को चालू करने, डीबग करने, और समस्या हल करने के बारे में जानकारी देने वाला परफ़ॉर्मेंस स्पॉटलाइट वीक वीडियो देखें.

'रखने के नियम' क्यों ज़रूरी हैं

Keep के नियमों को लिखने की ज़रूरत इसलिए पड़ती है, क्योंकि R8 एक स्टैटिक एनालिसिस टूल है. हालांकि, Android ऐप्लिकेशन अक्सर डाइनैमिक एक्ज़ीक्यूशन पैटर्न पर निर्भर करते हैं. जैसे, JNI (Java Native Interface) का इस्तेमाल करके नेटिव कोड में रिफ़्लेक्शन या कॉल.

R8, डायरेक्ट कॉल का विश्लेषण करके, इस्तेमाल किए गए कोड का ग्राफ़ बनाता है. जब कोड को डाइनैमिक तरीके से ऐक्सेस किया जाता है, तो R8 का स्टैटिक विश्लेषण इस बात का अनुमान नहीं लगा सकता. इसलिए, यह उस कोड को इस्तेमाल नहीं किया गया के तौर पर पहचान करेगा और उसे हटा देगा. इससे रनटाइम क्रैश हो सकते हैं.

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

Keep Rules के बारे में ज़्यादा जानने के लिए, आधिकारिक गाइड देखें.

Keep के नियम कहां लिखें

किसी ऐप्लिकेशन के लिए, कस्टम कीप नियम टेक्स्ट फ़ाइल में लिखे जाते हैं. आम तौर पर, इस फ़ाइल का नाम proguard-rules.pro होता है. यह ऐप्लिकेशन या लाइब्रेरी मॉड्यूल के रूट में मौजूद होती है. इसके बाद, इस फ़ाइल को आपके मॉड्यूल की build.gradle.kts फ़ाइल के release बिल्ड टाइप में तय किया जाता है.

release {

    isShrinkResources = true

    isMinifyEnabled = true

    proguardFiles(

        getDefaultProguardFile("proguard-android-optimize.txt"),

        "proguard-rules.pro",

    )

}

सही डिफ़ॉल्ट फ़ाइल का इस्तेमाल करना

getDefaultProguardFile तरीके से, Android SDK की ओर से दिए गए नियमों का डिफ़ॉल्ट सेट इंपोर्ट किया जाता है. गलत फ़ाइल का इस्तेमाल करने पर, हो सकता है कि आपका ऐप्लिकेशन ऑप्टिमाइज़ न हो. proguard-android-optimize.txt का इस्तेमाल करना न भूलें. इस फ़ाइल में, स्टैंडर्ड Android कॉम्पोनेंट के लिए डिफ़ॉल्ट कीप नियम दिए गए हैं. साथ ही, यह R8 को कोड ऑप्टिमाइज़ेशन की सुविधा चालू करने की अनुमति देता है. पुराना proguard-android.txt सिर्फ़ कीप नियम उपलब्ध कराता है. हालांकि, यह R8 के ऑप्टिमाइज़ेशन को चालू नहीं करता.

यह परफ़ॉर्मेंस से जुड़ी एक गंभीर समस्या है. इसलिए, हम डेवलपर को गलत फ़ाइल का इस्तेमाल करने के बारे में चेतावनी दे रहे हैं. यह चेतावनी, Android Studio Narwhal 3 Feature Drop से शुरू होगी. साथ ही, Android Gradle प्लग इन 9.0 वर्शन से, हम पुरानी proguard-android.txt फ़ाइल का इस्तेमाल नहीं कर रहे हैं. इसलिए, पक्का करें कि आपने ऑप्टिमाइज़ किए गए वर्शन पर अपग्रेड कर लिया हो.

Keep के लिए नियम लिखने का तरीका

डेटा बनाए रखने के नियम के तीन मुख्य हिस्से होते हैं:

1. कोई विकल्प जैसे कि -keep या -keepclassmembers
2. ज़रूरी नहीं है कि मॉडिफ़ायर का इस्तेमाल किया जाए. जैसे, allowshrinking
3. क्लास स्पेसिफ़िकेशन, जो मैच करने के लिए कोड तय करता है

पूरे सिंटैक्स और उदाहरणों के लिए, डेटा सुरक्षित रखने के नियम जोड़ने से जुड़े दिशा-निर्देश देखें.

Keep Rule के एंटी-पैटर्न

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

ग्लोबल ऑप्शन

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

-dontotptimize का इस्तेमाल करने से, R8 के परफ़ॉर्मेंस ऑप्टिमाइज़ेशन की सुविधा बंद हो जाती है. इससे ऐप्लिकेशन की परफ़ॉर्मेंस धीमी हो जाती है.

-dontobfuscate का इस्तेमाल करने पर, नाम बदलने की सुविधा बंद हो जाती है. वहीं, -dontshrink का इस्तेमाल करने पर, डेड कोड हटाने की सुविधा बंद हो जाती है. इन दोनों ग्लोबल नियमों से, ऐप्लिकेशन का साइज़ बढ़ जाता है.

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

निजी डेटा के रखरखाव के बहुत ज़्यादा सामान्य नियम

R8 के फ़ायदों को कम करने का सबसे आसान तरीका है कि बहुत ज़्यादा सामान्य कीप नियम लिखे जाएं. यहां दिए गए कीप नियम जैसे नियम, R8 ऑप्टिमाइज़र को इस पैकेज या इसके किसी भी सब-पैकेज में मौजूद किसी भी क्लास को छोटा न करने, उसे अस्पष्ट न करने, और उसे ऑप्टिमाइज़ न करने का निर्देश देते हैं. इससे पूरे पैकेज के लिए R8 के फ़ायदे पूरी तरह से खत्म हो जाते हैं. इसके बजाय, कम शब्दों में और खास कीप नियम लिखने की कोशिश करें.
 

-keep class com.example.package.** { *;} // WIDE KEEP RULES CAUSE PROBLEMS

इनवर्ज़न ऑपरेटर (!)

इनवर्ज़न ऑपरेटर (!) का इस्तेमाल करके, किसी पैकेज को नियम से बाहर रखा जा सकता है. हालांकि, यह इतना आसान नहीं है. इस उदाहरण को देखें:

-keep class !com.example.my_package.** { *; } // USE WITH CAUTION

आपको लग सकता है कि इस नियम का मतलब है कि com.example.package में क्लास न रखें. हालांकि, इसका मतलब है कि com.example.package में ऐसी हर क्लास, तरीका, और प्रॉपर्टी रखें जो पूरे ऐप्लिकेशन में मौजूद है, लेकिन com.example.package में नहीं है. अगर आपको यह जानकर हैरानी हुई है, तो R8 कॉन्फ़िगरेशन में किसी भी तरह के नेगेशन की जांच करें.

Android कॉम्पोनेंट के लिए ज़रूरत से ज़्यादा नियम

एक और आम गलती यह है कि लोग अपने ऐप्लिकेशन के Activities, Services या BroadcastReceivers के लिए, Keep Rules को मैन्युअल तरीके से जोड़ते हैं. ऐसा करना ज़रूरी नहीं है. डिफ़ॉल्ट proguard-android-optimize.txt फ़ाइल में, इन स्टैंडर्ड Android कॉम्पोनेंट के लिए पहले से ही ज़रूरी नियम शामिल होते हैं.

साथ ही, कई लाइब्रेरी अपने खुद के कीप रूल लेकर आती हैं. इसलिए, आपको इनके लिए अपने खुद के नियम नहीं लिखने चाहिए. अगर इस्तेमाल की जा रही किसी लाइब्रेरी के कीप रूल में कोई समस्या है, तो लाइब्रेरी के लेखक से संपर्क करके यह पता लगाना सबसे अच्छा है कि समस्या क्या है.

Keep Rule के सबसे सही तरीके

अब आपको पता चल गया है कि क्या नहीं करना है. इसलिए, आइए अब सबसे सही तरीकों के बारे में बात करते हैं.

Keep के लिए सटीक नियम लिखना

अच्छे कीप नियमों को ज़्यादा से ज़्यादा सीमित और खास होना चाहिए. उन्हें सिर्फ़ ज़रूरी कॉम्पोनेंट को सुरक्षित रखना चाहिए, ताकि R8 बाकी सभी कॉम्पोनेंट को ऑप्टिमाइज़ कर सके.
 

-keepclassmembers class com.example.MyClass {

    private java.lang.String secretMessage;

    public void onNativeEvent(java.lang.String);

}

कॉमन ऐनसेस्टर का इस्तेमाल करना

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

# Keep all fields of any class that implements SerializableModel

-keepclassmembers class * implements com.example.models.SerializableModel {

    <fields>;

}

एक से ज़्यादा क्लास को टारगेट करने के लिए, एनोटेशन का इस्तेमाल करना

कस्टम एनोटेशन (जैसे, @Serialize) बनाएं और इसका इस्तेमाल उन क्लास को "टैग" करने के लिए करें जिनके फ़ील्ड को सुरक्षित रखना है. यह एक और साफ़, एलानिया, और ज़्यादा स्केलेबल पैटर्न है. जिन फ़्रेमवर्क का इस्तेमाल किया जा रहा है उनसे पहले से मौजूद एनोटेशन के लिए भी, Keep के नियम बनाए जा सकते हैं.

# Keep all fields of any class annotated with @Serialize

-keepclassmembers class * {

    @com.example.annotations.Serialize <fields>;

}

सही कीप ऑप्शन चुनना

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

Keep Options के दस्तावेज़ में, Keep ऑप्शन के बारे में ज़्यादा जानकारी दी गई है.

मॉडिफ़ायर की मदद से ऑप्टिमाइज़ करने की अनुमति दें

allowshrinking और allowobfuscation जैसे मॉडिफ़ायर, -keep नियम को आसान बनाते हैं. इससे R8 को ऑप्टिमाइज़ेशन की सुविधा वापस मिल जाती है. उदाहरण के लिए, अगर कोई लेगसी लाइब्रेरी आपको पूरी क्लास पर -keep का इस्तेमाल करने के लिए मजबूर करती है, तो कोड को छोटा करने और उसे अस्पष्ट करने की अनुमति देकर, कुछ ऑप्टिमाइज़ेशन वापस पाया जा सकता है:

# Keep this class, but allow R8 to remove it if it's unused and allow R8 to rename it.

-keep,allowshrinking,allowobfuscation class com.example.LegacyClass

अतिरिक्त ऑप्टिमाइज़ेशन के लिए ग्लोबल विकल्प जोड़ना

कोड कॉम्पोनेंट को लागू करने से जुड़े नियमों के अलावा, R8 कॉन्फ़िगरेशन फ़ाइल में ग्लोबल फ़्लैग जोड़े जा सकते हैं. इससे ऑप्टिमाइज़ेशन को और बेहतर बनाया जा सकता है.

-repackageclasses एक बेहतरीन विकल्प है. यह R8 को सभी अस्पष्ट क्लास को एक ही पैकेज में ले जाने का निर्देश देता है. इससे DEX फ़ाइल में काफ़ी जगह बचती है, क्योंकि यह पैकेज के नाम वाली गैर-ज़रूरी स्ट्रिंग को हटा देता है.

-allowaccessmodification की मदद से, R8 को ज़्यादा ऐक्सेस (जैसे, private से public) मिलता है, ताकि वह ज़्यादा बेहतर तरीके से इनलाइनिंग कर सके. proguard-android-optimize.txt का इस्तेमाल करते समय, यह सुविधा अब डिफ़ॉल्ट रूप से चालू होती है.

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

इसे और भी ज़्यादा साफ़ तौर पर समझने के लिए, हम Android Gradle प्लगिन के 9.0 वर्शन में, लाइब्रेरी से मिलने वाले ग्लोबल ऑप्टिमाइज़ेशन फ़्लैग को पूरी तरह से अनदेखा करना शुरू कर देंगे. 

लाइब्रेरी के लिए सबसे सही तरीके

हर Android ऐप्लिकेशन, किसी न किसी तरह से लाइब्रेरी पर निर्भर होता है. इसलिए, आइए लाइब्रेरी के सबसे सही तरीकों के बारे में बात करते हैं.

लाइब्रेरी डेवलपर के लिए

अगर आपकी लाइब्रेरी में रिफ़्लेक्शन या JNI का इस्तेमाल किया जाता है, तो आपको उसके उपभोक्ताओं को ज़रूरी Keep Rules देने होंगे. ये नियम, consumer-rules.pro फ़ाइल में रखे जाते हैं. इसके बाद, इन्हें लाइब्रेरी की AAR फ़ाइल में अपने-आप बंडल कर दिया जाता है.

android {

    defaultConfig {

        consumerProguardFiles("consumer-rules.pro")

    }

    ...

}

लाइब्रेरी का इस्तेमाल करने वालों के लिए

Keep के उन नियमों को फ़िल्टर करना जिनमें समस्याएं हैं

अगर आपको ऐसी लाइब्रेरी का इस्तेमाल करना है जिसमें Keep Rules से जुड़ी समस्याएं हैं, तो AGP 9.0 या इसके बाद के वर्शन में, build.gradle.kts फ़ाइल में जाकर उन्हें फ़िल्टर किया जा सकता है. इससे R8 को यह पता चलता है कि किसी खास डिपेंडेंसी से आने वाले नियमों को अनदेखा करना है.

release {

    optimization.keepRules {

        // Ignore all consumer rules from this specific library

        it.ignoreFrom("com.somelibrary:somelibrary")

    }

}

सबसे अच्छा कीप रूल, कोई कीप रूल नहीं होता

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

लाइब्रेरी चुनने के तरीके के बारे में ज़्यादा जानने के लिए, लाइब्रेरी सोच-समझकर चुनें लेख पढ़ें.

R8 कॉन्फ़िगरेशन को डीबग करना और उससे जुड़ी समस्याओं को हल करना

जब R8 ऐसे कोड को हटा देता है जिसे उसे रखना चाहिए या आपका APK उम्मीद से ज़्यादा बड़ा होता है, तो समस्या का पता लगाने के लिए इन टूल का इस्तेमाल करें.

डुप्लीकेट और ग्लोबल Keep के नियम ढूंढना

R8, कई सोर्स से नियमों को मर्ज करता है. इसलिए, यह जानना मुश्किल हो सकता है कि "फ़ाइनल" नियमों का सेट क्या है. इस फ़्लैग को अपनी proguard-rules.pro फ़ाइल में जोड़ने से, पूरी रिपोर्ट जनरेट होती है:

# Outputs the final, merged set of rules to the specified file

-printconfiguration build/outputs/logs/configuration.txt

इस फ़ाइल में, एक जैसे नियमों को खोजने या किसी समस्या वाले नियम (जैसे, -dontoptimize) का पता लगाने के लिए, इसे खोजा जा सकता है. इससे यह पता लगाया जा सकता है कि इसे किस लाइब्रेरी में शामिल किया गया था.

R8 से पूछें: इसे क्यों सेव किया जा रहा है?

अगर आपको लगता है कि कोई क्लास हटाई जानी चाहिए थी, लेकिन वह अब भी आपके ऐप्लिकेशन में दिख रही है, तो R8 आपको इसकी वजह बता सकता है. बस यह नियम जोड़ें:

# Asks R8 to explain why it's keeping a specific class

class com.example.MyUnusedClass

-whyareyoukeeping 

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

पूरी गाइड के लिए, R8 से जुड़ी समस्या हल करना सेक्शन देखें.

अगले चरण

R8, Android ऐप्लिकेशन की परफ़ॉर्मेंस को बेहतर बनाने वाला एक बेहतरीन टूल है. यह स्टैटिक विश्लेषण इंजन के तौर पर काम करता है. इसलिए, इसकी परफ़ॉर्मेंस इस बात पर निर्भर करती है कि इसे सही तरीके से समझा गया है या नहीं.

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

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

अब समय आ गया है कि आप खुद इन फ़ायदों को देखें.

हमारा सुझाव है कि आप अपने ऐप्लिकेशन के लिए, R8 के फ़ुल मोड को आज ही चालू करें.

1. शुरू करने के लिए, हमारी डेवलपर गाइड देखें: ऐप्लिकेशन ऑप्टिमाइज़ेशन चालू करना.
2. देखें कि क्या अब भी proguard-android.txt का इस्तेमाल किया जा रहा है. अगर हां, तो इसे proguard-android-optimize.txt से बदलें.
3. इसके बाद, असर का आकलन करें. सिर्फ़ अंतर को महसूस न करें, बल्कि इसकी पुष्टि करें. स्टार्टअप के समय में हुई बढ़ोतरी को मेज़र करने के लिए,  GitHub पर मौजूद हमारे Macrobenchmark के सैंपल ऐप्लिकेशन से कोड को अडैप्ट करें. इससे, स्टार्टअप के समय को पहले और बाद में मेज़र किया जा सकेगा.

हमें भरोसा है कि इससे आपके ऐप्लिकेशन की परफ़ॉर्मेंस में काफ़ी सुधार होगा.

इसके अलावा, अपने सवाल पूछने के लिए #AskAndroid सोशल टैग का इस्तेमाल करें. हमारे विशेषज्ञ पूरे हफ़्ते आपके सवालों की निगरानी करते हैं और उनके जवाब देते हैं.

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