สร้างโปรไฟล์พื้นฐาน

สร้างโปรไฟล์สำหรับรุ่นของแอปทุกรุ่นโดยอัตโนมัติโดยใช้คลัง Macrobenchmark ของ Jetpack และ BaselineProfileRule เราขอแนะนําให้คุณใช้ com.android.tools.build:gradle:8.0.0 ขึ้นไป ซึ่งมาพร้อมกับการปรับปรุงบิลด์เมื่อใช้โปรไฟล์พื้นฐาน

สำคัญ: ระบบจะติดตั้งโปรไฟล์พื้นฐานสําหรับบิลด์รุ่นเท่านั้น เพื่อให้เวลาในการดำเนินการติดตั้งในระหว่างการพัฒนาต่ำ

ขั้นตอนทั่วไปในการสร้างโปรไฟล์พื้นฐานใหม่มีดังนี้

1. ตั้งค่าข้อบังคับของโปรไฟล์พื้นฐาน
2. กำหนดการทดสอบ JUnit ที่ช่วยสร้างโปรไฟล์พื้นฐาน
3. เพิ่มเส้นทางของผู้ใช้ที่สําคัญ (CUJ) ที่ต้องการเพิ่มประสิทธิภาพ
4. สร้างโปรไฟล์พื้นฐาน

หลังจากสร้างโปรไฟล์พื้นฐานแล้ว ให้ทำการเปรียบเทียบโดยใช้อุปกรณ์จริงเพื่อวัดการปรับปรุงความเร็ว

สร้างโปรไฟล์พื้นฐานใหม่ด้วย AGP 8.2 ขึ้นไป

วิธีที่ง่ายที่สุดในการสร้างโปรไฟล์พื้นฐานใหม่คือการใช้เทมเพลตข้อบังคับของโปรไฟล์พื้นฐาน ซึ่งพร้อมใช้งานตั้งแต่ Android Studio Iguana และ Android Gradle Plugin (AGP) 8.2

เทมเพลตโมดูลเครื่องมือสร้างโปรไฟล์พื้นฐานของ Android Studio จะสร้างโมดูลใหม่โดยอัตโนมัติเพื่อสร้างและเปรียบเทียบโปรไฟล์พื้นฐาน การเรียกใช้เทมเพลตจะสร้างการกำหนดค่าบิลด์ทั่วไป การสร้างโปรไฟล์พื้นฐาน และรหัสยืนยันส่วนใหญ่ เทมเพลตจะสร้างโค้ดเพื่อสร้างและเปรียบเทียบโปรไฟล์พื้นฐานเพื่อวัดการเริ่มต้นของแอป

ตั้งค่าโมดูลโปรไฟล์พื้นฐาน

หากต้องการเรียกใช้เทมเพลตข้อบังคับของโปรไฟล์พื้นฐาน ให้ทําตามขั้นตอนต่อไปนี้

1. เลือก File > New > New Module
2. เลือกเทมเพลตเครื่องมือสร้างโปรไฟล์พื้นฐานในแผงเทมเพลต แล้วกําหนดค่าดังนี้

   

   รูปที่ 1 เทมเพลตโมดูลเครื่องมือสร้างโปรไฟล์พื้นฐาน

   ฟิลด์ในเทมเพลตมีดังนี้

   • แอปพลิเคชันเป้าหมาย: ระบุว่าสร้างโปรไฟล์พื้นฐานให้กับแอปใด เมื่อโปรเจ็กต์มีโมดูลแอปเพียง 1 รายการ รายการนี้จะมีเพียงรายการเดียว
   • ชื่อโมดูล: ชื่อที่ต้องการใช้สำหรับโมดูลโปรไฟล์พื้นฐานที่สร้างขึ้น
   • ชื่อแพ็กเกจ: ชื่อแพ็กเกจที่คุณต้องการสำหรับโมดูลโปรไฟล์พื้นฐาน
   • ภาษา: คุณต้องการให้โค้ดที่สร้างขึ้นเป็น Kotlin หรือ Java
   • ภาษาการกำหนดค่าบิลด์: คุณต้องการใช้ Kotlin Script (KTS) หรือ Groovy สำหรับสคริปต์การกำหนดค่าบิลด์
   • ใช้อุปกรณ์ที่มีการจัดการจาก Gradle: ระบุว่าคุณใช้อุปกรณ์ที่มีการจัดการจาก Gradle เพื่อทดสอบแอปหรือไม่
