बेसलाइन प्रोफ़ाइल बनाएं

Jetpack Macrobenchmark लाइब्रेरी और BaselineProfileRule का इस्तेमाल करके, हर ऐप्लिकेशन रिलीज़ के लिए प्रोफ़ाइलें अपने-आप जनरेट करें. हमारा सुझाव है कि आप com.android.tools.build:gradle:8.0.0 या उससे ज़्यादा वर्शन का इस्तेमाल करें. यह वर्शन, बेसलाइन प्रोफ़ाइलों का इस्तेमाल करते समय, बेहतर बिल्ड के साथ आता है.

नई बेसलाइन प्रोफ़ाइल बनाने के सामान्य चरण यहां दिए गए हैं:

1. बेसलाइन प्रोफ़ाइल मॉड्यूल सेट अप करें.
2. बेसलाइन प्रोफ़ाइल जनरेट करने में मदद करने वाले JUnit टेस्ट के बारे में बताएं.
3. वे क्रिटिकल यूज़र जर्नी (CUJs) जोड़ें जिन्हें आपको ऑप्टिमाइज़ करना है.
4. बेसलाइन प्रोफ़ाइल जनरेट करें.

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

AGP 8.2 या उसके बाद के वर्शन का इस्तेमाल करके नई बेसलाइन प्रोफ़ाइल बनाना

नई बेसलाइन प्रोफ़ाइल बनाने का सबसे आसान तरीका, बेसलाइन प्रोफ़ाइल मॉड्यूल टेंप्लेट का इस्तेमाल करना है. यह टेंप्लेट, Android Studio Iguana और Android Gradle Plugin (AGP) 8.2 के बाद से उपलब्ध है.

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

बेसलाइन प्रोफ़ाइल मॉड्यूल सेट अप करना

बेसलाइन प्रोफ़ाइल मॉड्यूल टेंप्लेट चलाने के लिए, यह तरीका अपनाएं:

1. फ़ाइल > नया > नया मॉड्यूल चुनें
2. टेंप्लेट पैनल में, बेसलाइन प्रोफ़ाइल जनरेटर टेंप्लेट चुनें और उसे कॉन्फ़िगर करें:

   

   टेंप्लेट में ये फ़ील्ड होते हैं:

   • टारगेट किया गया ऐप्लिकेशन: इससे यह तय होता है कि बेसलाइन प्रोफ़ाइल किस ऐप्लिकेशन के लिए जनरेट की गई है. अगर आपके प्रोजेक्ट में सिर्फ़ एक ऐप्लिकेशन मॉड्यूल है, तो इस सूची में सिर्फ़ एक आइटम होगा.
   • मॉड्यूल का नाम: आपको बेसलाइन प्रोफ़ाइल मॉड्यूल के लिए जो नाम देना है वह डालें.
   • पैकेज का नाम: वह पैकेज का नाम जो आपको बेसलाइन प्रोफ़ाइल के लिए चाहिए मॉड्यूल.
   • भाषा: आपको जनरेट किया गया कोड Kotlin में चाहिए या Java में.
   • बिल्ड कॉन्फ़िगरेशन लैंग्वेज: आपको अपनी बिल्ड कॉन्फ़िगरेशन स्क्रिप्ट के लिए, Kotlin स्क्रिप्ट (KTS) या Groovy में से किसका इस्तेमाल करना है.
   • Gradle से मैनेज किए जाने वाले डिवाइस का इस्तेमाल करना: इससे पता चलता है कि आपने अपने ऐप्लिकेशन की जांच करने के लिए, Gradle से मैनेज किए जाने वाले डिवाइसों का इस्तेमाल किया है या नहीं.
3. पूरा करें पर क्लिक करें. इसके बाद, नया मॉड्यूल बन जाएगा. अगर सोर्स कंट्रोल का इस्तेमाल किया जा रहा है, तो आपको सोर्स कंट्रोल में नई बनाई गई मॉड्यूल फ़ाइलें जोड़ने के लिए कहा जा सकता है.

बेसलाइन प्रोफ़ाइल जनरेटर तय करना

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

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

