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

Jeśli nadal używasz wycofanej wtyczki Androida do obsługi Gradle funkcji (com.android.feature) w przypadku modułów aplikacji błyskawicznej na Androida należy: przejść na podstawową wtyczkę aplikacji (com.android.application) Wtyczka funkcji dynamicznych (com.android.dynamic-feature).

W przypadku wtyczki Androida do obsługi Gradle w wersji 3.3.0 lub nowszej podstawowa wtyczka aplikacji zapewnia obsługę z myślą o aplikacjach błyskawicznych. Oznacza to, że jeśli podstawowy moduł aplikacji spełnia wymagania dotyczące wersji błyskawicznej będą dostępne automatycznie. Następnie możesz dołączyć dodatkowe funkcje, które użytkownicy mogą pobrać na żądanie jako aplikacji błyskawicznych przy użyciu wtyczki Dzięki tej konfiguracji jest łatwiejsza do obsługi zarówno aplikacji instalowanej, jak i błyskawicznej z poziomu projektu i umożliwia korzystanie z możliwości publikowania Pakiety aplikacji na Androida.

W tabeli poniżej znajdziesz więcej informacji o wtyczkach, do których chcesz przenieść dane:

Opis modułu Stara wtyczka Obecna wtyczka
Moduł zawierający podstawowy kod, zasoby i funkcje związanych z zainstalowaną lub błyskawiczną aplikacją. com.android.feature (z: baseFeature = true) com.android.application

Uwaga: ten moduł zawiera wszystkie pliki manifestu i informacje dotyczące podpisywania wymagane do utworzenia i spakowania aplikacji na Androida Pakiet aplikacji lub plik 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 pliku manifestu modułu)
Kod i zasób funkcji dostępnej tylko w wersji zainstalowanej Twojej aplikacji. com.android.application com.android.dynamic-feature (z dist:instant="false" i dist:onDemand="false" w pliku manifestu modułu)

Na tej stronie dowiesz się, jak przenieść istniejący projekt aplikacji błyskawicznej, aby utworzyć pakietu Android App Bundle z obsługą wersji błyskawicznej. Dowiesz się z niego również, jak tworzyć, testować opublikować pakiet Android App Bundle obsługujący aplikacje błyskawicznie.

Jeśli tworzysz nowe aplikacje błyskawiczne, przeczytaj artykuł Utwórz moduł funkcji z obsługą wersji błyskawicznych.

Omówienie zmian

Jeśli przenosisz swój projekt do wtyczki Dynamic Feature, Pakiety Android App Bundle zapewniają nowy sposób tworzenia i publikowania aplikacji aplikacji, które znacznie upraszczają rozpowszechnianie zoptymalizowanych plików APK użytkowników.

Pakiety aplikacji upraszczają dystrybucję, tworząc pakiet całego skompilowanego kodu aplikacji i zasobów do przesłania, ale opóźnia wygenerowanie i podpisanie plików APK w Google Play. Nowy model udostępniania aplikacji w Google Play korzysta z Twojego pakiet aplikacji umożliwiający generowanie i udostępnianie zoptymalizowanych plików APK dla każdego urządzenia użytkownika Pobiera on tylko kod i zasoby potrzebne do uruchomienia do aplikacji. Nie musisz już tworzyć i podpisywać wielu plików APK ani nimi zarządzać. na różnych urządzeniach, a użytkownicy pobierają pliki mniejsze i lepiej zoptymalizowane.

Jeśli korzystasz z wycofanej wtyczki, musisz stworzyć aplikację błyskawiczną stworzenie modułu funkcji podstawowych, który zawierał udostępniony kod i zasoby. dla wszystkich modułów, w tym modułu aplikacji błyskawicznej. Pozostała część kodu została uwzględniona w wielu niepodstawowych modułach funkcji, które zawierały punkty wejścia do aplikacji błyskawicznych. W przypadku zainstalowanej wersji aplikacji plik w projekcie mógł być osobny moduł aplikacji, który zawierał kod czynności wymagane tylko w przypadku zainstalowanej aplikacji.

