Skonfiguruj generowanie profilu podstawowego

Wtyczka do obsługi Gradle profilu Baseline ułatwia generowanie i utrzymywanie Profile podstawowe. Umożliwia wykonywanie tych czynności:

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

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 nowsza
• Zależność od najnowsza wersja wtyczki Gradle

Użyj urządzeń zarządzanych przez Gradle do generowania profili podstawowych

Używanie urządzenia zarządzanego przez Gradle (GMD) do: wygeneruj profil podstawowy, dodaj go w konfiguracji build.gradle.kts producenta profilu – prawdopodobnie modułu testowego :baselineprofile – 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 GMD do generowania profili podstawowych przez dodanie ich do profilu bazowego Konfiguracja wtyczki Gradle w następujący sposób w sekcji build.gradle.kts Moduł testowy :baselineprofile:

baselineProfile {
    managedDevices += "pixel6Api31"
}

baselineProfile {
    managedDevices = ['pixel6Api31']
}

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

baselineProfile {
    ...
    useConnectedDevices = false
}

baselineProfile {
    ...
    useConnectedDevices false
}

Generowanie profili podstawowych dla różnych wariantów

Możesz wygenerować profile podstawowe dla poszczególnych wariantów, smaków lub jako pojedynczy plik. który będzie używany we wszystkich wariantach. Aby kontrolować to zachowanie, użyj ustawienia scalania, jak pokazano w tym przykładzie w build.gradle.kts aplikacji lub modułu biblioteki.

baselineProfile {
    mergeIntoMain = true
}

baselineProfile {
    mergeIntoMain true
}

Aby scalić wygenerowane profile dla wszystkich wariantów w 1 profil, ustaw mergeIntoMain do 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 lokalizacji src/main/generated/baselineProfiles

Aby wyłączyć scalanie i mieć po 1 profilu na wariant, w polu mergeIntoMain ustaw wartość false W tym przypadku istnieje wiele zadań Gradle dotyczących różnych wariantów. Dla: np. gdy są 2 rodzaje smaków – na przykład bezpłatny i płatny – i jeden należy wykonać następujące zadania:

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

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

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

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain true
        }
    }
}

W poprzednim przykładzie wariant, w którym flaga jest ustawiona na true, to wszystkie zostały scalone w element src/main/generated/baselineProfiles, natomiast profile warianty z flagą ustawioną na false są przechowywane w folderze src/<variant>/generated/baselineProfiles

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

Automatycznie generuj profile podstawowe podczas tworzenia nowej wersji

Możesz skonfigurować profile podstawowe tak, aby były automatycznie generowane z każdą wersją zamiast ręcznie używać zadania generateBaselineProfile. Na automatycznego generowania, najbardziej zaktualizowany profil jest uwzględniany w kompilacji wersji.

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

baselineProfile {
    automaticGenerationDuringBuild = true
}

baselineProfile {
    automaticGenerationDuringBuild true
}

Ustawienie flagi automaticGenerationDuringBuild na true powoduje uruchomienie i generować nowy profil podstawowy dla każdego zestawu wersji. Oznacza to, że uruchamianie zadania kompilacji opartej na zabudowie, takiego jak ./gradlew:app:assembleRelease, wywołuje również :app:generateReleaseBaselineProfile, uruchamia profil podstawowy test instrumentacji i tworzy kompilację profilu podstawowego. Automatyczne generowanie pomaga użytkownikom uzyskać największą wydajność, wydłuża też czas kompilacji ze względu na podwójną kompilację i instrumentację, testów.

Możesz też określić to zachowanie dla poszczególnych wariantów, jak pokazano poniżej: przykład:

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

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild true
        }
    }
}

W poprzednim przykładzie zadanie generateFreeReleaseBaselineProfile jest uruchamiane od assembleFreeRelease. Przydaje się to, gdy użytkownik chce mieć np. release do kompilacji dystrybucyjnej, która zawsze generuje profil podczas tworzenia, a kompilację releaseWithoutProfile do testów wewnętrznych.

Przechowuj profile podstawowe w źródłach

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

• true: profil podstawowy jest przechowywany w plikusrc/<variant>/generated/baselineProfiles. Umożliwi Ci to zatwierdzenie najnowszej wersji w wygenerowanym profilu z Twoimi źródłami.
• 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
        }
    }
}

Filtruj reguły profilu

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

Specyfikacja filtrów może zawierać dowolną z tych wartości:

• Nazwa pakietu kończąca się podwójnymi symbolami wieloznacznymi, które pasują do określonego pakietu oraz wszystkich podpakietów. Na przykład com.example.** odpowiada com.example.method i com.example.method.bar
• nazwa pakietu kończąca się symbolem wieloznacznym, aby pasować tylko do określonego pakietu; Dla: przykład, com.example.* pasuje do com.example.method, ale nie pasuje com.example.method.bar
• nazwy zajęć pasujące do konkretnej klasy, np. com.example.MyClass;

W przykładach poniżej pokazujemy, 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.**'
    }
}

Aby dostosować reguły filtrowania pod kątem różnych wariantów:

// 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 Gradle. jest wtyczką do filtrowania, ponieważ zapewnia prostszy sposób filtrowania podpakietów i w jednym miejscu, aby skonfigurować cały moduł.

Dostosuj typy kompilacji profilu bazowego i analizy porównawczej

Wtyczka do obsługi Gradle profilu Baseline tworzy dodatkowe typy kompilacji do wygenerowania i testów porównawczych. Te typy kompilacji mają prefiks benchmark i nonMinified. Na przykład w przypadku typu kompilacji release atrybut wtyczka tworzy typy kompilacji benchmarkRelease i nonMinifiedRelease. Te typy kompilacji są automatycznie konfigurowane pod kątem konkretnego zastosowania i zazwyczaj nie wymagają dostosowywania. Jednak w niektórych przypadkach przydaje się do stosowania opcji niestandardowych, np. do stosowania mają inną konfigurację podpisywania.

Automatycznie wygenerowane typy kompilacji możesz dostosować za pomocą podzbioru właściwości typu kompilacji; które nie nadają się do użycia. 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 podstawowych warto pamiętać o kilku dodatkowych kwestiach:

• Skompilowane profile podstawowe muszą być mniejsze niż 1,5 MB. Nie mają zastosowanie do formatu tekstowego w plikach źródłowych, który zwykle większy przed skompilacją. Sprawdź rozmiar pliku binarnego punktu odniesienia Profiluj go, znajdując go w artefaktze wyjściowym w 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 kompilują za dużo aplikacji, mogą spowalniać uruchamianie ze względu na zwiększony dostęp do dysku. Jeśli dopiero zaczynasz korzystać z punktu odniesienia Profile, nie musisz się tym przejmować. Jednak zależnie od aplikacji i atrybutu wielkości i liczby przejazdów, dodawanie dużej liczby przejazdów może nieoptymalną skuteczność. Sprawdź działanie aplikacji, wypróbowując różne metody i upewnić się, że skuteczność nie pogarsza się po jakimś czasie. .

Ćwiczenia z programowania