3. คลิก Finish จากนั้นสร้างโมดูลใหม่ หากใช้การควบคุมแหล่งที่มา คุณอาจได้รับแจ้งให้เพิ่มไฟล์โมดูลที่สร้างขึ้นใหม่ลงในการควบคุมแหล่งที่มา

กำหนดตัวสร้างโปรไฟล์พื้นฐาน

โมดูลที่สร้างขึ้นใหม่จะมีการทดสอบทั้งเพื่อสร้างและเปรียบเทียบโปรไฟล์พื้นฐาน รวมถึงทดสอบเฉพาะการเริ่มต้นแอปขั้นพื้นฐาน เราขอแนะนำให้คุณเพิ่ม CUJ และเวิร์กโฟลว์ขั้นสูงของ Startup เข้าไป ตรวจสอบว่าการทดสอบใดๆ ที่เกี่ยวข้องกับการเริ่มต้นแอปอยู่ในบล็อก rule โดยตั้งค่า includeInStartupProfile เป็น true ในทางกลับกัน และเพื่อประสิทธิภาพที่ดีที่สุด ให้ตรวจสอบว่าการทดสอบใดๆ ที่ไม่เกี่ยวข้องกับการเริ่มต้นแอปไม่ได้รวมอยู่ในโปรไฟล์สตาร์ทอัพ การเพิ่มประสิทธิภาพการเริ่มต้นแอปใช้เพื่อกำหนดส่วนพิเศษของโปรไฟล์พื้นฐานที่เรียกว่าโปรไฟล์การเริ่มต้น

การแยก CUJ เหล่านี้ออกจากโปรไฟล์พื้นฐานและโค้ดการเปรียบเทียบที่สร้างขึ้นจะช่วยให้สามารถบำรุงรักษาได้ เพื่อให้ใช้กับทั้ง 2 อย่างได้ ซึ่งหมายความว่าจะมีการใช้การเปลี่ยนแปลง CUJ อย่างสอดคล้องกัน

สร้างและติดตั้งโปรไฟล์พื้นฐาน

เทมเพลตโมดูลโปรไฟล์พื้นฐานจะเพิ่มการกําหนดค่าการเรียกใช้ใหม่เพื่อสร้างโปรไฟล์พื้นฐาน หากคุณใช้ตัวแปรผลิตภัณฑ์ Android Studio จะสร้างการกำหนดค่าการเรียกใช้หลายรายการเพื่อให้คุณสร้างโปรไฟล์พื้นฐานแยกต่างหากสำหรับแต่ละตัวแปรได้

หมายเหตุ: หากต้องการสร้างและติดตั้งโปรไฟล์พื้นฐานจากอินเทอร์เฟซบรรทัดคำสั่ง ให้เรียกใช้ :app:generateBaselineProfile หรือ :app:generateVariantBaselineProfile งาน Gradle

รูปที่ 2 การดำเนินการกำหนดค่านี้จะสร้างโปรไฟล์พื้นฐาน

เมื่อการกำหนดค่าการเรียกใช้สร้างโปรไฟล์พื้นฐานเสร็จสมบูรณ์แล้ว ระบบจะคัดลอกโปรไฟล์พื้นฐานที่สร้างขึ้นไปยังไฟล์ 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

หากใช้เทมเพลตโมดูลโปรไฟล์พื้นฐานไม่ได้ ให้ใช้เทมเพลตโมดูล Macrobenchmark และปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานเพื่อสร้างโปรไฟล์พื้นฐานใหม่ เราขอแนะนำให้คุณใช้เครื่องมือเหล่านี้โดยเริ่มจาก Android Studio Giraffe และ AGP 8.1

หมายเหตุ: การสร้างโปรไฟล์พื้นฐานอัตโนมัติด้วยปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานจะใช้ได้ตั้งแต่ AGP 8.0 แต่เราขอแนะนำให้ใช้ AGP 8.1 เพื่อประสบการณ์การใช้งานที่ดีขึ้น

