Wdrażanie AI na urządzeniach (beta) za pomocą Google Play

Wprowadzenie

Play for AI na urządzeniu zapewnia korzyści wynikające z pakietów Android App Bundle i dostarczania przez Google Play w przypadku dystrybucji niestandardowych modeli systemów uczących się. Dzięki temu możesz bezpłatnie zwiększyć wydajność modelu przy mniejszej złożoności ekosystemu urządzeń. Umożliwia opublikowanie w Google Play pojedynczego artefaktu zawierającego kod, zasoby i modele ML oraz wybór spośród wielu trybów dostarczania i opcji kierowania.

Zalety

  • Prześlij do Google Play pojedynczy artefakt publikacji i bezpłatnie zleć Play hosting, dostarczanie, aktualizacje i kierowanie.
  • Dostarczaj modele ML w czasie instalacji, w trybie fast-follow lub na żądanie.
    • Przesyłanie w czasie instalacji może zagwarantować, że bardzo duży model będzie dostępny, gdy aplikacja zostanie otwarta. Model zostanie zainstalowany jako pakiet APK.
    • Szybkie pobieranie następuje automatycznie w tle po zainstalowaniu aplikacji. Użytkownicy mogą otworzyć aplikację, zanim model zostanie w pełni pobrany. Model zostanie pobrany do pamięci wewnętrznej aplikacji.
    • Dostarczanie na żądanie umożliwia wysyłanie żądań do modelu w czasie działania, co jest przydatne, gdy model jest wymagany tylko w przypadku niektórych wzorców przeglądania. Model zostanie pobrany do pamięci wewnętrznej aplikacji.
  • Dostarczaj warianty modeli systemów uczących się kierowane na konkretne urządzenia na podstawie modelu urządzenia, właściwości systemu lub pamięci RAM.
  • Dzięki automatycznemu poprawianiu w Google Play aktualizacje aplikacji są niewielkie i zoptymalizowane, co oznacza, że pobierane są tylko różnice w plikach.

Uwagi

  • Korzystając z Play for On-device AI, akceptujesz warunki określone w Umowie dystrybucyjnej dla deweloperów w Google Play i Warunkach korzystania z pakietu Play Core Software Development Kit.
  • Modele pobrane przez Google Play na potrzeby AI na urządzeniu powinny być używane tylko przez Twoje aplikacje. Modele nie powinny być oferowane innym aplikacjom.
  • Poszczególne pakiety AI mogą mieć rozmiar do 1, 5 GB po skompresowaniu. Maksymalny łączny rozmiar aplikacji w dowolnej wersji wygenerowanej z pakietu aplikacji to 4 GB.
  • Aplikacje o rozmiarze przekraczającym 1 GB muszą mieć ustawiony minimalny poziom SDK na 21 lub wyższy.

Jak korzystać z wdrażania AI na urządzeniach za pomocą Google Play

Wdrażanie AI na urządzeniach za pomocą Google Play korzysta z pakietów AI. Modele niestandardowe, które są gotowe do dystrybucji, pakujesz w pakiety AI w pakiecie aplikacji. Możesz wybrać, czy pakiet AI ma być dostarczany podczas instalacji, w trybie szybkiego pobierania czy na żądanie.

Dzięki pakowaniu pakietów AI z pakietem aplikacji możesz korzystać ze wszystkich istniejących narzędzi do testowania i publikowania w Google Play, takich jak ścieżki testów i wdrażanie etapowe, aby zarządzać dystrybucją aplikacji za pomocą modeli niestandardowych.

Pakiety AI są aktualizowane razem z plikiem binarnym aplikacji. Jeśli nowa wersja aplikacji nie wprowadza zmian w pakiecie AI, proces automatycznego stosowania poprawek w Google Play sprawi, że użytkownik nie będzie musiał ponownie pobierać pakietu. Podczas aktualizowania aplikacji Google Play pobierze tylko to, co się zmieniło.

Pakiety AI zawierają tylko modele. Biblioteki Java/Kotlin i biblioteki natywne są niedozwolone. Jeśli musisz dostarczyć biblioteki lub kod, aby uruchomić model ML, przenieś je do modułu podstawowego lub modułu funkcji. Możesz skonfigurować moduł funkcji tak, aby miał takie same ustawienia pobierania i kierowania jak pakiet AI.

