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

Ostrzeżenie: aplikacja błyskawiczna w Google Play nie będzie już dostępna. Od grudnia 2025 r. nie będzie można publikować aplikacji błyskawicznych w Google Play, a wszystkie interfejsy Instant API Usług Google Play przestaną działać. Użytkownicy nie będą już otrzymywać aplikacji błyskawicznych z Google Play za pomocą żadnego mechanizmu.

Wprowadzamy tę zmianę na podstawie opinii deweloperów i naszych ciągłych inwestycji w ulepszanie ekosystemu od czasu wprowadzenia aplikacji błyskawicznych w Google Play.

Aby nadal optymalizować wzrost liczby użytkowników, zachęcamy deweloperów do kierowania użytkowników do standardowej aplikacji lub gry za pomocą precyzyjnych linków, które w razie potrzeby przekierowują ich do określonych ścieżek lub funkcji.

Jeśli w modułach aplikacji błyskawicznej na Androida nadal używasz wycofanej wtyczki Androida do obsługi Gradle dla funkcji (com.android.feature), musisz przejść na wtyczkę aplikacji podstawowej (com.android.application) i wtyczkę funkcji dynamicznej (com.android.dynamic-feature).

Wtyczka aplikacji podstawowej w wtyczce Androida do obsługi Gradle w wersji 3.3.0 lub nowszej obsługuje aplikacje błyskawiczne. Oznacza to, że jeśli podstawowy moduł aplikacji spełnia wymagania dotyczące aplikacji natychmiastowej, automatycznie uzyskasz korzyści z tego wynikające. Możesz też dodać dodatkowe funkcje, które użytkownicy mogą pobrać na żądanie jako natychmiastowe wersje próbne, korzystając z wtyczki funkcji dynamicznych. Dzięki temu łatwiej jest obsługiwać zarówno aplikację instalowaną, jak i błyskawiczną w ramach jednego projektu, a także korzystać z publikowania za pomocą pakietów Android App Bundle.

W tabeli poniżej znajdziesz więcej informacji o tym, do których wtyczek nastąpi migracja:

Opis modułu Stara wtyczka Bieżąca wtyczka
Moduł, który zawiera podstawowy kod, zasoby i funkcjonalność zainstalowanej lub błyskawicznej aplikacji. com.android.feature (z: baseFeature = true) com.android.application

Uwaga: ten moduł zawiera wszystkie informacje o pliku manifestu i podpisywaniu wymagane do utworzenia i spakowania aplikacji jako pakietu Android App Bundle lub pliku APK.

Dodatkowe modułowe funkcje, które użytkownicy mogą pobrać na żądanie. com.android.feature com.android.dynamic-feature (z dist:instant="true" i dist:onDemand="false" w manifeście modułu)
Kod i zasoby funkcji dostępnej tylko w zainstalowanej wersji aplikacji. com.android.application com.android.dynamic-feature (z dist:instant="false" i dist:onDemand="false" w manifeście modułu)

Z tej strony dowiesz się, jak przeprowadzić migrację istniejącego projektu aplikacji błyskawicznej, aby utworzyć pakiet aplikacji na Androida obsługujący aplikacje błyskawiczne. Opisuje też, jak tworzyć, testować i publikować pakiet aplikacji na Androida obsługujący aplikacje błyskawiczne.

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

Omówienie zmian

Gdy przeprowadzisz migrację projektu, aby zamiast tego używać wtyczki dynamicznych funkcji, pakiety aplikacji na Androida zapewnią nowy sposób tworzenia i publikowania aplikacji, który znacznie uprości dystrybucję zoptymalizowanych plików APK do użytkowników.

Pakiety aplikacji upraszczają dystrybucję, ponieważ zawierają cały skompilowany kod i wszystkie zasoby aplikacji, które można przesłać. Generowanie i podpisywanie plików APK odbywa się w Google Play. Nowy model przesyłania aplikacji w Google Play wykorzystuje pakiet aplikacji do generowania i przesyłania zoptymalizowanych plików APK na urządzenia użytkowników, dzięki czemu pobierają oni tylko kod i zasoby potrzebne do uruchomienia aplikacji. Nie musisz już tworzyć, podpisywać i zarządzać wieloma plikami APK, aby obsługiwać różne urządzenia, a użytkownicy pobierają mniejsze i bardziej zoptymalizowane pliki.