ขั้นตอนการสร้างโปรไฟล์พื้นฐานใหม่โดยใช้เทมเพลตโมดูล Macrobenchmark และปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานมีดังนี้

1. ตั้งค่าโมดูล Macrobenchmark ในโปรเจ็กต์ Gradle
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 ให้ตั้งค่า aosp เป็น systemImageSource เนื่องจากคุณต้องมีสิทธิ์เข้าถึงระดับรูทสำหรับเครื่องมือสร้างโปรไฟล์พื้นฐาน

   หมายเหตุ: เมื่อใช้ Jetpack Macrobenchmark 1.2.0-alpha06 ขึ้นไป คุณสามารถสร้างโปรไฟล์พื้นฐานในอุปกรณ์ที่ใช้ Android 13 (API 33) ขึ้นไปได้โดยไม่ต้องมีสิทธิ์เข้าถึงระดับรูท

   เมื่องานการสร้างสิ้นสุดลง ระบบจะคัดลอกโปรไฟล์พื้นฐานไปยัง app/src/variant/generated/baselineProfiles

สร้างโปรไฟล์พื้นฐานใหม่โดยไม่ใช้เทมเพลต

เราขอแนะนำให้สร้างโปรไฟล์พื้นฐานโดยใช้เทมเพลตโมดูลโปรไฟล์พื้นฐาน (แนะนำ) หรือเทมเพลตการทดสอบประสิทธิภาพแบบแมโครของ Android Studio แต่คุณก็ใช้ปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานเพียงอย่างเดียวได้เช่นกัน อ่านเพิ่มเติมเกี่ยวกับปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานได้ที่กําหนดค่าการสร้างโปรไฟล์พื้นฐาน

หมายเหตุ: ระบบจะใช้ปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานอยู่แล้วหากคุณใช้เทมเพลตโมดูลโปรไฟล์พื้นฐาน

วิธีสร้างโปรไฟล์พื้นฐานโดยใช้ปลั๊กอิน Gradle ของโปรไฟล์พื้นฐานโดยตรงมีดังนี้

1. สร้างข้อบังคับ com.android.test ใหม่ เช่น :baseline-profile

2. กำหนดค่าไฟล์ build.gradle.kts สำหรับ :baseline-profile โดยทำดังนี้

   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. เพิ่มการพึ่งพา baselineProfile ลงในโมดูล :baseline-profile

   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"))
   }

   ดึงดูด

   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. สร้างโปรไฟล์โดยเรียกใช้งาน Gradle แบบ :app:generateBaselineProfile หรือ :app:generateVariantBaselineProfile

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
• คุณต้องใช้กฎโปรไฟล์พื้นฐานที่สร้างขึ้นกับโค้ดด้วยตนเอง

ใช้กฎที่สร้างขึ้นด้วยตนเอง

