Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat Profil Dasar Pengukuran

Buat profil secara otomatis untuk setiap rilis aplikasi menggunakan library Jetpack Macrobenchmark dan BaselineProfileRule. Sebaiknya gunakan com.android.tools.build:gradle:8.0.0 atau versi lebih baru, yang dilengkapi dengan peningkatan build saat menggunakan Profil Dasar Pengukuran.

Berikut adalah langkah umum untuk membuat Profil Dasar Pengukuran baru:

Menyiapkan modul Profil Dasar Pengukuran.
Menentukan pengujian JUnit yang membantu membuat Profil Dasar Pengukuran.
Menambahkan Perjalanan Penting Pengguna (CUJ) yang ingin Anda optimalkan.
Membuat Profil Dasar Pengukuran.

Setelah Anda membuat Profil Dasar Pengukuran, lakukan benchmark menggunakan perangkat fisik untuk mengukur peningkatan kecepatan.

Membuat Profil Dasar Pengukuran baru dengan AGP 8.2 atau yang lebih baru

Cara termudah untuk membuat Profil Dasar Pengukuran baru adalah dengan menggunakan template modul Profil Dasar Pengukuran, yang tersedia mulai Android Studio Iguana dan Plugin Android Gradle (AGP) 8.2.

Template modul Generator Profil Dasar Pengukuran Android Studio mengotomatiskan pembuatan modul baru untuk membuat dan menjalankan benchmark Profil Dasar Pengukuran. Menjalankan template ini akan menghasilkan sebagian besar konfigurasi build standar, pembuatan Profil Dasar Pengukuran, dan kode verifikasi. Template ini membuat kode untuk menghasilkan dan menjalankan benchmark Profil Dasar Pengukuran guna mengukur startup aplikasi.

Menyiapkan modul Profil Dasar Pengukuran

Untuk menjalankan template modul Profil Dasar Pengukuran, ikuti langkah-langkah berikut:

Pilih File > New > New Module
Pilih template Baseline Profile Generator di panel Templates dan lakukan konfigurasi:

Gambar 1. Template modul Generator Profil Dasar Pengukuran.

Kolom dalam template adalah sebagai berikut:
- Target application: menentukan aplikasi yang menjadi tujuan pembuatan Profil Dasar Pengukuran. Jika Anda hanya memiliki satu modul aplikasi dalam project, berarti hanya ada satu item dalam daftar ini.
- Module name: nama yang Anda inginkan untuk modul Profil Dasar Pengukuran yang sedang dibuat.
- Package name: nama paket yang Anda inginkan untuk modul Profil Dasar Pengukuran.
- Language: apakah Anda menginginkan kode yang dihasilkan berupa Kotlin atau Java.
- Build configuration language: apakah Anda ingin menggunakan Skrip Kotlin (KTS) atau Groovy untuk skrip konfigurasi build Anda.
- Gunakan perangkat yang dikelola Gradle: apakah Anda menggunakan perangkat yang dikelola Gradle untuk menguji aplikasi.
Klik Finish, dan modul baru akan dibuat. Jika menggunakan kontrol sumber, Anda mungkin diminta untuk menambahkan file modul yang baru dibuat ke kontrol sumber.

Menentukan generator Profil Dasar Pengukuran

Modul yang baru dibuat berisi pengujian untuk membuat dan melakukan benchmark Profil Dasar Pengukuran serta hanya menguji startup aplikasi dasar. Sebaiknya Anda menambahkannya untuk menyertakan CUJ dan alur kerja startup lanjutan. Pastikan semua pengujian yang terkait dengan startup aplikasi berada dalam blok rule dengan includeInStartupProfile ditetapkan ke true; sebaliknya, untuk performa yang optimal, pastikan semua pengujian yang tidak terkait dengan startup aplikasi tidak disertakan dalam Profil Startup. Pengoptimalan startup aplikasi digunakan untuk menentukan bagian khusus dari Profil Dasar Pengukuran yang disebut Profil Startup.

Hal ini membantu pemeliharaan jika Anda memisahkan CUJ ini di luar Profil Dasar Pengukuran dan kode benchmark yang dihasilkan sehingga dapat digunakan untuk keduanya. Ini berarti perubahan pada CUJ Anda digunakan secara konsisten.

