इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

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

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

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

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

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

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

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

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

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

पहली इमेज. बेसलाइन प्रोफ़ाइल जनरेटर मॉड्यूल टेंप्लेट.

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

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

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

अपने Gradle प्रोजेक्ट में Macrobenchmark मॉड्यूल सेट अप करें.
BaselineProfileGenerator नाम की नई क्लास तय करें:
```
class BaselineProfileGenerator {
    @get:Rule
    val baselineProfileRule = BaselineProfileRule()

    @Test
    fun startup() = baselineProfileRule.collect(
        packageName = "com.example.app",
        profileBlock = {
            startActivityAndWait()
        }
    )
}
```
जनरेटर में, ऐप्लिकेशन के चालू होने के बाद भी आपके ऐप्लिकेशन के साथ हुए इंटरैक्शन शामिल हो सकते हैं. इससे आपको अपने ऐप्लिकेशन की रनटाइम परफ़ॉर्मेंस को ऑप्टिमाइज़ करने में मदद मिलती है. जैसे, स्क्रोलिंग लिस्ट, ऐनिमेशन चलाना, और किसी Activity में नेविगेट करना. @BaselineProfileRule का इस्तेमाल करके, उपयोगकर्ता के अहम सफ़र को बेहतर बनाने वाली जांच के अन्य उदाहरण देखें.
बेसलिन प्रोफ़ाइल Gradle प्लगिन (libs.plugins.androidx.baselineprofile) जोड़ें. इस प्लगिन की मदद से, बेसलिन प्रोफ़ाइल जनरेट करना और उन्हें आने वाले समय में बनाए रखना आसान हो जाता है.
बेसलिन प्रोफ़ाइल जनरेट करने के लिए, टर्मिनल में :app:generateBaselineProfile या :app:generateVariantBaselineProfile Gradle टास्क चलाएं.

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

ध्यान दें: Jetpack Macrobenchmark 1.2.0-alpha06 और इसके बाद के वर्शन का इस्तेमाल करते समय, Android 13 (एपीआई 33) और इसके बाद के वर्शन पर चलने वाले डिवाइसों पर, रूट ऐक्सेस के बिना बेसलाइन प्रोफ़ाइल जनरेट की जा सकती है.

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

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

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

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

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

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

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

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
}

: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;
            })
        )
    }
}

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

androidx.baselineprofile प्लगिन लागू करें.
: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'
}

:app:generateBaselineProfile या :app:generateVariantBaselineProfile Gradle टास्क चलाकर, प्रोफ़ाइल जनरेट करें.
जनरेशन टास्क के आखिर में, बेसलाइन प्रोफ़ाइल को 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.
आपको जनरेट किए गए Baseline Profile के नियमों को अपने कोड पर मैन्युअल तरीके से लागू करना होगा.

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

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

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

प्रोफ़ाइलें, [class name]-[test method name]-baseline-prof.txt नाम रखने के पैटर्न का पालन करती हैं. यह पैटर्न ऐसा दिखता है: BaselineProfileGenerator-startup-baseline-prof.txt.
जनरेट की गई प्रोफ़ाइल को src/main/ में कॉपी करें और फ़ाइल का नाम बदलकर baseline-prof.txt कर दें.

ध्यान दें: अगर Android Gradle प्लगिन के 8.0 से पहले के वर्शन का इस्तेमाल किया जा रहा है, तो baseline-prof.txt फ़ाइल, Android Studio में Android व्यू में नहीं दिखती है.
अपने ऐप्लिकेशन की build.gradle.kts फ़ाइल में, ProfileInstaller लाइब्रेरी की डिपेंडेंसी जोड़ें. इससे, क्लाउड प्रोफ़ाइलें उपलब्ध न होने पर, स्थानीय तौर पर बेसलाइन प्रोफ़ाइल कंपाइल की जा सकेगी. बेसलाइन प्रोफ़ाइल को स्थानीय तौर पर साइडलोड करने का यही तरीका है.
```
dependencies {
     implementation("androidx.profileinstaller:profileinstaller:1.4.1")
}
```
अपने ऐप्लिकेशन का प्रोडक्शन वर्शन बनाएं. इस दौरान, एचआरएफ़ के लागू किए गए नियमों को बाइनरी फ़ॉर्म में कंपाइल किया जाता है और APK या AAB में शामिल किया जाता है. इसके बाद, अपने ऐप्लिकेशन को हमेशा की तरह डिस्ट्रिब्यूट करें.

बेसलाइन प्रोफ़ाइल की परफ़ॉर्मेंस की तुलना करना

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

**तीसरी इमेज.** गटर ऐक्शन से Android टेस्ट चलाएं.

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

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

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

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

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

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

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

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

आपके लिए सुझाव

ध्यान दें: JavaScript बंद होने पर लिंक टेक्स्ट दिखता है
मैक्रोबेंचमार्क मेट्रिक कैप्चर करना
मैक्रोबेंचमार्क लिखना
JankStats लाइब्रेरी

पीछे जाएं

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

आगे बढ़ें

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