Tworzenie profili podstawowych

Automatycznie generuj profile dla każdej wersji aplikacji za pomocą pakietu Jetpack biblioteka Macrobenchmark, BaselineProfileRule. Zalecamy używaj wersji com.android.tools.build:gradle:8.0.0 lub nowszej, która jest dostępna w ramach kompilacji w przypadku korzystania z profili podstawowych.

Poniżej znajdziesz ogólne instrukcje tworzenia nowego profilu podstawowego:

  1. Skonfiguruj moduł Baseline Profile.
  2. Zdefiniuj test JUnit, który pomaga generować profile podstawowe.
  3. Dodaj najważniejsze ścieżki użytkownika, które chcesz zoptymalizować.
  4. Wygeneruj profil podstawowy.

Po wygenerowaniu profilu podstawowego przetestuj go na urządzeniu fizycznym, aby: mierzyć poprawę szybkości.

Utwórz nowy profil podstawowy z pakietem AGP w wersji 8.2 lub nowszej

Najłatwiejszym sposobem utworzenia nowego profilu podstawowego jest użycie profilu podstawowego szablon modułu, dostępny od Androida Studio Iguana i Androida Gradle Wtyczka (AGP) 8.2

Szablon modułu generatora profili Baseline w Android Studio automatyzuje tworzenia nowego modułu do generowania test porównawczy Profile Baseline. Uruchamianie szablonu generuje większość typowej kompilacji konfiguracji profilu, generowania profilu Baseline i kodu weryfikacyjnego. Szablon tworzy kod do generowania i testowania porównawczych profili podstawowych w celu pomiaru aplikacji podczas uruchamiania.

Konfigurowanie modułu profilu bazowego

Aby uruchomić szablon modułu profilu bazowego, wykonaj następujące czynności:

  1. Wybierz Plik > Nowe > Nowy moduł
  2. Wybierz szablon Baseline Profile Generator. Szablony i skonfiguruj go:
    Rysunek 1. Szablon modułu Baseline Profile Generator.

    Pola w szablonie to:

    • Aplikacja docelowa: określa, dla której aplikacji ma zostać wygenerowany profil podstawowy. Jeśli w projekcie masz tylko jeden moduł aplikacji, na tej liście jest tylko 1 element.
    • Module name (Nazwa modułu): nazwa, jakiej chcesz używać dla modułu podstawowego profilu. w jej tworzeniu.
    • Package name (Nazwa pakietu): nazwa pakietu dla profilu podstawowego. .
    • Language (Język): określa, czy wygenerowany kod ma być Kotlin, czy Java.
    • Język konfiguracji kompilacji: określa, czy chcesz używać Kotlin. Skrypt (KTS) lub Groovy w skryptach konfiguracji kompilacji.
    • Używaj urządzenia zarządzanego przez Gradle: niezależnie od tego, czy na urządzeniach zarządzanych przez Gradle, przetestować aplikację.
  3. Kliknij Zakończ. Nowy moduł zostanie utworzony. Jeśli używasz źródła może zostać wyświetlony monit o dodanie nowo utworzonych plików modułu do pliku źródłowego .

Zdefiniuj generator profilu podstawowego

Nowo utworzony moduł zawiera testy służące do generowania i testowania Profil bazowy i testowanie tylko podstawowego uruchamiania aplikacji. Zalecamy wzbogacenie w tym klientów głównych i zaawansowanych procesów startupów. Upewnij się, że wszystkie testy związane ze uruchamianiem aplikacji są w bloku rule z ustawionym includeInStartupProfile do: true; I na odwrót, dla uzyskania optymalnej skuteczności upewnij się, że żadne testy nie związane ze uruchamianiem aplikacji nie są uwzględniane w profilu startowym. Uruchamianie aplikacji służą do definiowania specjalnej części profilu bazowego nazywanej Profil startowy.

Wyodrębnianie tych głównych celów użytkowników poza wygenerowanymi Profil bazowy i kod porównawczy, aby można było ich używać w obu tych przypadkach. Ten co oznacza, że zmiany w głównych tagach użytkownika są stosowane konsekwentnie.

Wygeneruj i zainstaluj profil bazowy

Szablon modułu profilu Baseline Profile dodaje nową konfigurację uruchamiania, która ma zostać wygenerowana do profilu podstawowego. Jeśli używasz różnych rodzajów produktów, Android Studio utworzy wiele konfiguracji uruchamiania, aby można było generować oddzielne profile podstawowe dla każdego smaku.