Membuat dan menginstal Profil Dasar Pengukuran

Template modul Profil Dasar Pengukuran menambahkan konfigurasi run baru untuk membuat Profil Dasar Pengukuran. Jika Anda menggunakan ragam produk, Android Studio akan membuat beberapa konfigurasi run sehingga Anda dapat membuat Profil Dasar Pengukuran terpisah untuk setiap ragam.

Gambar 2. Menjalankan konfigurasi ini akan menghasilkan Profil Dasar Pengukuran.

Saat konfigurasi run Buat Profil Dasar Pengukuran selesai, konfigurasi ini akan menyalin Profil Dasar Pengukuran yang dihasilkan ke file src/variant/generated/baselineProfiles/baseline-prof.txt dalam modul yang sedang dibuat profilnya. Opsi varian dapat berupa jenis build rilis atau varian build yang melibatkan jenis build rilis.

Profil Dasar Pengukuran yang dihasilkan dibuat di build/outputs. Jalur lengkap ditentukan oleh varian atau ragam aplikasi yang sedang dibuat profilnya, dan ditentukan oleh apakah Anda menggunakan perangkat yang dikelola Gradle atau perangkat yang terhubung untuk pembuatan profil. Jika Anda menggunakan nama yang digunakan oleh kode dan konfigurasi build yang dihasilkan oleh template, Profil Dasar Pengukuran akan dibuat dalam file build/outputs/managed_device_android_test_additional_output/nonminifiedrelease/pixel6Api31/BaselineProfileGenerator_generate-baseline-prof.txt. Anda mungkin tidak perlu berinteraksi dengan versi Profil Dasar Pengukuran yang dihasilkan ini secara langsung kecuali jika Anda menyalinnya secara manual ke modul target (tidak direkomendasikan).

Membuat Profil Dasar Pengukuran baru dengan AGP 8.1

Jika Anda tidak dapat menggunakan template modul Profil Dasar Pengukuran, gunakan template modul Macrobenchmark dan plugin Gradle Profil Dasar Pengukuran untuk membuat Profil Dasar Pengukuran baru. Sebaiknya, gunakan alat ini mulai dari Android Studio Giraffe dan AGP 8.1.

Berikut adalah langkah-langkah untuk membuat Profil Dasar Pengukuran baru menggunakan template modul Macrobenchmark dan plugin Gradle Profil Dasar Pengukuran:

Siapkan modul Macrobenchmark dalam project Gradle Anda.
Tentukan class baru bernama BaselineProfileGenerator:
```
class BaselineProfileGenerator {
    @get:Rule
    val baselineProfileRule = BaselineProfileRule()

    @Test
    fun startup() = baselineProfileRule.collect(
        packageName = "com.example.app",
        profileBlock = {
            startActivityAndWait()
        }
    )
}
```
Generator dapat berisi interaksi dengan aplikasi Anda di luar startup aplikasi. Hal ini memungkinkan Anda mengoptimalkan performa runtime aplikasi, seperti men-scroll daftar, menjalankan animasi, dan menavigasi dalam Activity. Lihat contoh lain pengujian yang menggunakan @BaselineProfileRule untuk meningkatkan kualitas perjalanan penting pengguna.
Menambahkan plugin Gradle Profil Dasar Pengukuran (libs.plugins.androidx.baselineprofile). Plugin ini memudahkan pembuatan Profil Dasar Pengukuran dan mengelolanya di masa mendatang.
Untuk membuat Profil Dasar Pengukuran, jalankan tugas Gradle :app:generateBaselineProfile atau :app:generateVariantBaselineProfile di terminal.

Jalankan generator sebagai pengujian berinstrumen pada perangkat fisik yang di-root, emulator, atau Perangkat yang Dikelola Gradle. Jika Anda menggunakan Perangkat yang Dikelola Gradle, setel aosp sebagai systemImageSource, karena Anda memerlukan akses root untuk generator Profil Dasar Pengukuran.

Catatan: Saat menggunakan Jetpack Macrobenchmark 1.2.0-alpha06 dan yang lebih baru, Anda dapat membuat Profil Dasar Pengukuran di perangkat yang menjalankan Android 13 (API 33) dan yang lebih baru tanpa akses root.