बेसलाइन प्रोफ़ाइल जनरेट करना और इंस्टॉल करना

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

बेसलाइन प्रोफ़ाइल जनरेट करें रन कॉन्फ़िगरेशन पूरा होने के बाद, जनरेट की गई बेसलाइन प्रोफ़ाइल को, प्रोफ़ाइल किए जा रहे मॉड्यूल में मौजूद src/variant/generated/baselineProfiles/baseline-prof.txt फ़ाइल में कॉपी कर दिया जाता है. वैरिएंट के विकल्पों में, रिलीज़ बिल्ड टाइप या रिलीज़ बिल्ड टाइप वाला बिल्ड वैरिएंट शामिल होता है.

जनरेट की गई बेसलाइन प्रोफ़ाइल को मूल रूप से build/outputs में बनाया गया था. प्रोफ़ाइल किए जा रहे ऐप्लिकेशन के वैरिएंट या फ़्लेवर के आधार पर, पूरा पाथ तय होता है. साथ ही, यह भी तय होता है कि प्रोफ़ाइलिंग के लिए, Gradle से मैनेज किए जा रहे डिवाइस का इस्तेमाल किया जा रहा है या कनेक्ट किए गए डिवाइस का. अगर कोड में इस्तेमाल किए गए नामों और टेंप्लेट से जनरेट किए गए कॉन्फ़िगरेशन का इस्तेमाल किया जाता है, तो बेसलाइन प्रोफ़ाइल build/outputs/managed_device_android_test_additional_output/nonminifiedrelease/pixel6Api31/BaselineProfileGenerator_generate-baseline-prof.txt फ़ाइल में बनाई जाती है. हो सकता है कि आपको जनरेट की गई बेसलाइन प्रोफ़ाइल के इस वर्शन के साथ सीधे तौर पर इंटरैक्ट करने की ज़रूरत न पड़े. ऐसा तब तक नहीं होगा, जब तक कि इसे टारगेट मॉड्यूल में मैन्युअल तरीके से कॉपी नहीं किया जाता. हालांकि, ऐसा करने का सुझाव नहीं दिया जाता.

AGP 8.1 की मदद से नई बेसलाइन प्रोफ़ाइल बनाना

अगर बेसलाइन प्रोफ़ाइल मॉड्यूल टेंप्लेट का इस्तेमाल नहीं हो पा रहा है, तो नई बेसलाइन प्रोफ़ाइल बनाने के लिए, मैक्रोबेंचमार्क मॉड्यूल टेंप्लेट और बेसलाइन प्रोफ़ाइल Gradle प्लग इन का इस्तेमाल करें. हमारा सुझाव है कि आप Android Studio Giraffe और AGP 8.1 के साथ इन टूल का इस्तेमाल शुरू करें.

Macrobenchmark मॉड्यूल टेंप्लेट और Baseline Profile Gradle प्लग इन का इस्तेमाल करके, नई बेसलाइन प्रोफ़ाइल बनाने का तरीका यहां बताया गया है:

1. अपने Gradle प्रोजेक्ट में एक मैक्रोबेंचमार्क मॉड्यूल सेट अप करें.
2. BaselineProfileGenerator नाम की नई क्लास तय करें:

   class BaselineProfileGenerator {
       @get:Rule
       val baselineProfileRule = BaselineProfileRule()
   
       @Test
       fun startup() = baselineProfileRule.collect(
           packageName = "com.example.app",
           profileBlock = {
               startActivityAndWait()
           }
       )
   }

   जनरेटर में, ऐप्लिकेशन के शुरू होने के बाद होने वाले इंटरैक्शन भी शामिल हो सकते हैं. इससे, अपने ऐप्लिकेशन की रनटाइम परफ़ॉर्मेंस को ऑप्टिमाइज़ किया जा सकता है. जैसे, सूचियों को स्क्रोल करना, ऐनिमेशन चलाना, और किसी Activity में नेविगेट करना. उपयोगकर्ता के सफ़र को बेहतर बनाने के लिए, @BaselineProfileRule का इस्तेमाल करने वाले टेस्ट के अन्य उदाहरण देखें.