Po przeniesieniu aplikacji, by obsługiwała pakiety Android App Bundle, moduł odzyskuje rolę modułu podstawowego i porządkuje dodatkowe zainstalowane lub aplikacji błyskawicznych w postaci modułów funkcji. Oznacza to, że Twój projekt przypomina zwykły projekt aplikacji, a jej moduł podstawowy z obsługą wersji błyskawicznej oraz możliwość dodania dodatkowych, modułowych aplikacji błyskawicznych.

Aby przenieść istniejący projekt aplikacji błyskawicznej i zastosować pakiet Android App Bundle bardziej zoptymalizowanego modelu dystrybucji, wykonaj czynności opisane w sekcjach poniżej.

Przekształcanie modułu funkcji podstawowych w moduł aplikacji

Musisz najpierw zmodyfikować plik build.gradle podstawowego modułu funkcji przed możesz go przekonwertować na główny moduł aplikacji w ten sposób:

  1. Usuń wiersz baseFeature true.

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

    Odlotowe

    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ś skrypt applicationId wraz z innymi konfiguracjami skryptu kompilacji w podstawowym module aplikacji com.android.application do modułu com.android.feature. Niektóre poniżej. W zależności od build.gradle, być może łatwiej będzie skopiować i wkleić android blok build.gradle z poprzedniego modułu aplikacji do nowej aplikacji build.gradle modułu. Zachowaj jednak ostrożność podczas wykonywania tych czynności tak.

    Odlotowe

    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 z obsługą wersji błyskawicznej, dodając odpowiedni pakiet do pliku manifestu, 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ł podstawowy aplikacji, zmieniając wtyczkę wpisz do com.android.application:

    Odlotowe

    // 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 związany z instalacją

Jeśli nie masz kodu ani zasobów w starym module aplikacji, możesz – można go usunąć, ponieważ czynności opisane w poprzedniej sekcji modułu funkcji do podstawowego modułu aplikacji.

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

Utworzenie modułu funkcji wiąże się ze zmianą typu wtyczki z Z: com.android.application do: com.android.dynamic-feature i kilka inne zmiany build.gradle w następujący sposób:

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

    Odlotowe

    // 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 upewnij się, że kompilacja została przeniesiona konfiguracje, których wymaga wtyczka com.android.application do podstawowego modułu aplikacji, takich jak reguły applicationId lub proguardFiles.

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

    1. Otwórz panel Projekt, klikając Widok > Okna narzędziowe > Projekt na pasku menu.
    2. Kliknij prawym przyciskiem myszy moduł funkcji i wybierz Refaktoryzacja > 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 poprzednim np. „aplikacja”.

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

    Odlotowe

    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.

    Odlotowe

    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 instalacyjny moduł, dodając odpowiednie tagi dystrybucji pakietu do sekcji pliku manifestu.

    <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>

Konwertowanie innych modułów funkcji na moduły funkcji obsługujące wersję błyskawiczną

Jeśli połączysz dodatkowe funkcje aplikacji z kilkoma funkcjami, musisz wykonać czynności opisane w tej sekcji, aby je przekonwertować. w moduły funkcji z obsługą wersji błyskawicznej.

W przypadku każdego pozostałego modułu funkcji w projekcie wykonaj te czynności, aby dokonać konwersji do funkcji błyskawicznych:

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

    Odlotowe

    // 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 ten fragment: do pliku manifestu.

    <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.

    Odlotowe

    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 Twój projekt będzie mógł wygenerować artefaktu, czyli pakietu Android App Bundle, którego można używać do publikowania do Konsoli Google Play i przekazać do Konsoli Google Play wersję błyskawiczną, oddzielnie dla ścieżek błyskawicznych i zainstalowanych. Dodatkowo w aplikacji pakietów, zyskujesz korzyść dzięki udostępnianiu zoptymalizowanych plików APK dla konfiguracji urządzenia każdego użytkownika. Pobiera on tylko kod zasobów potrzebnych do uruchomienia aplikacji. Oznacza to, że nie trzeba już budować, podpisywać, i zarządzać wieloma pakietami APK, aby obsługiwać różne urządzenia. i lepiej optymalizować pobieranie.

Aby zacząć tworzyć i testować pakiet obsługujący aplikacje błyskawiczne, otwórz stronę Utwórz pakiet aplikacji.