Migracja aplikacji błyskawicznej w celu obsługi pakietów Android App Bundle

Jeśli nadal używasz wycofanej wtyczki Feature Android Gradle (com.android.feature) w modułach aplikacji błyskawicznej na Androida, musisz zacząć korzystać z podstawowej wtyczki aplikacji (com.android.application) i wtyczki funkcji dynamicznych (com.android.dynamic-feature).

Podstawowa wtyczka do aplikacji na Androida w wersji 3.3.0 lub nowszej obsługuje aplikacje błyskawiczne. Oznacza to, że jeśli moduł podstawowy aplikacji spełnia wymagania aplikacji błyskawicznej, korzyści zostaną przyznane automatycznie. Dzięki wtyczce funkcji dynamicznych możesz dodać dodatkowe funkcje, które użytkownicy będą mogli pobierać na żądanie w formie aplikacji błyskawicznej. Taka konfiguracja ułatwia obsługę zarówno aplikacji zainstalowanych, jak i błyskawicznych w ramach jednego projektu, a także czerpie korzyści z publikowania za pomocą pakietów Android App Bundle.

Tabela poniżej zawiera bardziej szczegółowe informacje o wtyczkach, do których przeprowadzisz migrację:

Opis modułu Stara wtyczka Obecna wtyczka
Moduł zawierający podstawowy kod, zasoby i funkcje aplikacji instalowanej lub błyskawicznej. com.android.feature (baseFeature = true) com.android.application

Uwaga: ten moduł zawiera wszystkie informacje z pliku manifestu i podpisów wymagane do skompilowania i spakowania aplikacji jako pakietu Android App Bundle lub pliku APK.

dodatkowe, modułowe funkcje, które użytkownicy mogą pobierać na żądanie. com.android.feature com.android.dynamic-feature (z elementami dist:instant="true" i dist:onDemand="false" w pliku manifestu modułu)
Kod i zasób funkcji dostępnej tylko w zainstalowanej wersji Twojej aplikacji. com.android.application com.android.dynamic-feature (z elementami dist:instant="false" i dist:onDemand="false" w pliku manifestu modułu)

Na tej stronie dowiesz się, jak zmigrować istniejący projekt aplikacji błyskawicznej, aby utworzyć pakiet Android App Bundle z obsługą błyskawiczną. Dowiesz się z niego też, jak kompilować, testować i publikować pakiety Android App Bundle z obsługą wersji błyskawicznej.

Jeśli tworzysz nowe aplikacje błyskawiczne dla swojej aplikacji, przeczytaj artykuł Tworzenie modułu funkcji z obsługą wersji błyskawicznych.

Omówienie zmian

Gdy przenosisz projekt tak, by zamiast niego używał wtyczki funkcji dynamicznych, pakiety Android App Bundle zapewniają nowy sposób tworzenia i publikowania aplikacji, który znacznie upraszcza dystrybucję zoptymalizowanych plików APK użytkownikom.

Pakiety aplikacji upraszczają dystrybucję, ponieważ zawierają cały skompilowany kod i zasoby aplikacji do przesłania, ale opóźniają generowanie plików APK i podpisywanie ich w Google Play. Nowy model obsługi aplikacji dostępny w Google Play używa Twojego pakietu aplikacji do generowania i udostępniania zoptymalizowanych plików APK zgodnych z konfiguracją urządzeń każdego użytkownika. Dzięki temu użytkownicy pobierają tylko kod i zasoby niezbędne do uruchomienia aplikacji. Nie musisz już tworzyć i podpisywać wielu plików APK ani nimi zarządzać, by obsługiwać różne urządzenia, a użytkownicy otrzymują mniejsze, lepiej zoptymalizowane pliki do pobrania.

Gdy używasz teraz wycofanej wtyczki funkcji, utworzenie aplikacji błyskawicznej wymagało utworzenia podstawowego modułu funkcji, który zawierał udostępniony kod i zasoby dla wszystkich Twoich modułów, w tym modułu aplikacji błyskawicznej. Pozostała część kodu była zawarta w kilku modułach funkcji innych niż podstawowe, które zawierały punkty wejścia do aplikacji błyskawicznych. Zainstalowana wersja aplikacji może zawierać oddzielny moduł, który zawiera kod i działania wymagane tylko w przypadku zainstalowanej aplikacji.

Gdy przenosisz swoją aplikację, aby obsługiwała pakiety Android App Bundle, moduł aplikacji przejmuje rolę modułu podstawowego, a dodatkowe środowiska zainstalowane lub błyskawiczne porządkujesz jako moduły funkcji. Oznacza to, że Twój projekt bardziej przypomina teraz standardowy projekt aplikacji, ponieważ zawiera moduł podstawowy z obsługą wersji błyskawicznej i możliwość dołączenia dodatkowych, modułowych aplikacji błyskawicznych.