ตัวสร้างโปรไฟล์พื้นฐานจะสร้างไฟล์ข้อความรูปแบบที่อ่านได้ของมนุษย์ (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

   หมายเหตุ: หากคุณใช้ปลั๊กอิน Android Gradle เวอร์ชันที่เก่ากว่า 8.0 ไฟล์ baseline-prof.txt จะไม่แสดงในมุมมอง Android ใน Android Studio

3. เพิ่มการพึ่งพาไลบรารี ProfileInstaller ในไฟล์ build.gradle.kts ของแอปเพื่อเปิดใช้การคอมไพล์โปรไฟล์พื้นฐานในเครื่องในกรณีที่ไม่มีโปรไฟล์ในระบบคลาวด์ วิธีนี้เป็นวิธีเดียวในการโหลดโปรไฟล์พื้นฐานในเครื่อง

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

4. สร้างแอปเวอร์ชันที่ใช้งานจริงขณะที่กฎ HRF ที่ใช้อยู่ได้รับการคอมไพล์เป็นรูปแบบไบนารีและรวมอยู่ใน APK หรือ AAB จากนั้นเผยแพร่แอปตามปกติ

เปรียบเทียบโปรไฟล์พื้นฐาน

หากต้องการเปรียบเทียบโปรไฟล์พื้นฐาน ให้สร้างการกำหนดค่าการทดสอบที่ใช้เครื่องมือวัดประสิทธิภาพ Android ใหม่จากการดำเนินการในแถบด้านข้างที่เรียกใช้การเปรียบเทียบที่กําหนดไว้ในไฟล์ StartupBenchmarks.kt หรือ StartupBencharks.java ดูข้อมูลเพิ่มเติมเกี่ยวกับการทดสอบการเปรียบเทียบได้ที่สร้างคลาส Macrobenchmark และวัดผลอัตโนมัติด้วยคลัง Macrobenchmark

รูปที่ 3 เรียกใช้การทดสอบ 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

บันทึกเส้นทางโค้ดที่จําเป็นทั้งหมด

เมตริกหลัก 2 ประการในการวัดเวลาเริ่มต้นของแอปมีดังนี้

เวลาที่ใช้ในการแสดงผลครั้งแรก (TTID)

เวลาที่ใช้ในการแสดงเฟรมแรกของ UI ของแอปพลิเคชัน

เวลาที่ใช้ในการแสดงผลครบถ้วน (TTFD)

TTID บวกเวลาในการแสดงเนื้อหาที่โหลดแบบไม่พร้อมกันหลังจากที่แสดงเฟรมแรกแล้ว

ระบบจะรายงาน TTFD เมื่อมีการเรียกใช้วิธีของ ComponentActivity reportFullyDrawn() หากไม่เคยเรียกใช้ reportFullyDrawn() ระบบจะรายงาน TTID แทน คุณอาจต้องหน่วงเวลาเมื่อมีการเรียกใช้ reportFullyDrawn() จนกว่าการโหลดแบบไม่พร้อมกันจะเสร็จสมบูรณ์ เช่น หาก UI มีรายการแบบไดนามิก เช่น RecyclerView หรือรายการแบบ Lazy ระบบอาจป้อนข้อมูลรายการโดยงานเบื้องหลังที่เสร็จสมบูรณ์หลังจากวาดรายการครั้งแรก และหลังจาก UI ได้รับการระบุว่าวาดเสร็จแล้ว ในกรณีดังกล่าว โค้ดที่ทํางานหลังจาก UI ถึงสถานะ "วาดจนเสร็จสมบูรณ์" แล้วจะไม่รวมอยู่ในโปรไฟล์เกณฑ์พื้นฐาน

หากต้องการรวมข้อมูลประชากรของรายการเป็นส่วนหนึ่งของโปรไฟล์พื้นฐาน ให้รับ FullyDrawnReporter โดยใช้ getFullyDrawnReporter() และเพิ่มผู้รายงานลงในโปรไฟล์นั้นในโค้ดแอป ปล่อยผู้รายงานเมื่องานเบื้องหลังป้อนข้อมูลรายการเสร็จแล้ว FullyDrawnReporter จะไม่เรียกใช้เมธอด reportFullyDrawn() จนกว่าจะมีการปล่อยผู้รายงานทั้งหมด ซึ่งโปรไฟล์พื้นฐานจะมีเส้นทางโค้ดที่จําเป็นในการป้อนข้อมูลรายการ ซึ่งจะไม่เปลี่ยนลักษณะการทํางานของแอปสําหรับผู้ใช้ แต่จะช่วยให้โปรไฟล์พื้นฐานมีเส้นทางโค้ดที่จําเป็นทั้งหมด

หากแอปใช้ Jetpack Compose ให้ใช้ API ต่อไปนี้เพื่อระบุสถานะที่วาดอย่างสมบูรณ์

• ReportDrawn บ่งบอกว่าคอมโพสิเบิลของคุณพร้อมสำหรับการโต้ตอบทันที
• ReportDrawnWhen ใช้ภาคแสดง เช่น list.count > 0 เพื่อระบุว่า Composable พร้อมที่จะโต้ตอบเมื่อใด
• ReportDrawnAfter จะใช้เมธอดการระงับ ซึ่งเมื่อการทำงานเสร็จสิ้นจะบ่งบอกว่า Composable ของคุณพร้อมสำหรับการโต้ตอบแล้ว