Korzystanie z LiteRT i MediaPipe z pakietami AI

Możesz używać LiteRT i MediaPipe z pakietami AI. Zapakuj model w pakiet AI, a następnie uzyskaj do niego dostęp, postępując zgodnie z instrukcjami dotyczącymi pakietów instalowanych w czasie instalacji lub pakietów instalowanych po instalacji i na żądanie.

Więcej informacji:

Pierwsze kroki z pakietami AI

Oto ogólne informacje o tym, jak zacząć korzystać z wdrażania AI na urządzeniach za pomocą Google Play:

  1. Spakuj modele w pakiety AI w pakiecie Android App Bundle i określ, jak mają być dostarczane.
  2. [Opcjonalnie] Jeśli chcesz dostarczać różne modele na różne urządzenia, możesz skonfigurować kierowanie na urządzenia w przypadku pakietów AI. Możesz na przykład dostarczyć pakiet AI A na konkretny model urządzenia, pakiet AI B na urządzenia z co najmniej 6 GB pamięci RAM, a na pozostałe urządzenia nie dostarczać żadnego modelu.
  3. [Opcjonalnie] Jeśli używasz dostarczania na żądanie lub szybkiego dostarczania, zintegruj z aplikacją bibliotekę Play AI Delivery, aby w razie potrzeby pobierać pakiety AI.
  4. Przetestuj i opublikuj pakiet aplikacji w Google Play.

Sprawdzanie wersji wtyczki Androida do obsługi Gradle

Aby używać pakietów AI, upewnij się, że wersja wtyczki Androida do obsługi Gradle (AGP) to co najmniej 8.8. Ta wersja jest dołączona do Android Studio Ladybug 2.

Wyodrębnianie modelu do pakietu AI

Android Studio nie jest wymagane do wykonania poniższych czynności.

  1. W katalogu najwyższego poziomu projektu utwórz katalog dla pakietu AI. Ta nazwa katalogu jest używana jako nazwa pakietu AI. Nazwy pakietów AI muszą zaczynać się od litery i mogą zawierać tylko litery, cyfry i podkreślenia.

  2. W katalogu pakietu AI utwórz plik build.gradle i dodaj do niego ten kod. Pamiętaj, aby podać nazwę pakietu AI i tylko jeden typ dostawy:

    // In the AI pack's build.gradle file:
plugins {
  id 'com.android.ai-pack'
}

aiPack {
    packName = "ai-pack-name" // Directory name for the AI pack
    dynamicDelivery {
        deliveryType = "[ install-time | fast-follow | on-demand ]"
    }
}

  3. W pliku build.gradle aplikacji projektu dodaj nazwę każdego pakietu AI w projekcie, jak pokazano poniżej:

    // In the app build.gradle file:
android {
    ...
    assetPacks = [":ai-pack-name", ":ai-pack2-name"]
}

  4. W pliku settings.gradle projektu uwzględnij wszystkie pakiety AI w projekcie, jak pokazano poniżej:

    // In the settings.gradle file:
include ':app'
include ':ai-pack-name'
include ':ai-pack2-name'

  5. W pakiecie AI utwórz katalog src/main/assets/.

  6. Umieść modele w katalogu src/main/assets. Możesz tu też tworzyć podkatalogi. Struktura katalogów aplikacji powinna teraz wyglądać tak:

    • build.gradle
    • settings.gradle
    • app/
    • ai-pack-name/build.gradle
    • ai-pack-name/src/main/assets/your-model-directories

  7. Dodaj kod, aby wczytać i uruchomić modele. Sposób, w jaki to zrobisz, zależy od trybu dostarczania pakietów AI. Poniżej znajdziesz instrukcje dotyczące czasu instalacji i szybkiego pobierania/na żądanie.

  8. [Opcjonalnie] Skonfiguruj kierowanie na urządzenia, aby dostarczać różne modele na różne urządzenia.

  9. Tworzenie pakietu Android App Bundle za pomocą Gradle W wygenerowanym pakiecie aplikacji katalog na poziomie głównym zawiera teraz te elementy:

    • ai-pack-name/manifest/AndroidManifest.xml: konfiguruje identyfikator i tryb dostarczania pakietu AI
    • ai-pack-name/assets/your-model-directories: katalog zawierający wszystkie zasoby dostarczone w ramach pakietu AI.

    Gradle generuje plik manifestu dla każdego pakietu AI i tworzy katalog assets/.

