Skonfiguruj generowanie profilu podstawowego

Wtyczka Gradle do tworzenia profili bazowych ułatwia generowanie i utrzymywanie profili bazowych. Umożliwia wykonywanie tych czynności:

• Utwórz nowe profile podstawowe dla swojej aplikacji.
• Utwórz nowe profile podstawowe dla swojej biblioteki.
• Dostosowywanie generowania profilu bazowego.

Na tej stronie wyjaśniamy, jak za pomocą wtyczki Gradle do profili bazowych możesz dostosować generowanie profili bazowych.

Wymagania dotyczące wtyczek

• AGP 8.0 lub nowszy
• Zależność od najnowszej wersji wtyczki Gradle

Generowanie profili referencyjnych za pomocą urządzeń zarządzanych przez Gradle

Aby użyć urządzenia zarządzanego przez Gradle (GMD) do wygenerowania profilu podstawowego, dodaj je w konfiguracji build.gradle.kts modułu producenta profilu (prawdopodobnie modułu testowego :baselineprofile), jak pokazano w tym przykładzie:

android {
   testOptions.managedDevices.devices {
       create<com.android.build.api.dsl.ManagedVirtualDevice>("pixel6Api31") {
           device = "Pixel 6"
           apiLevel = 31
           systemImageSource = "aosp"
       }
   }
}

android {
   testOptions.managedDevices.devices {
       pixel6Api31(ManagedVirtualDevice) {
           device 'Pixel 6'
           apiLevel = 31
           systemImageSource 'aosp'
       }
   }
}

Użyj narzędzia GMD do wygenerowania profili referencyjnych, dodając je do konfiguracji wtyczki Gradle. Aby to zrobić, w modułach testowych build.gradle.kts dodaj następujący kod do build.gradle.kts::baselineprofile

baselineProfile {
    managedDevices += "pixel6Api31"
}

baselineProfile {
    managedDevices = ['pixel6Api31']
}

Jeśli do generowania profili bazowych używasz GMD, w module testowym :baselineprofile ustaw wartość parametru useConnectedDevices na false:

baselineProfile {
    ...
    useConnectedDevices = false
}

baselineProfile {
    ...
    useConnectedDevices false
}

Generowanie profili podstawowych dla różnych wariantów

Profile bazowe możesz generować dla poszczególnych wariantów lub smaków albo jako pojedynczy plik do wykorzystania we wszystkich wariantach. Aby kontrolować to zachowanie, użyj ustawienia scalania, jak pokazano w następnym przykładzie w build.gradle.kts w aplikacji lub module biblioteki.

baselineProfile {
    mergeIntoMain = true
}

baselineProfile {
    mergeIntoMain true
}

Aby połączyć wygenerowane profile wszystkich wariantów w jeden profil, ustaw wartość parametru mergeIntoMain na true. Gdy to ustawienie ma wartość true, nie można generować profili bazowych na podstawie wariantów, więc jest tylko jedno zadanie Gradle o nazwie generateBaselineProfile. Profil jest generowany w pliku src/main/generated/baselineProfiles.

Aby wyłączyć scalanie i mieć jeden profil na wariant, ustaw wartość mergeIntoMain na false. W tym przypadku istnieje wiele zadań Gradle dotyczących poszczególnych wariantów. Jeśli na przykład masz 2 wersje – np. bezpłatną i płatną – oraz jeden typ kompilacji wersji, zadania będą wyglądać tak:

* `generateFreeReleaseBaselineProfile`
* `generatePaidReleaseBaselineProfile`
* `generateReleaseBaselineProfile`

Aby określić sposób scalania dla poszczególnych wariantów, użyj tego kodu:

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain true
        }
    }
}

W powyższym przykładzie warianty, w których flaga ma wartość true, są łączone w src/main/generated/baselineProfiles, a profile wariantów, w których flaga ma wartość false, są przechowywane w folderze src/<variant>/generated/baselineProfiles.

Domyślnie mergeIntoMain ma wartość true w przypadku bibliotek i false w przypadku aplikacji.

automatycznie generować profile bazowe podczas kompilowania nowej wersji;

Możesz skonfigurować generowanie profili bazowych automatycznie przy każdym wydaniu, zamiast ręcznie tworzyć zadanie generateBaselineProfile. W przypadku automatycznego generowania do wersji wydania jest dołączany najbardziej aktualny profil.

Aby włączyć automatyczne generowanie wersji wydania, użyj flagi automaticGenerationDuringBuild:

baselineProfile {
    automaticGenerationDuringBuild = true
}