Gdy używasz wtyczki funkcji, która jest już wycofana, utworzenie aplikacji błyskawicznej wymagało utworzenia podstawowego modułu funkcji, który zawierał wspólny kod i zasoby dla wszystkich modułów, w tym modułu aplikacji błyskawicznej. Pozostała część kodu została uwzględniona w wielu modułach funkcji innych niż podstawowe, które zawierały punkty wejścia do aplikacji błyskawicznych. W przypadku zainstalowanej wersji aplikacji projekt mógł zawierać osobny moduł aplikacji, który zawierał kod i aktywności wymagane tylko w przypadku zainstalowanej aplikacji.

Gdy przeniesiesz aplikację, aby obsługiwała pakiety Android App Bundle, moduł aplikacji odzyska rolę modułu podstawowego, a dodatkowe zainstalowane lub błyskawiczne wersje aplikacji zostaną zorganizowane jako moduły funkcji. Oznacza to, że Twój projekt jest teraz bardziej podobny do standardowego projektu aplikacji z modułem podstawowym obsługującym aplikacje błyskawiczne i możliwością uwzględnienia dodatkowych, modułowych aplikacji błyskawicznych.

Aby przenieść dotychczasowy projekt aplikacji natychmiastowej i zastosować bardziej zoptymalizowany model dystrybucji pakietu Android App Bundle, wykonaj czynności opisane w sekcjach poniżej.

Przekształć moduł funkcji podstawowych w moduł aplikacji

Zanim przekonwertujesz moduł funkcji podstawowej na moduł aplikacji głównej, musisz najpierw edytować plik build.gradle w moduł funkcji podstawowej w ten sposób:

  1. Usuń wiersz baseFeature true.

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

    Groovy

    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ś element applicationId wraz z innymi konfiguracjami skryptu kompilacji, które powinny znajdować się w podstawowym module 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 konfiguracjibuild.gradle, może być łatwiej skopiować i wkleić blok androidbuild.gradle z poprzedniego modułu aplikacji do pliku build.gradle nowego modułu aplikacji. Należy jednak zachować ostrożność.

    Groovy

    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 aplikacje natychmiastowe, dodając do manifestu odpowiednie tagi dystrybucji pakietu, 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ł aplikacji podstawowej, zmieniając typ wtyczki na com.android.application:

    Groovy

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

Przekształć stary moduł aplikacji w moduł funkcji przesyłany podczas instalacji

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

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

Tworzenie modułu funkcji polega na zmianie typu wtyczki z com.android.application na com.android.dynamic-feature oraz wprowadzeniu kilku innych zmian build.gradle:

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

    Groovy

    // 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. Zgodnie z opisem w poprzedniej sekcji przenieś konfiguracje kompilacji wymagane przez wtyczkę com.android.application do modułu aplikacji podstawowej, np. reguły applicationId lub proguardFiles.

  3. Zmień nazwę modułu na „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 Refactor > Rename (Refaktoryzacja > Zmień nazwę).
    3. W wyświetlonym oknie dialogowym kliknij Zmień nazwę modułu i 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 „app”.

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

    Groovy

    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 funkcję do pliku build.gradle nowego modułu aplikacji.

    Groovy

    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 go jako moduł instalacyjny, dodając do manifestu 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>

Przekształcanie innych modułów funkcji w moduły obsługujące aplikacje błyskawiczne

Jeśli dodatkowe funkcje aplikacji zostały podzielone na kilka modułów funkcji, musisz wykonać czynności opisane w tej sekcji, aby przekonwertować te moduły na moduły funkcji obsługujące aplikacje natychmiastowe.

W przypadku każdego pozostałego modułu funkcji w projekcie wykonaj te czynności, aby przekonwertować go na funkcję włączaną natychmiast:

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

    Groovy

    // 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 obsługujący aplikacje natychmiastowe, 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, w którym dodano installed_feature do listy modułów funkcji.

    Groovy

    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 aplikacji obsługującego aplikacje błyskawiczne

Po wykonaniu czynności opisanych na tej stronie projekt będzie mógł wygenerować jeden artefakt, czyli pakiet aplikacji na Androida, którego możesz użyć do opublikowania w Konsoli Google Play zarówno wersji instalowanej, jak i błyskawicznej aplikacji oraz do oddzielnego wdrażania ich na ścieżkach wersji błyskawicznej i instalowanej. Pakiety aplikacji umożliwiają też przesyłanie zoptymalizowanych plików APK na urządzenia użytkowników, dzięki czemu pobierają oni tylko kod i zasoby potrzebne do uruchomienia aplikacji. Nie musisz już tworzyć, podpisywać i zarządzać wieloma plikami APK, aby obsługiwać różne urządzenia, a użytkownicy mogą pobierać mniejsze i bardziej zoptymalizowane pliki.

Aby rozpocząć tworzenie i testowanie pakietu aplikacji z obsługą wersji błyskawicznej, przejdź do sekcji Tworzenie pakietu aplikacji.