Konfiguracja uruchomienia generowania profilu bazowego.
Rysunek 2. Uruchamianie tej konfiguracji powoduje wygenerowanie wartości odniesienia Profil

Po zakończeniu konfigurowania Wygeneruj profil podstawowy zostanie on skopiowany wygenerowany profil bazowy src/variant/generated/baselineProfiles/baseline-prof.txt w profilowanym module. Dostępne warianty to: typu kompilacji wydania lub wariantu kompilacji obejmującej dany typ kompilacji.

Wygenerowany profil podstawowy został pierwotnie utworzony w zadaniu build/outputs. pełna ścieżka jest określana przez wariant lub rodzaj profilowanej aplikacji; niezależnie od tego, czy do profilowania używasz urządzenia zarządzanego przez Gradle czy połączonego urządzenia. Jeśli użyj nazw używanych przez kod i konfiguracje kompilacji wygenerowane przez profil podstawowy jest tworzony build/outputs/managed_device_android_test_additional_output/nonminifiedrelease/pixel6Api31/BaselineProfileGenerator_generate-baseline-prof.txt. Prawdopodobnie nie muszą bezpośrednio korzystać z tej wersji wygenerowanego profilu bazowego chyba że ręcznie kopiujesz go do modułów docelowych (niezalecane).

Tworzenie nowego profilu podstawowego z pakietem AGP 8.1

Jeśli nie możesz skorzystać z Szablon modułu profilu bazowego, użyj parametru Szablon modułu Macrobenchmark i wtyczki do Gradle profilu Baseline do utworzenia nowego profilu podstawowego. Zalecamy korzystanie z tych narzędzi na Androidzie Studio Giraffe i AGP 8.1.

Oto kroki, które należy wykonać, aby utworzyć nowy profil bazowy za pomocą wartości porównawczej szablon modułu i wtyczka do Gradle profilu Baseline:

  1. Ustaw moduł analizy porównawczej 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 też obejmować interakcje z aplikacją poza jej uruchomieniem. Pozwala to zoptymalizować wydajność aplikacji w czasie działania aplikacji, np. listy przewijania, wyświetlania animacji i poruszania się w obrębie Activity Zobacz inne przykłady testów, w których użyto parametru @BaselineProfileRule do które pozwalają poprawić najważniejsze ścieżki użytkowników.

  3. Dodaj wtyczkę do Gradle profilu Baseline (libs.plugins.androidx.baselineprofile). Dzięki wtyczce aby generować profile podstawowe i utrzymywać je w przyszłości.

  4. Aby wygenerować profil podstawowy, uruchom polecenie :app:generateBaselineProfile lub :app:generateVariantBaselineProfile zadań Gradle w złącze.

    Uruchamianie generatora jako testu instrumentowanego na urządzeniu fizycznym z dostępem do roota, emulatorze Urządzenie zarządzane Gradle. Jeśli używasz urządzenia zarządzanego przez Gradle, ustaw aosp jako systemImageSource, ponieważ potrzebujesz roota generatora profilu Baseline.

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

Utwórz nowy profil podstawowy bez szablonów

Zalecamy utworzenie profilu Baseline za pomocą Android Studio. Szablon modułu profilu bazowego (preferowane) lub szablonu analizy porównawczej, ale możesz używać też wtyczki do obsługi Gradle profilu Baseline. Aby dowiedzieć się więcej na temat Wtyczka do obsługi profilu Baseline do Gradle, patrz Skonfiguruj generowanie profilu Baseline.

Oto jak utworzyć profil Baseline za pomocą wtyczki Baseline Profile Gradle bezpośrednio:

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

  2. Skonfiguruj plik build.gradle.kts pod kątem :baseline-profile:

    1. Zastosuj wtyczkę androidx.baselineprofile.
    2. Upewnij się, że targetProjectPath wskazuje :app.
    3. Opcjonalnie dodaj parametr Urządzenie zarządzane przez Gradle (GMD). W tym przykładzie jest to pixel6Api31. Jeśli nie podasz żadnej wartości, wtyczka korzysta z podłączonego urządzenia – emulowanego lub fizycznego.
    4. Zastosuj wybraną konfigurację, jak pokazano poniżej przykład.

    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
}

    Odlotowe

    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-profile z modułu testowego. Poniżej znajduje się przykład testu, który uruchamia aplikację i czeka za bezczynności.

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

    Odlotowe

    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 :app:generateBaselineProfile lub :app:generateVariantBaselineProfile zadań Gradle.

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

Utwórz nowy profil podstawowy z AGP 7.3-7.4