baselineProfile {
    automaticGenerationDuringBuild true
}

Ustawienie flagi automaticGenerationDuringBuild na true powoduje wygenerowanie nowego profilu podstawowego dla każdego zestawu wersji. Oznacza to, że wykonanie zadania kompilacji kompilacji wersji, takiego jak ./gradlew:app:assembleRelease, powoduje również uruchomienie :app:generateReleaseBaselineProfile, rozpoczęcie testów instrumentacji profilu podstawowego i utworzenie kompilacji profilu podstawowego, na której są one wykonywane. Chociaż automatyczne generowanie pomaga użytkownikom uzyskać największą wydajność, wydłuża też czas kompilacji z powodu podwójnych testów kompilacji i instrumentacji.

Możesz też określić to zachowanie dla każdej odmiany, jak pokazano w tym przykładzie:

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild true
        }
    }
}

W poprzednim przykładzie zadanie generateFreeReleaseBaselineProfile jest wykonywane po uruchomieniu zadania assembleFreeRelease. Jest to przydatne, gdy użytkownik chce mieć np. kompilację dystrybucyjną release, która zawsze generuje profil podczas kompilowania, oraz kompilację releaseWithoutProfile do testów wewnętrznych.

Przechowywanie profili podstawowych w źródłach

Profile podstawowe możesz przechowywać w katalogu źródłowym za pomocą flagi saveInSrc w pliku build.gradle.kts w aplikacji lub module biblioteki:

• true: profil podstawowy jest przechowywany w pliku src/<variant>/generated/baselineProfiles. Umożliwi Ci to zatwierdzenie najnowszego wygenerowanego profilu w przypadku źródeł.
• false: profil podstawowy jest przechowywany w plikach pośrednich w katalogu kompilacji. Dzięki temu podczas zatwierdzania kodu nie zapisujesz najnowszego wygenerowanego profilu.

baselineProfile {
    saveInSrc = true
}

baselineProfile {
    saveInSrc true
}

Możesz też określić to zachowanie dla poszczególnych wariantów:

baselineProfile {
    variants {
        freeRelease {
            saveInSrc = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            saveInSrc true
        }
    }
}

Wyłączanie ostrzeżeń

Domyślnie wtyczka Gradle do profilu podstawowego ostrzega o sytuacjach, które mogą powodować problemy. Aby wyłączyć ostrzeżenia, możesz ustawić odpowiednią opcję na false w pliku build.gradle.kts. Oto opcje ostrzeżenia:

baselineProfile {
    warnings {

        /**
        * Warn when the Android Gradle Plugin version is higher than the max
        * tested one.
        */
        maxAgpVersion = true

        /**
        * Warn when a benchmark or baseline profile variant has been disabled.
        */
        disabledVariants = true

        /**
        * Warn that running `generateBaselineProfile` with AGP 8.0 doesn't
        * support running instrumentation tests for multiple build types at
        * once.
        */
        multipleBuildTypesWithAgp80 = true

        /**
        * Warn when no baseline profiles are generated after running the
        * generate baseline profile command.
        */
        noBaselineProfileRulesGenerated = true

        /**
        * Warn when no startup profiles are generated after running the generate
        * baseline profile command.
        */
        noStartupProfileRulesGenerated = true
    }
}

Filtrowanie reguł profilu

Wtyczka Gradle do profilu podstawowego umożliwia filtrowanie wygenerowanych reguł profilu podstawowego. Jest to szczególnie przydatne w przypadku bibliotek, jeśli chcesz wykluczyć reguły profilu dotyczące klas i metod, które są częścią innych zależności aplikacji przykładowej lub samej biblioteki. Filtry mogą uwzględniać lub wykluczać określone pakiety i klasy. Jeśli określisz tylko wykluczenia, zostaną wykluczone tylko reguły z pasującego profilu podstawowego, a wszystko inne zostanie uwzględnione.

Specyfikacja filtrów może być dowolnym z tych elementów:

• nazwa pakietu kończąca się podwójnym symbolem wieloznacznym, aby pasować do określonego pakietu i wszystkich podrzędnych pakietów; Na przykład com.example.** jest zgodne z com.example.method i com.example.method.bar.
• Nazwa pakietu kończąca się symbolem wieloznacznym, aby pasować tylko do określonego pakietu. Na przykład reguła com.example.* pasuje do com.example.method, ale nie do com.example.method.bar.
• nazwy zajęć pasujące do konkretnej klasy, np. com.example.MyClass;

Poniższe przykłady pokazują, jak uwzględniać i wykluczać konkretne pakiety:

baselineProfile {
    filter {
        include("com.somelibrary.widget.grid.**")
        exclude("com.somelibrary.widget.grid.debug.**")
        include("com.somelibrary.widget.list.**")
        exclude("com.somelibrary.widget.list.debug.**")
        include("com.somelibrary.widget.text.**")
        exclude("com.somelibrary.widget.text.debug.**")
    }
}

baselineProfile {
    filter {
        include 'com.somelibrary.widget.grid.**'
        exclude 'com.somelibrary.widget.grid.debug.**'
        include 'com.somelibrary.widget.list.**'
        exclude 'com.somelibrary.widget.list.debug.**'
        include 'com.somelibrary.widget.text.**'
        exclude 'com.somelibrary.widget.text.debug.**'
    }
}

Dostosuj reguły filtra dla różnych wariantów w ten sposób:

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include("com.myapp.**") }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include("com.myapp.free.**")
            }
        }
        paid {
            filter {
                include("com.myapp.paid.**")
            }
        }
    }
}

// Build-type-specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include 'com.myapp.**' }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include 'com.myapp.free.**'
            }
        }
        paid {
            filter {
                include 'com.myapp.paid.**'
            }
        }
    }
}

// Build-type specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

Możesz też filtrować reguły za pomocą argumentu filterPredicate w BaselineProfileRule.collect(), ale zalecamy użycie wtyczki Gradle, ponieważ zapewnia ona prostszy sposób filtrowania podpakietów i jedno miejsce do konfigurowania całego modułu.

Dostosowywanie typów danych benchmarku i profilu podstawowego

Wtyczka Gradle do tworzenia profilu bazowego tworzy dodatkowe typy kompilacji, aby generować profile i uruchamiać testy porównawcze. Te typy kompilacji mają przedrostek benchmark lub nonMinified. Na przykład w przypadku typu kompilacji release wtyczka tworzy typy kompilacji benchmarkRelease i nonMinifiedRelease. Te typy kompilacji są automatycznie konfigurowane pod kątem konkretnego zastosowania i zazwyczaj nie wymagają dostosowywania. W niektórych przypadkach może być jednak przydatne zastosowanie niektórych opcji niestandardowych, na przykład innej konfiguracji podpisywania.

Typy kompilacji generowane automatycznie możesz dostosowywać za pomocą podzbioru właściwości typu kompilacji. Właściwości, których nie można użyć, są zastępowane. Ten przykład pokazuje, jak dostosować dodatkowe typy kompilacji i które właściwości są zastępowane:

android {
    buildTypes {
        release {
            ...
        }
        create("benchmarkRelease") {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default
            // it's the same as for the `release` build type).
            signingConfig = signingConfigs.getByName("benchmarkRelease")
        }
        create("nonMinifiedRelease") {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.getByName("nonMinifiedRelease")

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't
            // customize the following properties, which are always overridden to
            // avoid breaking Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false
        }
    }
}

android {
    buildTypes {
        release {
            ...
        }
        benchmarkRelease {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default it's the
            // same as for the `release` build type.)
            signingConfig = signingConfigs.benchmarkRelease
        }
        nonMinifiedRelease {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.nonMinifiedRelease

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't use
            // the following properties, which are always overridden to avoid breaking
            // Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false       
        }
    }
}

Uwagi dodatkowe

Podczas tworzenia profili referencyjnych należy pamiętać o tych kwestiach:

• Zkompilowane profile bazowe muszą mieć rozmiar mniejszy niż 1,5 MB. Nie dotyczy to formatu tekstu w plikach źródłowych, które są zwykle znacznie większe przed skompilowaniem. Sprawdź rozmiar binarnego profilu referencyjnego, wyszukując go w elementach wyjściowych w folderze assets/dexopt/baseline.prof (w przypadku pliku APK) lub BUNDLE-METADATA/com.android.tools.build.profiles/baseline.prof (w przypadku pakietu aplikacji na Androida).

• Ogólne reguły, które kompilują zbyt dużą część aplikacji, mogą spowolnić jej uruchamianie ze względu na zwiększony dostęp do dysku. Jeśli dopiero zaczynasz korzystać z profili referencyjnych, nie musisz się tym przejmować. Jednak w zależności od aplikacji oraz rozmiaru i liczby ścieżek dodanie zbyt dużej ich liczby może spowodować nieoptymalną skuteczność. Testuj wydajność aplikacji, korzystając z różnych profili, i sprawdzaj, czy po dodaniu nowych elementów nie nastąpiło pogorszenie wydajności.

Ćwiczenia z programowania