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

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

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

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

Generate Baseline Profile रन कॉन्फ़िगरेशन पूरा होने पर, यह जनरेट की गई Baseline Profile को उस मॉड्यूल की 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 प्रोजेक्ट में Macrobenchmark मॉड्यूल सेट अप करें.
2. BaselineProfileGenerator नाम की नई क्लास तय करें:

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

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

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

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

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

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

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

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

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

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

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

   1. androidx.baselineprofile प्लगिन लागू करें.
   2. पक्का करें कि targetProjectPath, :app मॉड्यूल की ओर ले जाता हो.
   3. ज़रूरी नहीं है कि Gradle मैनेज किए गए डिवाइस (जीएमडी) को जोड़ा जाए. यहां दिए गए उदाहरण में, यह 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 के लिए दिए गए तरीके का इस्तेमाल करें. हालांकि, इसमें ये अपवाद शामिल हैं:

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

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

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

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

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

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

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

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

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

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

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

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

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

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