Di akhir tugas pembuatan, Profil Dasar Pengukuran disalin ke app/src/variant/generated/baselineProfiles.

Membuat Profil Dasar Pengukuran baru tanpa template

Sebaiknya, buat Profil Dasar Pengukuran menggunakan template modul Profil Dasar Pengukuran Android Studio (lebih disukai) atau template Macrobenchmark, tetapi Anda juga dapat menggunakan Plugin Gradle Profil Dasar Pengukuran itu sendiri. Untuk membaca selengkapnya tentang plugin Gradle Profil Dasar Pengukuran, lihat Mengonfigurasi pembuatan Profil Dasar Pengukuran.

Berikut cara membuat Profil Dasar Pengukuran menggunakan plugin Gradle Profil Dasar Pengukuran secara langsung:

Buat modul com.android.test baru—misalnya, :baseline-profile.

Konfigurasi file build.gradle.kts untuk :baseline-profile:

Terapkan plugin androidx.baselineprofile.
Pastikan targetProjectPath mengarah ke modul :app.
Secara opsional, tambahkan perangkat yang dikelola Gradle (GMD). Dalam contoh berikut, GMD-nya adalah pixel6Api31. Jika tidak ditentukan, plugin akan menggunakan perangkat yang terhubung, baik yang diemulasikan maupun fisik.
Terapkan konfigurasi yang Anda inginkan, seperti yang ditunjukkan dalam contoh berikut.

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
}

Buat pengujian Profil Dasar Pengukuran dalam modul pengujian :baseline-profile. Contoh berikut adalah pengujian yang memulai aplikasi dan menunggu tidak ada aktivitas.

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

Update file build.gradle.kts di modul aplikasi, misalnya :app.

Terapkan plugin androidx.baselineprofile.
Tambahkan dependensi baselineProfile ke modul :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"))
}

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'
}

Buat profil dengan menjalankan tugas Gradle :app:generateBaselineProfile atau :app:generateVariantBaselineProfile.
Di akhir tugas pembuatan, Profil Dasar Pengukuran disalin ke app/src/variant/generated/baselineProfiles.

Membuat Profil Dasar Pengukuran baru dengan AGP 7.3-7.4

Anda dapat membuat Profil Dasar Pengukuran dengan AGP 7.3-7.4, tetapi sebaiknya upgrade ke setidaknya AGP 8.1 sehingga Anda dapat menggunakan plugin Gradle Profil Dasar Pengukuran dan fitur terbarunya.

Jika Anda perlu membuat Profil Dasar Pengukuran dengan AGP 7.3-7.4, langkah-langkahnya sama seperti langkah untuk AGP 8.1, dengan pengecualian berikut:

Jangan tambahkan plugin Gradle Profil Dasar Pengukuran.
Untuk membuat Profil Dasar Pengukuran, jalankan tugas Gradle ./gradlew [emulator name][flavor][build type]AndroidTest. Misalnya, ./gradlew :benchmark:pixel6Api31BenchmarkAndroidTest.
Anda harus menerapkan aturan Profil Dasar Pengukuran yang dibuat ke kode Anda secara manual.

Menerapkan aturan yang dibuat secara manual

Generator Profil Dasar Pengukuran membuat file teks Format yang Dapat Dibaca Manusia (HRF) di perangkat dan menyalinnya ke mesin host Anda. Untuk menerapkan profil yang dihasilkan ke kode Anda, ikuti langkah-langkah berikut:

Temukan file HRF di folder build modul tempat Anda membuat profil: [module]/build/outputs/managed_device_android_test_additional_output/[device].

Profil mengikuti pola penamaan [class name]-[test method name]-baseline-prof.txt, yang terlihat seperti ini: BaselineProfileGenerator-startup-baseline-prof.txt.
Salin profil yang dihasilkan ke src/main/ dan ganti nama file menjadi baseline-prof.txt.