Istnieje możliwość wygenerowania profili podstawowych z AGP 7.3-7.4, ale zdecydowanie zalecamy uaktualnienie go do wersji AGP 8.1 lub nowszej, aby można było korzystać z profilu podstawowego. Wtyczka Gradle i jej najnowsze funkcje.

Jeśli chcesz utworzyć profile podstawowe z AGP 7.3-7.4, czynności są takie same zgodnie z procedurą AGP 8.1 z tymi wyjątki:

Ręcznie stosuj wygenerowane reguły

Generator profilu Baseline tworzy plik tekstowy HRF (Huan Readable Format). na urządzeniu i skopiuje go na komputer hosta. Aby zastosować wygenerowany profil w kodzie, wykonaj te czynności:

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

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

  2. Skopiuj wygenerowany profil do usługi 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ć lokalny profil bazowy kompilacja tam, gdzie profile Google Cloud są niedostępne. To jest to jedyny sposób lokalnego wczytywania profilu podstawowego.

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

  4. Utwórz wersję produkcyjną aplikacji, a zastosowane reguły HRF będą skompilowane do postaci binarnej i dołączone do pakietu APK lub pakietu AAB. Następnie rozpowszechnij do aplikacji.

Przeprowadź analizę profilu bazowego

Aby porównać swój profil Baseline, utwórz nowe narzędzie Android Instrumented Test Run z konfiguracji rynien, które wykonuje testy porównawcze zdefiniowane w plik StartupBenchmarks.kt lub StartupBencharks.java. Więcej informacji o analizie porównawczej można znaleźć w artykule o tworzeniu makroporównań zajęcia i Automatyzacja pomiarów za pomocą Macrobenchmark Biblioteka.

Rysunek 3. Uruchamiaj Testy Androida bezpośrednio w rynku działania.

Gdy uruchomisz to w Android Studio, dane wyjściowe kompilacji będą zawierać szczegóły ulepszenia szybkości działania profilu podstawowego:

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

Przechwytywanie wszystkich wymaganych ścieżek kodu

Oto 2 kluczowe dane związane z mierzeniem czasu uruchamiania aplikacji:

Czas do początkowego wyświetlenia (TTID)
Czas potrzebny do wyświetlenia pierwszej klatki interfejsu aplikacji.
Czas do pełnego wyświetlenia (TTFD)
TTID plus czas do wyświetlenia treści ładowanych asynchronicznie po wyświetleniu pierwszej klatki.

Funkcja TTFD jest raportowana, gdy reportFullyDrawn() funkcji ComponentActivity . Jeśli funkcja reportFullyDrawn() nie zostanie wywołana, funkcja TTID zostanie zgłoszona . Może być konieczne opóźnienie połączenia z numerem reportFullyDrawn() do po ładowanie asynchroniczne zostało zakończone. Jeśli na przykład interfejs zawiera dynamiczne lista, np. RecyclerView lub leniwa , lista może być zapełniona tłem zadanie, które zostaje wykonane po pierwszym narysowaniu listy, więc także po interfejsie jest oznaczony jako w całości narysowany. W takich przypadkach kod uruchamiany po osiągnięciu przez interfejs użytkownika w pełni narysowany stan nie jest uwzględniony w profilu podstawowym.

Aby uwzględnić tę populację w profilu podstawowym, pobierz FullyDrawnReporter za pomocą getFullyDrawnReporter(). i dodaj do niego w kodzie aplikacji. Puść reportera po zadanie w tle zakończy zapełnianie listy. FullyDrawnReporter: wywoływać metodę reportFullyDrawn() aż do zwolnienia wszystkich osób zgłaszających. Poprzez działanie to profil Baseline zawiera ścieżki kodu wymagane do zapełnienia listy. Nie zmienia to zachowania aplikacji u użytkownika, ale umożliwia grupie odniesienia Profil obejmuje wszystkie niezbędne ścieżki kodu.

Jeśli Twoja aplikacja używa Jetpack Compose, skorzystaj z tych interfejsów API, aby wskazuje stan w pełni wyrysowany:

  • ReportDrawn wskazuje, że funkcja kompozycyjna jest od razu gotowa do interakcji.
  • ReportDrawnWhen używa predykatu, np. list.count > 0, aby wskazać, kiedy Element kompozycyjny jest gotowy do interakcji.
  • ReportDrawnAfter przyjmuje metodę zawieszenia, która po zakończeniu wskazuje, Element kompozycyjny jest gotowy do interakcji.
. .
Wstecz
Informacje o profilach podstawowych
Dalej
Tworzenie profili podstawowych dla biblioteki