Skonfiguruj generowanie profilu podstawowego

Wtyczka Gradle profilu podstawowego ułatwia generowanie i utrzymywanie profili podstawowych. Pomaga wykonać następujące zadania:

• Utwórz nowe profile podstawowe dla aplikacji.
• Utwórz nowe profile podstawowe dla swojej biblioteki
• Dostosuj generowanie profilu podstawowego.

Na tej stronie dowiesz się, jak za pomocą wtyczki Gradle profilu Baseline dostosować generowanie profili bazowych.

Wymagania dotyczące wtyczek

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

Wygeneruj profile bazowe za pomocą urządzeń zarządzanych przez Gradle

Aby użyć urządzenia zarządzanego Gradle (GMD) do wygenerowania profilu podstawowego, dodaj go w konfiguracji build.gradle.kts modułu producenta profilu (prawdopodobnie modułu testowego :baselineprofile), jak pokazano w poniższym 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 GMD do wygenerowania profili bazowych poprzez dodanie ich do konfiguracji wtyczki Gradle profilu bazowego w następujący sposób:

baselineProfile {
    managedDevices += "pixel6Api31"
}

baselineProfile {
    managedDevices = ['pixel6Api31']
}

Jeśli używasz GMD do generowania profili podstawowych, ustaw useConnectedDevices na false:

baselineProfile {
    ...
    useConnectedDevices = false
}

baselineProfile {
    ...
    useConnectedDevices false
}

Generowanie profili bazowych dla różnych wariantów

Możesz generować profile bazowe dla wariantu, smaku lub pojedynczego pliku do wykorzystania we wszystkich wariantach. Możesz kontrolować to zachowanie za pomocą ustawienia scalania, jak pokazano w poniższym przykładzie.

baselineProfile {
    mergeIntoMain = true
}

baselineProfile {
    mergeIntoMain true
}

Aby scalić wygenerowane profile dla wszystkich wersji w jeden profil, ustaw mergeIntoMain na true. Gdy to ustawienie ma wartość true, nie można generować profili bazowych dla poszczególnych wariantów, dlatego istnieje jedno zadanie Gradle o nazwie generateBaselineProfile. Dane wyjściowe profilu: src/main/generated/baselineProfiles.

Aby wyłączyć scalanie i mieć po 1 profilu na wariant, ustaw mergeIntoMain na false. W takim przypadku istnieje wiele zadań Gradle specyficznych dla wariantów. Jeśli na przykład mamy 2 rodzaje – np. bezpłatną i płatną – oraz jeden typ kompilacji wersji, to zadania będą takie:

* `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 poprzednim przykładzie warianty, w których flaga jest ustawiona na true, zostały scalone w elementy src/main/generated/baselineProfiles, a profile wariantów, dla których flaga jest ustawiona na false, są przechowywane w folderze src/<variant>/generated/baselineProfiles.

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

Automatycznie generuj profile bazowe podczas tworzenia nowej wersji

Możesz skonfigurować profile podstawowe, aby były generowane automatycznie przy każdej kompilacji wersji, zamiast ręcznie używać zadania generateBaselineProfile. Dzięki automatycznemu generowaniu w kompilacji wersji dostępny jest najnowszy profil.

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

baselineProfile {
    automaticGenerationDuringBuild = true
}

baselineProfile {
    automaticGenerationDuringBuild true
}

Ustawienie flagi automaticGenerationDuringBuild na true aktywuje generowanie nowego profilu podstawowego dla każdego zestawu wersji. Oznacza to, że uruchomienie zadania kompilacji w wersji Compute, np. ./gradlew:app:assembleRelease, również aktywuje :app:generateReleaseBaselineProfile, uruchamia testy narzędzi profilu podstawowego i buduje kompilację profilu podstawowego, na podstawie której są uruchamiane. Automatyczne generowanie pomaga użytkownikom uzyskać największą wydajność, ale wydłuża też czas kompilacji ze względu na podwójne testy kompilacji i instrumentacji.

Możesz też określić to zachowanie w przypadku poszczególnych wariantów, tak jak w tym przykładzie:

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

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild true
        }
    }
}

W poprzednim przykładzie zadanie generateFreeReleaseBaselineProfile jest uruchamiane podczas uruchamiania assembleFreeRelease. Jest to przydatne, gdy użytkownik chce mieć na przykład kompilację release do dystrybucji, która zawsze generuje profil podczas tworzenia, i kompilację releaseWithoutProfile na potrzeby testów wewnętrznych.

Zapisuj profile podstawowe w źródłach

Profile podstawowe możesz przechowywać w katalogu źródłowym za pomocą flagi saveInSrc:

• true: profil podstawowy jest przechowywany w src/<variant>/generated/baselineProfiles. Dzięki temu możesz zatwierdzić najnowszy wygenerowany profil z użyciem źródeł.
• false: profil podstawowy jest przechowywany w plikach pośrednich w katalogu kompilacji. Dzięki temu podczas zatwierdzania kodu nie zapiszesz najnowszego wygenerowanego profilu.

baselineProfile {
    saveInSrc = true
}

baselineProfile {
    saveInSrc true
}

Możesz też określić takie działanie w przypadku poszczególnych wariantów:

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

baselineProfile {
    variants {
        freeRelease {
            saveInSrc true
        }
    }
}

Filtruj reguły profilu

Wtyczka Gradle profilu podstawowego umożliwia filtrowanie wygenerowanych reguł profilu podstawowego. Jest to szczególnie przydatne w przypadku bibliotek, gdy chcesz wykluczyć reguły profilu dla klas i metod, które są częścią innych zależności aplikacji lub biblioteki. Filtry mogą uwzględniać i wykluczać określone pakiety i klasy. Jeśli podajesz tylko wykluczenia, wykluczane są tylko pasujące reguły profilu podstawowego, a wszystkie pozostałe uwzględniane są.

Specyfikacja filtrów może być:

• Nazwa pakietu zakończona podwójnymi symbolami wieloznacznymi, które pasują do określonego pakietu i wszystkich podpakietów. Na przykład com.example.** pasuje do com.example.method i com.example.method.bar.
• Nazwa pakietu zakończona symbolem wieloznacznym, który pasuje tylko do określonego pakietu. Na przykład com.example.* pasuje do wyrażenia com.example.method, ale nie pasuje do com.example.method.bar.
• Nazwy klas pasujące do konkretnej klasy, na przykład com.example.MyClass.

Poniższe przykłady pokazują, jak uwzględniać i wykluczać określone 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 filtrowania dla różnych wersji 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.**'
            }
        }
    }
}

W BaselineProfileRule.collect() możesz też filtrować reguły za pomocą argumentu filterPredicate, ale zalecamy filtrowanie za pomocą wtyczki Gradle, ponieważ upraszcza ona filtrowanie podpakietów i pozwala skonfigurować cały moduł za pomocą jednego miejsca.

Dostosuj typy kompilacji testu porównawczego i profilu podstawowego

Wtyczka Gradle profilu podstawowego tworzy dodatkowe typy kompilacji w celu generowania profili i przeprowadzania testów porównawczych. Te typy kompilacji mają prefiks benchmark i nonMinified. Na przykład w przypadku typu kompilacji release wtyczka tworzy typy kompilacji benchmarkRelease i nonMinifiedRelease. Te typy kompilacji są konfigurowane automatycznie pod kątem konkretnego zastosowania i zwykle nie wymagają dostosowywania. W niektórych przypadkach warto jednak zastosować opcje niestandardowe, na przykład inną konfigurację podpisywania.

Automatycznie generowane typy kompilacji możesz dostosowywać za pomocą podzbioru właściwości typu kompilacji. Właściwości, które nie nadają się do użycia, są zastępowane. Z przykładu poniżej dowiesz się, jak dostosowywać dodatkowe typy kompilacji i które właściwości są zastępowane:

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.getByName("benchmarkRelease")
        }
        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 podstawowych pamiętaj o tych dodatkowych kwestiach:

• Skompilowane profile podstawowe muszą być mniejsze niż 1,5 MB. Nie dotyczy to formatu tekstowego w plikach źródłowych, które są zwykle dużo większe przed kompilacją. Sprawdź rozmiar binarnego profilu podstawowego, znajdując go w artefakcie wyjściowym 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.

• Szerokie reguły, które kompilowają zbyt dużą część aplikacji, mogą spowolnić uruchamianie z powodu zwiększonego dostępu do dysku. Nie musisz się tym przejmować, jeśli dopiero zaczynasz korzystać z profili podstawowych. Jednak w zależności od aplikacji oraz rozmiaru i liczby ścieżek dodanie dużej liczby ścieżek może doprowadzić do nieoptymalnej wydajności. Przetestuj wydajność aplikacji, testując różne profile i sprawdzając, czy po wprowadzeniu zmian wydajność nie pogorszy się.

Ćwiczenia z programowania