3. Baseline Profile Gradle प्लग इन (libs.plugins.androidx.baselineprofile) जोड़ें. इस प्लग इन की मदद से, Baseline Profile जनरेट करना और आने वाले समय में उन्हें मैनेज करना आसान हो जाता है.

4. बेसलाइन प्रोफ़ाइल जनरेट करने के लिए, टर्मिनल में :app:generateBaselineProfile या :app:generateVariantBaselineProfile Gradle टास्क चलाएं.

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

   जनरेशन टास्क पूरा होने के बाद, बेसलाइन प्रोफ़ाइल को app/src/variant/generated/baselineProfiles में कॉपी कर दिया जाता है.

टेंप्लेट के बिना नई बेसलाइन प्रोफ़ाइल बनाना

हमारा सुझाव है कि आप Android Studio के बेसलाइन प्रोफ़ाइल मॉड्यूल टेंप्लेट (इसका सुझाव दिया जाता है) या मैक्रोबेंचमार्क टेंप्लेट का इस्तेमाल करके, बेसलाइन प्रोफ़ाइल बनाएं. हालांकि, आपके पास बेसलाइन प्रोफ़ाइल Gradle प्लग इन का इस्तेमाल करने का विकल्प भी है. बेसलाइन प्रोफ़ाइल Gradle प्लग-इन के बारे में ज़्यादा जानने के लिए, बेसलाइन प्रोफ़ाइल जनरेशन को कॉन्फ़िगर करना लेख पढ़ें.

बेसलाइन प्रोफ़ाइल Gradle प्लग इन का इस्तेमाल करके, सीधे तौर पर बेसलाइन प्रोफ़ाइल बनाने का तरीका यहां बताया गया है:

1. नया com.android.test मॉड्यूल बनाएं. उदाहरण के लिए, :baseline-profile.

2. :baseline-profile के लिए build.gradle.kts फ़ाइल को कॉन्फ़िगर करें:

   1. androidx.baselineprofile प्लग इन लागू करें.
   2. पक्का करें कि targetProjectPath, :app मॉड्यूल पर ले जाता हो.
   3. इसके अलावा, Gradle से मैनेज किया जाने वाला डिवाइस (GMD) भी जोड़ा जा सकता है. नीचे दिए गए उदाहरण में, यह pixel6Api31 है. अगर इसकी जानकारी नहीं दी गई है, तो प्लग इन, कनेक्ट किए गए डिवाइस का इस्तेमाल करता है. यह डिवाइस, एम्युलेट किया गया हो या फ़िज़िकल.
   4. अपनी पसंद का कॉन्फ़िगरेशन लागू करें, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है.

   Kotlin

   plugins {
       id("com.android.test")
       id("androidx.baselineprofile")
   }
   
   android {
       defaultConfig {
           ...
       }
   
       // Point to the app module, the module that you're generating the Baseline Profile for.
       targetProjectPath = ":app"
       // Configure a GMD (optional).
       testOptions.managedDevices.devices {
           pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
               device = "Pixel 6"
               apiLevel = 31
               systemImageSource = "aosp"
           }
       }
   }
   
   dependencies { ... }
   
   // Baseline Profile Gradle plugin configuration. Everything is optional. This
   // example uses the GMD added earlier and disables connected devices.
   baselineProfile {
       // Specifies the GMDs to run the tests on. The default is none.
       managedDevices += "pixel6Api31"
       // Enables using connected devices to generate profiles. The default is
       // `true`. When using connected devices, they must be rooted or API 33 and
       // higher.
       useConnectedDevices = false
   }

   Groovy

   plugins {
       id 'com.android.test'
       id 'androidx.baselineprofile'
   }
   
   android {
       defaultConfig {
           ...
       }
   
       // Point to the app module, the module that you're generating the Baseline Profile for.
       targetProjectPath ':app'
       // Configure a GMD (optional).
       testOptions.managedDevices.devices {
           pixel6Api31(com.android.build.api.dsl.ManagedVirtualDevice) {
               device 'Pixel 6'
               apiLevel 31
               systemImageSource 'aosp'
           }
       }
   }
   
   dependencies { ... }
   
   // Baseline Profile Gradle plugin configuration. Everything is optional. This
   // example uses the GMD added earlier and disables connected devices.
   baselineProfile {
       // Specifies the GMDs to run the tests on. The default is none.
       managedDevices ['pixel6Api31']
       // Enables using connected devices to generate profiles. The default is
       // `true`. When using connected devices, they must be rooted or API 33 and
       // higher.
       useConnectedDevices false
   }

