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

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.