Konfigurowanie przesyłania w czasie instalacji

Pakiety AI skonfigurowane jako instalowane w czasie instalacji są dostępne natychmiast po uruchomieniu aplikacji. Aby uzyskać dostęp do pakietów AI udostępnianych w tym trybie, użyj interfejsu Java AssetManager API:

import android.content.res.AssetManager;
...
Context context = createPackageContext("com.example.app", 0);
AssetManager assetManager = context.getAssets();
InputStream is = assetManager.open("model-name");

Konfigurowanie szybkiego pobierania i dostarczania na żądanie

Aby pobrać pakiety AI z szybką dostawą lub dostawą na żądanie, użyj biblioteki Play AI Delivery.

Zadeklaruj zależność od biblioteki Play AI Delivery

W pliku build.gradle aplikacji zadeklaruj zależność od biblioteki Play AI Delivery:

dependencies {
  ...
  implementation "com.google.android.play:ai-delivery:0.1.1-alpha01"
}

Sprawdź stan

Każdy pakiet AI jest przechowywany w osobnym folderze w pamięci wewnętrznej aplikacji. Aby określić folder główny pakietu AI, użyj metody getPackLocation(). Ta metoda zwraca te wartości:

Zwracana wartość Stan
Prawidłowy obiekt AiPackLocation. Folder główny pakietu AI jest gotowy do natychmiastowego dostępu pod adresem assetsPath()
null Nieznany pakiet AI lub pakiety AI są niedostępne

Uzyskiwanie informacji o pobieraniu pakietów AI

Użyj metody
getPackStates(), aby określić rozmiar pobierania i sprawdzić, czy pakiet jest już pobierany.

Task<AiPackStates> getPackStates(List<String> packNames)

getPackStates() to metoda asynchroniczna, która zwraca Task<AiPackStates>. Metoda packStates() obiektu AiPackStates zwraca Map<String, AiPackState>. Ta mapa zawiera stan każdego żądanego pakietu AI, którego kluczem jest jego nazwa:

Map<String, AiPackState> AiPackStates#packStates()

Ostateczne żądanie wygląda tak:

final String aiPackName = "myAiPackName";