3. :baseline-profile टेस्ट मॉड्यूल में, बेसलाइन प्रोफ़ाइल टेस्ट बनाएं. यहां दिया गया उदाहरण, एक ऐसा टेस्ट है जो ऐप्लिकेशन को शुरू करता है और ऐप्लिकेशन के बंद होने का इंतज़ार करता है.

   Kotlin

   class BaselineProfileGenerator {
   
       @get:Rule
       val baselineRule = BaselineProfileRule()
   
       @Test
       fun startupBaselineProfile() {
           baselineRule.collect("com.myapp") {
               startActivityAndWait()
           }
       }
   }

   Java

   public class BaselineProfileGenerator {
   
       @Rule
       Public BaselineProfileRule baselineRule = new BaselineProfileRule();
   
       @Test
       Public void startupBaselineProfile() {
           baselineRule.collect(
               "com.myapp",
               (scope -> {
                   scope.startActivityAndWait();
                   Return Unit.INSTANCE;
               })
           )
       }
   }

4. ऐप्लिकेशन मॉड्यूल में build.gradle.kts फ़ाइल को अपडेट करें. उदाहरण के लिए, :app.

   1. प्लगिन androidx.baselineprofile लागू करें.
   2. :baseline-profile मॉड्यूल में baselineProfile डिपेंडेंसी जोड़ें.

   Kotlin

   plugins {
       id("com.android.application")
       id("androidx.baselineprofile")
   }
   
   android {
       // There are no changes to the `android` block.
       ...
   }
   
   dependencies {
       ...
       // Add a `baselineProfile` dependency on the `:baseline-profile` module.
       baselineProfile(project(":baseline-profile"))
   }

   Groovy

   plugins {
       id 'com.android.application'
       id 'androidx.baselineprofile'
   }
   
   android {
       // No changes to the `android` block.
       ...
   }
   
   dependencies {
       ...
       // Add a `baselineProfile` dependency on the `:baseline-profile` module.
       baselineProfile ':baseline-profile'
   }

5. :app:generateBaselineProfile या :app:generateVariantBaselineProfile Gradle टास्क चलाकर प्रोफ़ाइल जनरेट करें.

6. जनरेट करने के टास्क के आखिर में, बेसलाइन प्रोफ़ाइल को app/src/variant/generated/baselineProfiles में कॉपी कर दिया जाता है.

AGP 7.3-7.4 की मदद से नई बेसलाइन प्रोफ़ाइल बनाना

AGP 7.3-7.4 की मदद से बेसलाइन प्रोफ़ाइलें जनरेट की जा सकती हैं. हालांकि, हमारा सुझाव है कि आप कम से कम AGP 8.1 पर अपग्रेड करें, ताकि आप बेसलाइन प्रोफ़ाइल Gradle प्लग इन और उसकी नई सुविधाओं का इस्तेमाल कर सकें.

अगर आपको AGP 7.3-7.4 के साथ बेसलाइन प्रोफ़ाइलें बनानी हैं, तो इसके लिए वही तरीका अपनाएं जो AGP 8.1 के लिए अपनाया जाता है. हालांकि, इन मामलों में यह तरीका अलग होगा:

• Baseline Profile Gradle प्लग-इन न जोड़ें.
• बेसलाइन प्रोफ़ाइल जनरेट करने के लिए, Gradle टास्क ./gradlew [emulator name][flavor][build type]AndroidTest को लागू करें. उदाहरण के लिए, ./gradlew :benchmark:pixel6Api31BenchmarkAndroidTest.
• आपको जनरेट किए गए बेसलाइन प्रोफ़ाइल के नियमों को अपने कोड में मैन्युअल तरीके से लागू करना होगा.