Aby przenieść istniejący projekt aplikacji błyskawicznej i wdrożyć bardziej zoptymalizowany model dystrybucji pakietu Android App Bundle, wykonaj czynności opisane w sekcjach poniżej.

Przekonwertowanie modułu funkcji podstawowych na moduł aplikacji

Zanim przekonwertujesz go na główny moduł aplikacji, musisz zmodyfikować plik build.gradle modułu funkcji podstawowej w następujący sposób:

  1. Usuń wiersz baseFeature true.

  2. Usuń wszystkie zależności, które korzystają z konfiguracji zależności feature lub application.

    Odlotowy

    dependencies {
    ...
    // delete any lines that look like
    // feature project(":foo")
    // feature project(":bar")
    // application project(":app")
}

    Kotlin

    dependencies {
    ...
    // delete any lines that look like
    // feature(project(":foo"))
    // feature(project(":bar"))
    // application(project(":app"))
}

  3. Przenieś obiekt applicationId wraz z wszystkimi innymi konfiguracjami skryptu kompilacji, które powinny się znajdować w module podstawowym aplikacji z bieżącego modułu com.android.application do modułu com.android.feature. Poniżej znajdziesz kilka przykładów. W tym kroku, w zależności od konkretnej konfiguracji build.gradle, łatwiej będzie skopiować i wkleić blok android build.gradle z poprzedniego modułu aplikacji do pliku build.gradle nowego modułu aplikacji. Należy jednak zachować ostrożność.

    Odlotowy

    android {
    ...
    defaultConfig {
        // You need to move the application ID from the app module
        // to your feature module.
        applicationId "com.example.myapp"
        ...
    }
    // Some additional build configurations you might want to
    // copy from your current ‘app’ module may include ProGuard
    // rules and code shrinking settings.
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
              'proguard-android-optimize.txt'),
              'proguard-rules.pro'
        }
    }
}

    Kotlin

    android {
    ...
    defaultConfig {
        // You need to move the application ID from the app module
        // to your feature module.
        applicationId = "com.example.myapp"
        ...
    }
    // Some additional build configurations you might want to
    // copy from your current ‘app’ module may include ProGuard
    // rules and code shrinking settings.
    buildTypes {
        getByName("release") {
            minifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

  4. Oznacz moduł funkcji jako obsługujący wersję błyskawiczną, dodając do pliku manifestu odpowiednie tagi dystrybucji pakietów (jak pokazano poniżej).

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" />
    ...
</manifest>

  5. Przekonwertuj moduł funkcji na moduł podstawowej aplikacji, zmieniając jego typ wtyczki na com.android.application:

    Odlotowy

    // Replace  "plugins { id 'com.android.feature' }"
// with the following
plugins {
  id 'com.android.application'
}

    Kotlin

    // Replace  "plugins { id("com.android.feature") }"
// with the following
plugins {
    id("com.android.application")
}

Przekonwertuj stary moduł aplikacji na moduł funkcji czasu instalacji.

Jeśli w starym module aplikacji nie ma kodu ani zasobów, możesz go po prostu usunąć, ponieważ czynności opisane w poprzedniej sekcji skonwertowały moduł funkcji w podstawowy moduł aplikacji.

Jeśli jednak w starym module aplikacji masz kod i zasoby reprezentujące funkcje, które chcesz udostępnić użytkownikom podczas instalowania aplikacji, wykonaj czynności opisane w tej sekcji, aby przekonwertować moduł aplikacji na moduł funkcji.

Utworzenie modułu funkcji obejmuje zmianę typu wtyczki z com.android.application na com.android.dynamic-feature i wprowadzenie kilku innych zmian w elemencie build.gradle w następujący sposób:

  1. Zmień typ wtyczki z com.android.application na com.android.dynamic-feature.

    Odlotowy

    // Replace "plugins { id 'com.android.feature' }"
// with the following:
plugins {
  id 'com.android.dynamic-feature'
}

    Kotlin

    // Replace "plugins { id("com.android.application") }"
// with the following:
plugins {
    id("com.android.dynamic-feature")
}

  2. Jak opisano w poprzedniej sekcji, upewnij się, że konfiguracje kompilacji wymagane przez wtyczkę com.android.application, takie jak reguły applicationId lub proguardFiles, zostały przeniesione do modułu aplikacji podstawowej.

  3. Zmień nazwę modułu na podobną do „installed_feature” w ten sposób:

    1. Otwórz panel Projekt, wybierając na pasku menu Widok > Okna narzędzi > Projekt.
    2. Kliknij prawym przyciskiem myszy moduł funkcji i wybierz Refaktor > Zmień nazwę.
    3. W wyświetlonym oknie wybierz Zmień nazwę modułu i kliknij OK.
    4. Wpisz nową nazwę modułu i kliknij OK.

  4. Podobnie jak w kroku 3, zmień nazwę nowego modułu aplikacji utworzonego w poprzedniej sekcji na np. „aplikacja”.

  5. Dodaj zależność implementacji do modułu „app” w pliku build.gradle modułu funkcji, jak pokazano poniżej.

    Odlotowy

    dependencies {
    ...
    // In the feature module, add an implementation dependency
    // on the base app module.
    implementation project(":app")
}

    Kotlin

    dependencies {
    ...
    // In the feature module, add an implementation dependency
    // on the base app module.
    implementation(project(":app"))
}

  6. Dodaj tę funkcję do pliku build.gradle nowego modułu aplikacji.

    Odlotowy

    android {
    ...
    // In the base app module, specify each feature module.
    dynamicFeatures = [":installed_feature"]
}

    Kotlin

    android {
    ...
    // In the base app module, specify each feature module.
    dynamicFeatures.addAll(listOf(":installed_feature"))
}

  7. W pliku manifestu modułu funkcji oznacz moduł funkcji jako moduł z możliwością zainstalowania, dodając do niego odpowiednie tagi dystrybucji pakietu.

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="false" dist:onDemand="false"
            dist:title="@string/title_dynamic_feature">
        <dist:fusing dist:include="true" />
    </dist:module>
    ...
</manifest>

konwertować inne moduły funkcji na moduły funkcji z obsługą wersji błyskawicznej;

Jeśli moduł dodatkowych funkcji aplikacji jest podzielony na kilka modułów funkcji, musisz wykonać czynności opisane w tej sekcji, aby je przekonwertować na moduły funkcji z obsługą wersji błyskawicznej.

W przypadku pozostałych modułów funkcji w projekcie wykonaj te czynności, aby przekonwertować je na funkcje obsługujące błyskawiczne:

  1. Zmień typ wtyczki w pliku build.gradle na com.android.dynamic-feature, jak pokazano poniżej:

    Odlotowy

    // Replace 'com.android.feature' with 'com.android.dynamic-feature'
plugins {
  id 'com.android.dynamic-feature'
}

    Kotlin

    // Replace "com.android.feature" with "com.android.dynamic-feature"
plugins {
    id("com.android.dynamic-feature")
}

  2. Oznacz każdy moduł funkcji jako z obsługą wersji błyskawicznej, dodając do pliku manifestu ten kod.

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" dist:onDemand="false"
            dist:title="@string/title_dynamic_feature">
        <dist:fusing dist:include="true" />
    </dist:module>
    ...
</manifest>

  3. Dodaj moduł funkcji do pliku build.gradle nowego modułu aplikacji i dodaj installed_feature do listy modułów funkcji.

    Odlotowy

    android {
   ...
   dynamicFeatures = [":installed_feature", ":feature_1", ":feature_2"]
   // or whichever name exists for the instant enabled feature module
}

    Kotlin

    android {
   ...
   dynamicFeatures.addAll(listOf(":installed_feature", ":feature_1", ":feature_2"))
   // or whichever name exists for the instant enabled feature module
}

Tworzenie, testowanie i publikowanie nowego pakietu z obsługą wersji błyskawicznej

Po wykonaniu czynności opisanych na tej stronie Twój projekt będzie mógł wygenerować 1 artefakt – pakiet Android App Bundle, którego możesz użyć do opublikowania w Konsoli Google Play zarówno wersji instalowanej, jak i błyskawicznej aplikacji. Możesz też wdrożyć oddzielnie dla ścieżki błyskawicznej i instalacyjnej. Poza tym dzięki pakietom aplikacji możesz korzystać ze zoptymalizowanych plików APK dostosowanych do konfiguracji urządzenia każdego użytkownika. Dzięki temu pobierają oni tylko kod i zasoby niezbędne do uruchomienia Twojej aplikacji. Nie musisz już tworzyć i podpisywać wielu plików APK ani nimi zarządzać, by obsługiwać różne urządzenia, a użytkownicy otrzymują mniejsze i bardziej zoptymalizowane pliki do pobrania.

Aby zacząć tworzyć i testować pakiet aplikacji obsługujący aplikacje błyskawiczne, przejdź do sekcji Tworzenie pakietu aplikacji.