Catatan: Jika Anda menggunakan versi plugin Android Gradle yang lebih lama dari 8.0, file baseline-prof.txt tidak akan ditunjukkan di tampilan Android pada Android Studio.
Tambahkan dependensi ke library ProfileInstaller di file build.gradle.kts aplikasi Anda untuk mengaktifkan kompilasi Profil Dasar Pengukuran lokal tempat Profil Cloud tidak tersedia. Ini adalah satu-satunya cara untuk melakukan sideload Profil Dasar Pengukuran secara lokal.
```
dependencies {
     implementation("androidx.profileinstaller:profileinstaller:1.4.1")
}
```
Buat versi produksi aplikasi Anda, saat aturan HRF yang berlaku dikompilasi menjadi bentuk biner dan disertakan dalam APK atau AAB. Kemudian, distribusikan aplikasi seperti biasa.

Menjalankan benchmark Profil Dasar Pengukuran

Untuk menjalankan benchmark Profil Dasar Pengukuran, buat konfigurasi Android Instrumented Test Run yang baru dari tindakan gutter yang menjalankan benchmark yang ditentukan dalam file StartupBenchmarks.kt atau StartupBencharks.java. Untuk mempelajari pengujian benchmark lebih lanjut, lihat Membuat class Macrobenchmark dan Mengotomatiskan pengukuran dengan library Macrobenchmark.

**Gambar 3.** Menjalankan Pengujian Android dari tindakan gutter.

Saat Anda menjalankan ini dalam Android Studio, output build akan berisi detail peningkatan kecepatan yang disediakan oleh Profil Dasar Pengukuran:

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

Merekam semua jalur kode yang diperlukan

Dua metrik utama untuk mengukur waktu startup aplikasi adalah sebagai berikut:

Waktu hingga tampilan awal (TTID): Waktu yang diperlukan untuk menampilkan frame pertama UI aplikasi.
Waktu hingga tampilan penuh (TTFD): TTID ditambah waktu untuk menampilkan konten yang dimuat secara asinkron setelah frame awal ditampilkan.

TTFD dilaporkan setelah metode reportFullyDrawn() dari ComponentActivity dipanggil. Jika reportFullyDrawn() tidak pernah dipanggil, TTID akan dilaporkan. Anda mungkin harus menunda saat reportFullyDrawn() dipanggil hingga pemuatan asinkron selesai. Misalnya, jika UI berisi daftar dinamis, seperti RecyclerView atau daftar lambat, daftar ini mungkin diisi oleh tugas latar belakang yang selesai setelah daftar pertama kali digambar, sehingga setelah UI ditandai sebagai sepenuhnya digambar. Dalam kasus tersebut, kode yang berjalan setelah UI mencapai status sepenuhnya digambar tidak disertakan dalam Profil Dasar Pengukuran.

Untuk menyertakan populasi daftar sebagai bagian dari Profil Dasar Pengukuran Anda, dapatkan FullyDrawnReporter dengan menggunakan getFullyDrawnReporter() dan tambahkan reporter ke profil tersebut di kode aplikasi Anda. Rilis reporter setelah tugas latar belakang selesai mengisi daftar. FullyDrawnReporter tidak memanggil metode reportFullyDrawn() hingga semua reporter dirilis. Dengan melakukan ini, Profil Dasar Pengukuran menyertakan jalur kode yang diperlukan untuk mengisi daftar. Tindakan ini tidak mengubah perilaku aplikasi bagi pengguna, tetapi memungkinkan Profil Dasar Pengukuran menyertakan semua jalur kode yang diperlukan.

Jika aplikasi Anda menggunakan Jetpack Compose, gunakan API berikut untuk menunjukkan status yang sepenuhnya digambar:

ReportDrawn menunjukkan bahwa composable Anda langsung siap untuk berinteraksi.
ReportDrawnWhen mengambil predikat, seperti list.count > 0, untuk menunjukkan kapan composable siap berinteraksi.
ReportDrawnAfter mengambil metode penangguhan yang, setelah selesai, menunjukkan bahwa composable Anda siap untuk berinteraksi.

Direkomendasikan untuk Anda

Catatan: teks link ditampilkan saat JavaScript nonaktif
Mengambil metrik Macrobenchmark
Menulis Macrobenchmark
Library JankStats

Sebelumnya

Tentang Profil Dasar Pengukuran

Berikutnya

Membuat Profil Dasar Pengukuran untuk library