जनरेट किए गए नियमों को मैन्युअल तरीके से लागू करना

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

1. उस मॉड्यूल के बिल्ड फ़ोल्डर में HRF फ़ाइल ढूंढें जिसमें प्रोफ़ाइल जनरेट की जाती है: [module]/build/outputs/managed_device_android_test_additional_output/[device].

   प्रोफ़ाइलों को नाम देने का पैटर्न [class name]-[test method name]-baseline-prof.txt यह होता है: BaselineProfileGenerator-startup-baseline-prof.txt.

2. जनरेट की गई प्रोफ़ाइल को src/main/ में कॉपी करें और फ़ाइल का नाम बदलकर baseline-prof.txt करें.

3. अपने ऐप्लिकेशन की build.gradle.kts फ़ाइल में, ProfileInstaller लाइब्रेरी के लिए डिपेंडेंसी जोड़ें. इससे, उन जगहों पर स्थानीय बेसलाइन प्रोफ़ाइल को कंपाइल करने की सुविधा चालू की जा सकती है जहां क्लाउड प्रोफ़ाइल उपलब्ध नहीं हैं. यह, डिवाइस में बेसलाइन प्रोफ़ाइल को साइडलोड करने का एकमात्र तरीका है.

   dependencies {
        implementation("androidx.profileinstaller:profileinstaller:1.4.1")
   }
   

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

बेसलाइन प्रोफ़ाइल को बेंचमार्क करना

अपनी बेसलाइन प्रोफ़ाइल को बेंचमार्क करने के लिए, गटर ऐक्शन से एक नया Android इंस्ट्रुमेंटेड टेस्ट रन कॉन्फ़िगरेशन बनाएं. यह कॉन्फ़िगरेशन, StartupBenchmarks.kt या StartupBencharks.java फ़ाइल में तय किए गए बेंचमार्क को लागू करता है. बेंचमार्क जांच के बारे में ज़्यादा जानने के लिए, Macrobenchmark क्लास बनाएं और Macrobenchmark लाइब्रेरी की मदद से मेज़रमेंट को ऑटोमेट करें लेख पढ़ें.

Android Studio में इसे चलाने पर, बिल्ड आउटपुट में, बेसलाइन प्रोफ़ाइल की मदद से, ऐप्लिकेशन की स्पीड में हुए सुधारों की जानकारी दिखती है:

StartupBenchmarks_startupCompilationBaselineProfiles
timeToInitialDisplayMs   min 161.8,   median 178.9,   max 194.6
StartupBenchmarks_startupCompilationNone
timeToInitialDisplayMs   min 184.7,   median 196.9,   max 202.9

सभी ज़रूरी कोड पाथ कैप्चर करना

ऐप्लिकेशन के शुरू होने में लगने वाले समय को मेज़र करने के लिए, ये दो मुख्य मेट्रिक इस्तेमाल की जाती हैं:

शुरुआती डिसप्ले में लगने वाला समय (टीटीआईडी)

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

पूरी तरह से दिखने में लगने वाला समय (टीटीएफ़डी)

टीटीआईडी के साथ-साथ, शुरुआती फ़्रेम दिखने के बाद असिंक्रोनस तरीके से लोड होने वाले कॉन्टेंट को दिखाने में लगने वाला समय.

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

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

अगर आपका ऐप्लिकेशन Jetpack Compose का इस्तेमाल करता है, तो पूरी तरह से ड्रॉ होने की स्थिति दिखाने के लिए, इन एपीआई का इस्तेमाल करें:

• ReportDrawn से पता चलता है कि आपका कॉम्पोज़ेबल, इंटरैक्शन के लिए तुरंत तैयार है.
• ReportDrawnWhen list.count > 0 जैसे प्रीडिकेट का इस्तेमाल करता है. इससे यह पता चलता है कि आपका कॉम्पोनेंट, इंटरैक्शन के लिए कब तैयार है.
• ReportDrawnAfter, एक ऐसा तरीका इस्तेमाल करता है जिससे आपका कॉम्पोनेंट इंटरैक्शन के लिए तैयार हो जाता है.