Tworzenie profili podstawowych

Automatycznie generuj profile dla każdej wersji aplikacji za pomocą biblioteki Jetpack Macrobenchmark i BaselineProfileRule. Zalecamy używanie wersji com.android.tools.build:gradle:8.0.0 lub nowszej, która zapewnia ulepszenia kompilacji podczas korzystania z profili podstawowych.

Oto ogólne kroki tworzenia nowego profilu podstawowego:

  1. Skonfiguruj moduł profilu podstawowego.
  2. Określ test JUnit, który pomoże wygenerować profile podstawowe.
  3. Dodaj główne ścieżki użytkownika, które chcesz optymalizować.
  4. Wygeneruj profil podstawowy.

Po wygenerowaniu profilu podstawowego przeprowadź test porównawczy na urządzeniu fizycznym, aby zmierzyć wzrost szybkości.

Tworzenie nowego profilu podstawowego w AGP 8.2 lub nowszym

Najprostszym sposobem utworzenia nowego profilu podstawowego jest użycie szablonu modułu profilu podstawowego, który jest dostępny od Androida Studio Iguana i Androida Gradle Plugin (AGP) 8.2.

Szablon modułu Generator profili bazowych Android Studio automatyzuje tworzenie nowego modułu do generowania i testowania profili bazowych. Uruchomienie szablonu generuje większość typowej konfiguracji kompilacji, profilu podstawowego i kodu weryfikacyjnego. Szablon tworzy kod do generowania i testowania profili bazowych, aby mierzyć uruchamianie aplikacji.

Konfigurowanie modułu profilu podstawowego

Aby uruchomić szablon modułu Profil podstawowy, wykonaj te czynności:

  1. Wybierz Plik > Nowy > Nowy moduł.
  2. Wybierz szablon Generator profilu podstawowego w panelu Szablony i skonfiguruj go:
    Ilustracja 1. Szablon modułu generatora profilu podstawowego.

    Szablon zawiera te pola:

    • Aplikacja docelowa: określa, dla której aplikacji jest generowany profil podstawowy. Jeśli w projekcie masz tylko 1 moduł aplikacji, na tej liście znajduje się tylko 1 element.
    • Nazwa modułu: nazwa, którą chcesz nadać tworzonemu modułowi profilu podstawowego.
    • Nazwa pakietu: nazwa pakietu, który chcesz przypisać do modułu profilu podstawowego.
    • Język: czy wygenerowany kod ma być w języku Kotlin czy Java.
    • Język konfiguracji kompilacji: czy w skryptach konfiguracji kompilacji chcesz używać języka Kotlin Script (KTS) czy Groovy.
    • Używaj urządzenia zarządzanego przez Gradle: czy do testowania aplikacji używasz urządzeń zarządzanych przez Gradle.
  3. Kliknij Zakończ, aby utworzyć nowy moduł. Jeśli używasz kontroli źródła, może pojawić się prośba o dodanie nowo utworzonych plików modułu do kontroli źródła.

Definiowanie generatora profilu podstawowego

Nowo utworzony moduł zawiera testy generowania i testowania profilu bazowego oraz testowania tylko podstawowego uruchamiania aplikacji. Zalecamy rozszerzenie tych informacji o CUJ i zaawansowane procesy uruchamiania. Upewnij się, że wszystkie testy związane z uruchamianiem aplikacji znajdują się w bloku rule z ustawioną wartością includeInStartupProfile na true. Z kolei, aby uzyskać optymalną wydajność, upewnij się, że wszystkie testy niezwiązane z uruchamianiem aplikacji nie są uwzględnione w profilu uruchamiania. Optymalizacje uruchamiania aplikacji służą do definiowania specjalnej części profilu podstawowego, zwanej profilem uruchamiania.

Ułatwia to utrzymanie, jeśli wyodrębnisz te CUJ poza wygenerowany profil podstawowy i kod testu porównawczego, aby można było ich używać w obu przypadkach. Oznacza to, że zmiany w CUJ są stosowane w spójny sposób.

Generowanie i instalowanie profilu podstawowego

Szablon modułu profilu podstawowego dodaje nową konfigurację uruchamiania, która umożliwia wygenerowanie profilu podstawowego. Jeśli używasz wersji produktu, Android Studio tworzy wiele konfiguracji uruchamiania, dzięki czemu możesz generować osobne profile podstawowe dla każdej wersji.

Konfiguracja uruchomienia generowania profilu podstawowego.
Rysunek 2. Uruchomienie tej konfiguracji spowoduje wygenerowanie profilu podstawowego.

Po zakończeniu działania konfiguracji Generate Baseline Profile (Generuj profil podstawowy) wygenerowany profil podstawowy jest kopiowany do pliku src/variant/generated/baselineProfiles/baseline-prof.txt w profilowanym module. Opcje wariantu to typ kompilacji wersji lub wariant kompilacji obejmujący typ kompilacji wersji.