aiPackManager
    .getPackStates(Collections.singletonList(aiPackName))
    .addOnCompleteListener(new OnCompleteListener<AiPackStates>() {
        @Override
        public void onComplete(Task<AiPackStates> task) {
            AiPackStates aiPackStates;
            try {
                aiPackStates = task.getResult();
                AiPackState aiPackState =
                    aiPackStates.packStates().get(aiPackName);
            } catch (RuntimeExecutionException e) {
                Log.d("MainActivity", e.getMessage());
                return;
            });

Te metody AiPackState podają rozmiar pakietu AI, ilość pobranych do tej pory danych (jeśli jest to wymagane) oraz ilość danych już przesłanych do aplikacji:

Aby sprawdzić stan pakietu AI, użyj metody status(), która zwraca stan jako liczbę całkowitą odpowiadającą stałemu polu w klasie AiPackStatus. Pakiet AI, który nie został jeszcze zainstalowany, ma stan AiPackStatus.NOT_INSTALLED.

Jeśli żądanie się nie powiedzie, użyj metody errorCode(), której zwracana wartość odpowiada stałemu polu w klasie AiPackErrorCode.

Zainstaluj

Użyj metody fetch(), aby pobrać pakiet AI po raz pierwszy lub wywołać aktualizację pakietu AI:

Task<AiPackStates> fetch(List<String> packNames)

Ta metoda zwraca obiekt AiPackStates zawierający listę pakietów oraz ich początkowe stany i rozmiary pobierania. Jeśli pakiet AI, o który poproszono za pomocą fetch(), jest już pobierany, zwracany jest stan pobierania i nie rozpoczyna się dodatkowe pobieranie.

Monitorowanie stanów pobierania

Aby śledzić postęp instalacji pakietów AI, zaimplementuj AiPackStateUpdateListener. Aktualizacje stanu są podzielone według pakietów, aby ułatwić śledzenie stanu poszczególnych pakietów AI. Możesz zacząć korzystać z dostępnych pakietów AI, zanim zostaną pobrane wszystkie inne pliki, o które prosisz.

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)
pobierania dużych plików,

Jeśli rozmiar pobieranych danych przekracza 200 MB, a użytkownik nie jest połączony z Wi-Fi, pobieranie nie rozpocznie się, dopóki użytkownik nie wyrazi wyraźnej zgody na pobieranie przy użyciu komórkowego połączenia transmisji danych. Podobnie, jeśli pobierany plik jest duży, a użytkownik straci połączenie z Wi-Fi, pobieranie zostanie wstrzymane i będzie wymagało wyraźnej zgody na kontynuowanie przy użyciu komórkowego połączenia danych. Wstrzymany pakiet ma stan WAITING_FOR_WIFI. Aby uruchomić proces interfejsu, który prosi użytkownika o zgodę, użyj metody showConfirmationDialog().

Pamiętaj, że jeśli aplikacja nie wywoła tej metody, pobieranie zostanie wstrzymane i zostanie wznowione automatycznie dopiero wtedy, gdy użytkownik ponownie połączy się z połączeniem Wi-Fi.

Wymagana zgoda użytkownika

Jeśli pakiet ma stan REQUIRES_USER_CONFIRMATION, pobieranie nie rozpocznie się, dopóki użytkownik nie zaakceptuje okna wyświetlanego za pomocą metody showConfirmationDialog(). Ten stan może wystąpić, gdy aplikacja nie jest rozpoznawana przez Google Play, np. jeśli została zainstalowana z nieoficjalnego źródła. Pamiętaj, że wywołanie showConfirmationDialog() w tym przypadku spowoduje zaktualizowanie aplikacji. Po aktualizacji musisz ponownie poprosić o pakiety AI.

Oto przykładowa implementacja detektora:

AiPackStateUpdateListener aiPackStateUpdateListener = new AiPackStateUpdateListener() {
    private final ActivityResultLauncher<IntentSenderRequest> activityResultLauncher =
      registerForActivityResult(
          new ActivityResultContracts.StartIntentSenderForResult(),
          new ActivityResultCallback<ActivityResult>() {
            @Override
            public void onActivityResult(ActivityResult result) {
              if (result.getResultCode() == RESULT_OK) {
                Log.d(TAG, "Confirmation dialog has been accepted.");
              } else if (result.getResultCode() == RESULT_CANCELED) {
                Log.d(TAG, "Confirmation dialog has been denied by the user.");
              }
            }
          });

    @Override
    public void onStateUpdate(AiPackState aiPackState) {
      switch (aiPackState.status()) {
        case AiPackStatus.PENDING:
          Log.i(TAG, "Pending");
          break;

        case AiPackStatus.DOWNLOADING:
          long downloaded = aiPackState.bytesDownloaded();
          long totalSize = aiPackState.totalBytesToDownload();
          double percent = 100.0 * downloaded / totalSize;

          Log.i(TAG, "PercentDone=" + String.format("%.2f", percent));
          break;

        case AiPackStatus.TRANSFERRING:
          // 100% downloaded and assets are being transferred.
          // Notify user to wait until transfer is complete.
          break;

        case AiPackStatus.COMPLETED:
          // AI pack is ready to use. Run the model.
          break;

        case AiPackStatus.FAILED:
          // Request failed. Notify user.
          Log.e(TAG, aiPackState.errorCode());
          break;

        case AiPackStatus.CANCELED:
          // Request canceled. Notify user.
          break;

        case AiPackStatus.WAITING_FOR_WIFI:
        case AiPackStatus.REQUIRES_USER_CONFIRMATION:
          if (!confirmationDialogShown) {
            aiPackManager.showConfirmationDialog(activityResultLauncher);
            confirmationDialogShown = true;
          }
          break;

        case AiPackStatus.NOT_INSTALLED:
          // AI pack is not downloaded yet.
          break;
        case AiPackStatus.UNKNOWN:
          Log.wtf(TAG, "AI pack status unknown")
          break;
      }
    }
}

Możesz też użyć metody getPackStates(), aby sprawdzić stan bieżących pobrań. AiPackStates zawiera postęp pobierania, stan pobierania i kody błędów.

Dostęp do pakietów AI

Dostęp do pakietu AI możesz uzyskać za pomocą wywołań systemu plików, gdy prośba o pobranie osiągnie stan COMPLETED. Użyj metody getPackLocation(), aby uzyskać folder główny pakietu AI.

Pakiety AI są przechowywane w katalogu assets w katalogu głównym pakietów AI. Ścieżkę do katalogu assets możesz uzyskać za pomocą metody assetsPath(). Aby uzyskać ścieżkę do konkretnego komponentu, użyj tej metody:

private String getAbsoluteAiAssetPath(String aiPack, String relativeAiAssetPath) {
    AiPackLocation aiPackPath = aiPackManager.getPackLocation(aiPack);

    if (aiPackPath == null) {
        // AI pack is not ready
        return null;
    }

    String aiAssetsFolderPath = aiPackPath.assetsPath();
    // equivalent to: FilenameUtils.concat(aiPackPath.path(), "assets");
    String aiAssetPath = FilenameUtils.concat(aiAssetsFolderPath, relativeAiAssetPath);
    return aiAssetPath;
}

Konfigurowanie kierowania na urządzenia

Możesz postępować zgodnie z instrukcjami kierowania na urządzenia, aby określić urządzenia lub grupy urządzeń, które powinny otrzymać pakiety AI.

Inne metody interfejsu Play AI Delivery API

Oto kilka dodatkowych metod interfejsu API, których możesz użyć w aplikacji.

Anuluj prośbę

Użyj cancel(), aby anulować aktywną prośbę o pakiet AI. Pamiętaj, że ta prośba jest operacją wykonywaną w miarę możliwości.

Usuwanie pakietu AI

Aby zaplanować usunięcie pakietu AI, użyj removePack().

Uzyskiwanie lokalizacji wielu pakietów AI

Użyj getPackLocations(), aby zbiorczo sprawdzić stan wielu pakietów AI. Zwróci to mapę pakietów AI i ich lokalizacji. Mapa zwracana przez getPackLocations() zawiera wpis dotyczący każdego pakietu, który jest obecnie pobrany i aktualny.

Kierowanie na urządzenia

Kierowanie na urządzenia zapewnia większą kontrolę nad tym, które części pakietu aplikacji są dostarczane na określone urządzenia. Możesz na przykład zadbać o to, aby duży model był dostarczany tylko na urządzenia z dużą ilością pamięci RAM, lub dostarczać różne wersje modelu na różne urządzenia.

Możesz kierować reklamy na takie właściwości urządzeń jak:

Omówienie wymaganych czynności

Aby włączyć kierowanie na urządzenia, wykonaj te czynności:

  1. Zdefiniuj grupy urządzeń w pliku XML.
  2. Określ, które części pakietu mają być przeznaczone dla poszczególnych grup urządzeń.
  3. [Opcjonalnie] Przetestuj konfigurację lokalnie.
  4. Prześlij pakiet (zawierający plik XML) do Google Play.

Sprawdzanie wersji wtyczki Androida do obsługi Gradle

Aby korzystać z kierowania na urządzenia, upewnij się, że wtyczka Androida do obsługi Gradle (AGP) jest w wersji co najmniej 8.10.0. Jest on dołączony do Android Studio (Meerkat 2 i nowszych wersji). Pobierz najnowszą stabilną wersję Android Studio.

Włącz tę funkcję we wtyczce Androida do obsługi Gradle

Kierowanie na urządzenia musi być wyraźnie włączone w pliku gradle.properties:

android.experimental.enableDeviceTargetingConfigApi=true

Tworzenie pliku XML konfiguracji kierowania na urządzenia

Plik konfiguracji kierowania na urządzenia to plik XML, w którym definiujesz niestandardowe grupy urządzeń. Możesz na przykład zdefiniować grupę urządzeń o nazwie qti_v79, która zawiera wszystkie urządzenia z układem SOC Qualcomm SM8750:

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="qti_v79">
        <config:device-selector>
            <config:system-on-chip manufacturer="QTI" model="SM8750"/>
        </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

Grupa urządzeń składa się z maksymalnie 5 selektorów urządzeń. Urządzenie jest uwzględniane w grupie urządzeń, jeśli spełnia warunki dowolnego z selektorów urządzeń.

Selektor urządzeń może mieć co najmniej 1 właściwość urządzenia. Urządzenie jest wybierane, jeśli pasuje do wszystkich właściwości urządzenia w selektorze.

Jeśli urządzenie pasuje do kilku grup, zostaną mu wyświetlone treści dla grupy, która jest zdefiniowana jako pierwsza w pliku XML. Kolejność, w jakiej definiujesz grupy w pliku XML, określa ich priorytet.

Jeśli urządzenie nie pasuje do żadnej grupy, zostanie przypisane do domyślnej grupy „inne”. Ta grupa jest generowana automatycznie i nie powinna być definiowana bezpośrednio.

Dostępne właściwości urządzenia

  • device_ram: wymagania dotyczące pamięci RAM urządzenia.
    • min_bytes (włącznie): minimalna wymagana ilość pamięci RAM (w bajtach).
    • max_bytes (exclusive): maksymalna wymagana ilość pamięci RAM (w bajtach).
  • included_device_ids: modele urządzeń, które mają być uwzględnione w tym selektorze (maksymalnie 10 000 identyfikatorów device_id na grupę). Ta właściwość jest spełniona, jeśli urządzenie pasuje do dowolnego identyfikatora device_id na liście.
    • build_brand: producent urządzenia,
    • build_device: kod modelu urządzenia,
  • excluded_device_ids: modele urządzeń, które mają zostać wykluczone w tym selektorze (maksymalnie 10 000 identyfikatorów device_id na grupę). Ta właściwość jest spełniona, jeśli urządzenie nie pasuje do żadnego identyfikatora device_id na liście.
    • build_brand: producent urządzenia,
    • build_device: kod modelu urządzenia,

  • required_system_features: funkcje, które musi mieć urządzenie, aby zostało uwzględnione przez ten selektor (maksymalnie 100 funkcji na grupę). Aby spełnić ten warunek, urządzenie musi mieć wszystkie funkcje systemowe z tej listy.

    Lista funkcji systemowych

    • name: funkcja systemowa.

  • forbidden_system_features: funkcje, których urządzenie nie może mieć, aby zostało uwzględnione przez ten selektor (maksymalnie 100 funkcji na grupę). Jeśli urządzenie ma którąkolwiek z funkcji systemowych z tej listy, nie spełnia tego warunku.

    Lista funkcji systemowych

    • name: funkcja systemowa.

  • system-on-chip: układy SOC, które mają być uwzględnione w tym selektorze. Aby spełnić wymagania tej właściwości, urządzenie musi mieć dowolny układ z tej listy.

Oto przykład pokazujący wszystkie możliwe właściwości urządzenia:

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="myCustomGroup1">
      <config:device-selector ram-min-bytes="8000000000">
        <config:included-device-id brand="google" device="redfin"/>
        <config:included-device-id brand="google" device="sailfish"/>
        <config:included-device-id brand="good-brand"/>
        <config:excluded-device-id brand="google" device="caiman"/>
        <config:system-on-chip manufacturer="Sinclair" model="ZX80"/>
        <config:system-on-chip manufacturer="Commodore" model="C64"/>
      </config:device-selector>
      <config:device-selector ram-min-bytes="16000000000"/>
    </config:device-group>

    <config:device-group name="myCustomGroup2">
      <config:device-selector ram-min-bytes="4000000000" ram-max-bytes="8000000000">
        <config:required-system-feature name="android.hardware.bluetooth"/>
        <config:required-system-feature name="android.hardware.location"/>
        <config:forbidden-system-feature name="android.hardware.camera"/>
        <config:forbidden-system-feature name="mindcontrol.laser"/>
      </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

Oficjalne kody producenta i modelu urządzenia

Prawidłowy format kodu producenta i modelu urządzenia możesz znaleźć w katalogu urządzeń w Konsoli Google Play. Możesz to zrobić na 2 sposoby:

  • Sprawdź poszczególne urządzenia w katalogu urządzeń i znajdź producenta oraz kod modelu w miejscach pokazanych w przykładzie poniżej (w przypadku telefonu Google Pixel 4a producentem jest „Google”, a kodem modelu – „sunfish”).

    Strona Pixela 4a w katalogu urządzeń

    Strona Pixela 4a w katalogu urządzeń

  • pobrać plik CSV z obsługiwanymi urządzeniami i użyć wartości z kolumn Manufacturer (Producent) i Model Code (Kod modelu) odpowiednio w polach build_brand i build_device;

Dołącz plik konfiguracji kierowania na urządzenia do pakietu aplikacji

Dodaj do pliku build.gradle głównego modułu te informacje:

android {
  ...
  bundle {
    deviceTargetingConfig = file('device_targeting_config.xml')
    deviceGroup {
      enableSplit = true   // split bundle by #group
      defaultGroup = "other"  // group used for standalone APKs
    }
  }
  ...
}

device_targeting_config.xml to ścieżka do pliku konfiguracji względem modułu głównego. Dzięki temu plik konfiguracji zostanie spakowany razem z pakietem aplikacji.

Klauzula deviceGroup zapewnia, że pliki APK wygenerowane z pakietu są dzielone według grup urządzeń.

Używanie kierowania na urządzenia w przypadku pakietów AI

Możesz zoptymalizować rozmiar na urządzeniach, dostarczając duże modele tylko na urządzenia, które mogą je obsługiwać.

Podziel pakiety AI na grupy urządzeń, korzystając z istniejących katalogów pakietów AI utworzonych w ostatnim kroku, i dodaj do odpowiednich folderów (jak opisano poniżej) przyrostek #group_myCustomGroup1, #group_myCustomGroup2 itd. Podczas korzystania z pakietów AI w aplikacji nie musisz adresować folderów według przyrostka (innymi słowy, przyrostek jest automatycznie usuwany podczas procesu kompilacji).

Po wykonaniu poprzedniego kroku może to wyglądać tak:

...
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup1/
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup2/
...

W tym przykładzie odwołujesz się do ai-pack-name/assets/image-classifier/ bez żadnych przyrostków.

Urządzenia w grupie myCustomGroup1 otrzymają wszystkie zasoby z grupy image-classifier#group_myCustomGroup1/, a urządzenia w grupie myCustomGroup2 otrzymają wszystkie zasoby z grupy image-classifier#group_myCustomGroup2/.

Urządzenia, które nie należą do myCustomGroup1 ani myCustomGroup2, otrzymają pusty pakiet ai-pack-name.

Dzieje się tak, ponieważ urządzenia, które nie pasują do żadnej grupy urządzeń, otrzymają domyślny wariant pakietu AI. Obejmuje to wszystko, co nie znajduje się w katalogu z plikiem #group_suffix.

Po pobraniu pakietu AI możesz sprawdzić, czy model jest obecny, używając AssetManager w przypadku pakietów instalowanych podczas pobierania aplikacji lub AiPackManager w przypadku pakietów pobieranych po instalacji i na żądanie. Przykłady, jak to zrobić, są pokazane dla wszystkich trybów dostawy w przykładowej aplikacji.

Używanie kierowania na urządzenia w przypadku modułów funkcji

Możesz też używać kierowania na urządzenia w przypadku modułów funkcji. Zamiast dzielić moduły funkcji na podgrupy według grupy urządzeń, określasz, czy cały moduł ma być dostarczany na podstawie przynależności do grupy urządzeń.

Aby dostarczyć moduł funkcji na urządzenia, które należą do grupy myCustomGroup1 lub myCustomGroup2, zmodyfikuj jego AndroidManifest.xml:

<manifest ...>
  ...
  <dist:module dist:title="...">
    <dist:delivery>
      <dist:install-time>
        <dist:conditions>
          <dist:device-groups>
            <dist:device-group dist:name="myCustomGroup1"/>
            <dist:device-group dist:name="myCustomGroup2"/>
          </dist:device-groups>
          ...
        </dist:conditions>
      </dist:install-time>
    </dist:delivery>
  </dist:module>
  ...
</manifest>

Testowanie lokalne

Zanim utworzysz wersję nowego pakietu, możesz przetestować go lokalnie za pomocą wewnętrznego udostępniania aplikacji lub narzędzia bundletool.

Wewnętrzne udostępnianie aplikacji

Wewnętrzne udostępnianie aplikacji umożliwia użycie pakietu aplikacji do szybkiego wygenerowania adresu URL, który można kliknąć na urządzeniu lokalnym, aby zainstalować dokładnie to, co Google Play zainstalowałby na tym urządzeniu, gdyby ta wersja aplikacji była aktywna na ścieżce testowej lub produkcyjnej.

Zapoznaj się z instrukcjami dotyczącymi wewnętrznego udostępniania aplikacji.

Bundletool

Możesz też wygenerować pliki APK za pomocą narzędzia bundletool (w wersji 1.18.0 lub nowszej) i zainstalować je na urządzeniu z nieoficjalnych źródeł. Aby przetestować aplikację lokalnie za pomocą narzędzia bundletool, wykonaj te czynności:

  1. Utwórz pakiet aplikacji za pomocą Android Studio lub narzędzia bundletool.

  2. Wygeneruj pliki APK z flagą --local-testing:

    java -jar bundletool-all.jar build-apks --bundle=path/to/your/bundle.aab \
  --output=output.apks --local-testing

  3. Podłącz urządzenie i uruchom bundletool, aby zainstalować pliki APK z nieoficjalnych źródeł:

    # Example without Device Targeting Configuration
java -jar bundletool.jar install-apks --apks=output.apks

    # Example with Device Targeting Configuration (you must specify which groups the connected device belongs to)
java -jar bundletool.jar install-apks --apks=output.apks --device-groups=myCustomGroup1,myCustomGroup2

Ograniczenia testowania lokalnego za pomocą narzędzia bundletool

Oto ograniczenia testowania lokalnego za pomocą narzędzia bundletool:

  • Pakiety fast-follow działają jak pakiety on-demand. Oznacza to, że nie zostaną one automatycznie pobrane, gdy aplikacja zostanie zainstalowana z nieoficjalnego źródła. Deweloperzy muszą poprosić o nie ręcznie po uruchomieniu aplikacji. Nie wymaga to żadnych zmian w kodzie aplikacji.
  • Pakiety są pobierane z pamięci zewnętrznej, a nie z Google Play, więc nie możesz przetestować, jak kod zachowuje się w przypadku błędów sieci.
  • Testowanie lokalne nie obejmuje scenariusza oczekiwania na Wi-Fi.
  • Aktualizacje nie są obsługiwane. Przed zainstalowaniem nowej wersji kompilacji ręcznie odinstaluj poprzednią wersję.

Sprawdzanie, czy instalowane są prawidłowe pliki APK

Użyj tej metody, aby upewnić się, że na urządzeniu są zainstalowane tylko prawidłowe pliki APK

adb shell pm path {packageName}

Powinno pojawić się coś takiego:

package:{...}/base.apk
package:{...}/split_config.en.apk
package:{...}/split_config.xxhdpi.apk
package:{...}/split_main_ai-pack-name.apk
package:{...}/split_main_ai-pack-name.config.group_myCustomGroup1.apk

Pamiętaj, że na tej liście zobaczysz tylko pliki APK utworzone z modułów funkcji i pakietów AI instalowanych podczas pobierania. Pakiety AI na żądanie i pakiety AI do szybkiego pobrania nie są instalowane jako pliki APK.

Testowanie i publikowanie w Google Play

Zalecamy kompleksowe przetestowanie aplikacji w Google Play na ścieżce testu wewnętrznego.

Gdy to zrobisz, możesz stopniowo publikować aktualizację aplikacji w wersji produkcyjnej, korzystając z wdrażania etapowego.

Przykładowa aplikacja korzystająca z wdrażania AI na urządzeniach za pomocą Google Play

Pobierz przykładową aplikację.

Pokazuje, jak używać poszczególnych trybów dostarczania oraz konfiguracji kierowania na urządzenia. Aby rozpocząć, zapoznaj się z sekcją Testowanie lokalne.

Powiązane artykuły

Dowiedz się więcej o pakietach Android App Bundle i zapoznaj się z dokumentacją AI Delivery SDK.