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

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

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

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

डेटा को सुरक्षित रखने से जुड़े नियमों की ज़रूरत क्यों होती है

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

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

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

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

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

किसी ऐप्लिकेशन के लिए, 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 के फ़ायदों को कम करने का सबसे आसान तरीका है कि बहुत ज़्यादा सामान्य Keep Rules लिखे जाएं. नीचे दिए गए नियम जैसे नियमों का इस्तेमाल करें. इनसे R8 ऑप्टिमाइज़र को यह निर्देश मिलता है कि वह इस पैकेज या इसके किसी भी सब-पैकेज में मौजूद किसी भी क्लास को छोटा न करे, उसे अस्पष्ट न करे, और उसे ऑप्टिमाइज़ न करे. इससे उस पूरे पैकेज के लिए, R8 के फ़ायदे पूरी तरह से हट जाते हैं. इसके बजाय, Keep के लिए सटीक और कम शब्दों वाले नियम लिखें.
 

-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 में न रखें. अगर आपको यह जानकर हैरानी हुई है, तो अपने R8 कॉन्फ़िगरेशन में किसी भी तरह के नेगेशन की जांच करें.

Android कॉम्पोनेंट के लिए, एक जैसे नियम

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

इसके अलावा, कई लाइब्रेरी अपने खुद के डेटा को सुरक्षित रखने के नियम बनाती हैं. इसलिए, आपको इनके लिए अपने नियम नहीं बनाने चाहिए. अगर आपको इस्तेमाल की जा रही किसी लाइब्रेरी के Keep Rules में कोई समस्या आ रही है, तो सबसे अच्छा तरीका यह है कि आप लाइब्रेरी के लेखक से संपर्क करें और समस्या के बारे में जानें.

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

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

कम शब्दों में जानकारी देने वाले Keep के नियम लिखना

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

-keepclassmembers class com.example.MyClass {

    private java.lang.String secretMessage;

    public void onNativeEvent(java.lang.String);

}

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

अलग-अलग डेटा मॉडल के लिए अलग-अलग Keep Rule लिखने के बजाय, एक ऐसा नियम लिखें जो किसी सामान्य बेस क्लास या इंटरफ़ेस को टारगेट करता हो. नीचे दिए गए नियम से 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 Option के बारे में ज़्यादा जानकारी दी गई है.

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

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 Rules को फ़िल्टर करना

अगर आपको ऐसी लाइब्रेरी का इस्तेमाल करना है जिसमें 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 की ज़रूरत नहीं है. नई लाइब्रेरी चुनते समय, हमेशा ऐसे समाधान को प्राथमिकता दें जो रिफ़्लेक्शन के बजाय कोड जनरेशन का इस्तेमाल करता हो.

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

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 पर मौजूद मैक्रोबेंचमार्क के सैंपल ऐप्लिकेशन से कोड को अडॉप्ट करके, परफ़ॉर्मेंस में हुए फ़ायदों को मेज़र करें. इससे, ऐप्लिकेशन के स्टार्टअप टाइम को पहले और बाद में मेज़र किया जा सकेगा.

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

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

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