Wygenerowany profil podstawowy został pierwotnie utworzony w build/outputs. Pełna ścieżka zależy od wariantu lub wersji aplikacji, która jest profilowana, oraz od tego, czy do profilowania używasz urządzenia zarządzanego przez Gradle czy podłączonego urządzenia. Jeśli użyjesz nazw używanych przez kod i konfiguracje kompilacji wygenerowane przez szablon, profil podstawowy zostanie utworzony w pliku build/outputs/managed_device_android_test_additional_output/nonminifiedrelease/pixel6Api31/BaselineProfileGenerator_generate-baseline-prof.txt. Prawdopodobnie nie będziesz musiał(-a) bezpośrednio korzystać z tej wersji wygenerowanego profilu podstawowego, chyba że ręcznie skopiujesz go do modułów docelowych (nie jest to zalecane).

Tworzenie nowego profilu podstawowego za pomocą AGP 8.1

Jeśli nie możesz użyć szablonu modułu profilu podstawowego, użyj szablonu modułu testu porównawczego na poziomie makro i wtyczki Gradle profilu podstawowego, aby utworzyć nowy profil podstawowy. Zalecamy korzystanie z tych narzędzi od Androida Studio Giraffe i AGP 8.1.

Aby utworzyć nowy profil podstawowy za pomocą szablonu modułu Macrobenchmark i wtyczki Gradle Baseline Profile:

  1. Skonfiguruj moduł Macrobenchmark w projekcie Gradle.
  2. Zdefiniuj nową klasę o nazwie BaselineProfileGenerator: 
    class BaselineProfileGenerator {
    @get:Rule
    val baselineProfileRule = BaselineProfileRule()

    @Test
    fun startup() = baselineProfileRule.collect(
        packageName = "com.example.app",
        profileBlock = {
            startActivityAndWait()
        }
    )
}

    Generator może zawierać interakcje z aplikacją inne niż jej uruchomienie. Dzięki temu możesz zoptymalizować wydajność działania aplikacji, np. przewijanie list, uruchamianie animacji i poruszanie się w Activity. Zobacz inne przykłady testów, które wykorzystują @BaselineProfileRule do ulepszania najważniejszych ścieżek użytkowników.

  3. Dodaj wtyczkę Gradle Baseline Profile (libs.plugins.androidx.baselineprofile). Ułatwia ona generowanie profili bazowych i zarządzanie nimi w przyszłości.

  4. Aby wygenerować profil podstawowy, uruchom zadania Gradle :app:generateBaselineProfile lub :app:generateVariantBaselineProfile w terminalu.

    Uruchom generator jako test z instrumentacją na urządzeniu fizycznym z dostępem do roota, emulatorze lub urządzeniu zarządzanym przez Gradle. Jeśli używasz urządzenia zarządzanego przez Gradle, ustaw aosp jako systemImageSource, ponieważ generator profilu podstawowego wymaga dostępu do roota.

    Po zakończeniu zadania generowania profil podstawowy jest kopiowany do app/src/variant/generated/baselineProfiles.

Tworzenie nowego profilu podstawowego bez szablonów

Zalecamy utworzenie profilu podstawowego za pomocą szablonu modułu profilu podstawowego w Android Studio (preferowane) lub szablonu testu Macrobenchmark, ale możesz też użyć samego wtyczki Gradle do profilu podstawowego. Więcej informacji o wtyczce Gradle do profilu podstawowego znajdziesz w artykule Konfigurowanie generowania profilu podstawowego.

Aby utworzyć profil podstawowy za pomocą wtyczki Gradle Baseline Profile:

  1. Utwórz nowy moduł com.android.test, np. :baseline-profile.

  2. Skonfiguruj plik build.gradle.kts dla usługi :baseline-profile:

    1. Zastosuj wtyczkę androidx.baselineprofile.
    2. Sprawdź, czy targetProjectPath wskazuje moduł :app.
    3. Opcjonalnie dodaj urządzenie zarządzane przez Gradle. W tym przykładzie jest to pixel6Api31. Jeśli nie zostanie określone, wtyczka użyje podłączonego urządzenia, emulowanego lub fizycznego.
    4. Zastosuj wybraną konfigurację, jak pokazano w tym przykładzie.

    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. Utwórz test profilu podstawowego w :baseline-profilemodule testowym. Poniżej znajdziesz przykład testu, który uruchamia aplikację i czeka na jej bezczynność.

    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. Zaktualizuj plik build.gradle.kts w module aplikacji, np. :app.

    1. Zastosuj wtyczkę androidx.baselineprofile.
    2. Dodaj zależność baselineProfile do modułu :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'
}

  5. Wygeneruj profil, uruchamiając zadania Gradle :app:generateBaselineProfilelub :app:generateVariantBaselineProfile.

  6. Po zakończeniu zadania generowania profil podstawowy jest kopiowany do app/src/variant/generated/baselineProfiles.

Tworzenie nowego profilu podstawowego za pomocą AGP w wersji 7.3–7.4

Profile bazowe można generować za pomocą AGP 7.3–7.4, ale zdecydowanie zalecamy przejście na co najmniej AGP 8.1, aby móc korzystać z wtyczki Gradle do profilu bazowego i jej najnowszych funkcji.

Jeśli chcesz utworzyć profile podstawowe za pomocą AGP 7.3–7.4, wykonaj te same czynności co w przypadku AGP 8.1, z tymi wyjątkami:

Ręczne stosowanie wygenerowanych reguł

Generator profilu podstawowego tworzy na urządzeniu plik tekstowy w formacie HRF (Human Readable Format) i kopiuje go na komputer hosta. Aby zastosować wygenerowany profil w kodzie:

  1. Znajdź plik HRF w folderze kompilacji modułu, w którym generujesz profil:[module]/build/outputs/managed_device_android_test_additional_output/[device]

    Profile są zgodne ze wzorcem nazewnictwa [class name]-[test method name]-baseline-prof.txt, który wygląda tak: BaselineProfileGenerator-startup-baseline-prof.txt.

  2. Skopiuj wygenerowany profil do src/main/ i zmień nazwę pliku na baseline-prof.txt.

  3. Dodaj zależność do biblioteki ProfileInstaller w pliku build.gradle.kts aplikacji, aby włączyć lokalną kompilację profilu podstawowego, gdy profile w chmurze nie są dostępne. To jedyny sposób na lokalne wczytanie profilu podstawowego.

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

  4. Zbuduj wersję produkcyjną aplikacji, podczas gdy zastosowane reguły HRF są kompilowane do postaci binarnej i dołączane do pliku APK lub AAB. Następnie rozpowszechnij aplikację w zwykły sposób.

Analiza porównawcza profilu podstawowego

Aby porównać profil podstawowy z testem porównawczym, utwórz nową konfigurację testu z instrumentacją na Androida, korzystając z działania w marginesie, które wykonuje testy porównawcze zdefiniowane w pliku StartupBenchmarks.kt lub StartupBencharks.java. Więcej informacji o testach porównawczych znajdziesz w artykułach Tworzenie klasy Macrobenchmark i Automatyzowanie pomiarów za pomocą biblioteki Macrobenchmark.

Rysunek 3. Uruchom testy Androida z poziomu paska bocznego.

Gdy uruchomisz to w Android Studio, dane wyjściowe kompilacji będą zawierać szczegóły dotyczące poprawy szybkości, jaką zapewnia profil bazowy:

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

Rejestrowanie wszystkich wymaganych ścieżek kodu

Dwa kluczowe wskaźniki pomiaru czasu uruchamiania aplikacji to:

Czas do początkowego wyświetlenia (TTID)
Czas potrzebny na wyświetlenie pierwszej klatki interfejsu aplikacji.
Czas do pełnego wyświetlenia (TTFD)
TTID plus czas wyświetlania treści, które są wczytywane asynchronicznie po wyświetleniu pierwszej klatki.

TTFD jest zgłaszany po wywołaniu metody reportFullyDrawn() interfejsu ComponentActivity. Jeśli wywołanie funkcji reportFullyDrawn() nigdy nie nastąpi, zamiast tego zostanie zgłoszony identyfikator TTID. Może być konieczne opóźnienie wywołania funkcji reportFullyDrawn() do momentu zakończenia ładowania asynchronicznego. Jeśli np. interfejs zawiera dynamiczną listę, taką jak RecyclerView lub lazy list, może ona być wypełniana przez zadanie w tle, które kończy się po pierwszym narysowaniu listy, a więc po oznaczeniu interfejsu jako w pełni narysowanego. W takich przypadkach kod, który jest uruchamiany po osiągnięciu przez interfejs stanu pełnego wyrenderowania, nie jest uwzględniany w profilu podstawowym.

Aby uwzględnić zapełnianie listy w profilu podstawowym, uzyskaj obiekt FullyDrawnReporter, używając funkcji getFullyDrawnReporter(), i dodaj do niego reportera w kodzie aplikacji. Zwolnij reportera, gdy zadanie w tle zakończy wypełnianie listy. Funkcja FullyDrawnReporter nie wywołuje metody reportFullyDrawn(), dopóki nie zostaną zwolnione wszystkie funkcje raportujące. Dzięki temu profil podstawowy zawiera ścieżki kodu wymagane do wypełnienia listy. Nie zmienia to działania aplikacji dla użytkownika, ale umożliwia profilowi podstawowemu uwzględnienie wszystkich niezbędnych ścieżek kodu.

Jeśli Twoja aplikacja korzysta z Jetpack Compose, użyj tych interfejsów API, aby wskazać stan pełnego wyrenderowania:

  • ReportDrawn oznacza, że komponent jest od razu gotowy do interakcji.
  • ReportDrawnWhen przyjmuje predykat, np. list.count > 0, aby wskazać, kiedy komponent jest gotowy do interakcji.
  • ReportDrawnAfter przyjmuje metodę zawieszającą, która po zakończeniu wskazuje, że kompozycja jest gotowa do interakcji.
Wstecz
Informacje o profilach podstawowych
Dalej
Tworzenie profili podstawowych dla biblioteki