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

Wprowadzenie

Play for On-device AI zapewnia korzyści wynikające z pakietów Android App Bundle i przesyłania w Google Play w przypadku dystrybucji niestandardowych modeli ML. Dzięki temu możesz zwiększyć wydajność modelu przy mniejszej złożoności ekosystemu urządzeń bez dodatkowych kosztów. Umożliwia publikowanie w Google Play pojedynczego artefaktu zawierającego kod, zasoby i modele ML oraz wybieranie spośród wielu trybów dostarczania i opcji kierowania.

Zalety

  • Prześlij pojedynczy artefakt publikacji do Google Play i przekaż Play bez dodatkowych opłat hosting, dostarczanie, aktualizacje i kierowanie.
  • Udostępniaj modele ML w momencie instalacji, w trybie fast-follow lub na żądanie.
    • Dostarczanie w momencie instalacji może zagwarantować, że bardzo duży model będzie dostępny po otwarciu aplikacji. Model zostanie zainstalowany jako plik APK.
    • Przesyłanie bezpośrednio po instalacji odbywa się automatycznie w tle po zainstalowaniu aplikacji. Użytkownicy mogą otworzyć aplikację, zanim model zostanie w całości pobrany. Model zostanie pobrany do pamięci wewnętrznej aplikacji.
    • Dostawa na żądanie umożliwia wysyłanie żądań dotyczących modelu w czasie działania, co jest przydatne, jeśli model jest wymagany tylko w przypadku określonych ścieżek użytkownika. Model zostanie pobrany do pamięci wewnętrznej aplikacji.
  • Dostarczaj warianty modeli ML, które są przeznaczone dla konkretnych urządzeń na podstawie modelu urządzenia, właściwości systemu lub pamięci RAM.
  • Dzięki automatycznemu poprawianiu plików w Google Play aktualizacje aplikacji są niewielkie i zoptymalizowane, co oznacza, że pobierane są tylko różnice w plikach.

co należy wziąć pod uwagę

  • Korzystając z usługi Play w przypadku AI na urządzeniu, akceptujesz warunki Umowy dystrybucyjnej dla deweloperów w Google Play oraz Warunki korzystania z pakietu SDK Play Core.
  • Modele pobrane przez Play na potrzeby AI na urządzeniu powinny być używane tylko przez Twoje aplikacje. Modele nie powinny być oferowane innym aplikacjom.
  • Pojedyncze pakiety AI mogą mieć rozmiar do 1,5 GB, w zależności od rozmiaru skompresowanego pliku do pobrania. Maksymalny łączny rozmiar aplikacji w dowolnej wersji wygenerowanej z pakietu aplikacji to 4 GB.
  • Aplikacje o rozmiarze powyżej 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

W ramach usługi Play for On-device AI używane są pakiety AI. W pakietach AI w pakiecie aplikacji umieszczasz modele niestandardowe gotowe do dystrybucji. Możesz wybrać, czy pakiet AI ma być przesyłany w momencie instalacji, w trybie fast-follow czy na żądanie.

Pakując pakiety AI z pakietem aplikacji, możesz korzystać ze wszystkich dostępnych w Google Play narzędzi do testowania i wdrażania, takich jak ścieżki testowe i wdrażanie etapowe, aby zarządzać dystrybucją aplikacji z modelami niestandardowymi.

Pakiety AI są aktualizowane razem z plikiem binarnym aplikacji. Jeśli nowa wersja aplikacji nie wprowadza zmian w pakiecie AI, automatyczny proces tworzenia poprawek w Google Play sprawi, że użytkownik nie będzie musiał go ponownie pobierać. Podczas aktualizacji aplikacji Google Play pobierze tylko zmienione elementy.

Pakiety AI zawierają tylko modele. Biblioteki Java/Kotlin i biblioteki natywne są niedozwolone. Jeśli musisz dostarczyć biblioteki lub kod do uruchomienia modelu ML, przenieś je do modułu podstawowego lub modułu funkcji. Moduł funkcji możesz skonfigurować 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. Spakuj model w pakiet AI, a następnie uzyskaj do niego dostęp, korzystając z instrukcji dotyczących pakietów instalowanych w momencie instalacji lub pakietów fast-follow i on-demand.

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 aplikacji na Androida 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 wszystkie pozostałe urządzenia nie dostarczać żadnego modelu.
  3. [Opcjonalnie] Jeśli korzystasz z przesyłania na żądanie lub szybkiego przesyłania, zintegruj z aplikacją bibliotekę Play AI Delivery Library, aby pobierać pakiety AI w razie potrzeby.
  4. Przetestuj i opublikuj pakiet aplikacji w Google Play.

Sprawdzanie wersji wtyczki Androida do obsługi Gradle

Aby korzystać z pakietów AI, upewnij się, że masz wtyczkę Androida do obsługi Gradle (AGP) w wersji co najmniej 8.8. Ta wersja jest dołączona do Androida Studio Ladybug 2.

Wyodrębnianie modelu do pakietu AI

Do wykonania tych czynności nie jest wymagane Android Studio.

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

  2. W katalogu pakietu AI utwórz plik build.gradle i dodaj ten kod. Podaj 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 nazwy wszystkich pakietów 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 umieść 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 wykonania tej czynności zależy od trybu dostawy pakietów AI. Poniżej znajdziesz instrukcje dotyczące instalacji i szybkiego śledzenia/na żądanie.

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

  9. Utwórz pakiet Android App Bundle za pomocą Gradle W wygenerowanym pakiecie aplikacji katalog najwyższego poziomu zawiera teraz te elementy:

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

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

Konfigurowanie dostawy w momencie instalacji

Pakiety AI skonfigurowane jako instalowane w momencie 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 przesyłania w trybach fast-follow i on-demand

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

Deklarowanie zależności od biblioteki Play AI Delivery Library

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. Użyj metody getPackLocation(), aby określić folder główny pakietu AI. 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

Informacje 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 obiekt Task<AiPackStates>. Metoda packStates() obiektu AiPackStates zwraca Map<String, AiPackState>. Ta mapa zawiera stan każdego żądanego pakietu AI, z nazwą jako kluczem:

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 metodyAiPackState podają rozmiar pakietu AI, pobraną do tej pory ilość (jeśli została o to poproszona) oraz ilość już przesłaną do aplikacji:

Aby uzyskać 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 jest jeszcze zainstalowany, ma stan AiPackStatus.NOT_INSTALLED.

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

Zainstaluj

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

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

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

Monitorowanie stanów pobierania

Aby śledzić postępy instalacji pakietów AI, musisz wdrożyć AiPackStateUpdateListener. Aktualizacje stanu są podzielone na pakiety, aby umożliwić śledzenie stanu poszczególnych pakietów AI. Możesz zacząć korzystać z dostępnych pakietów AI, zanim zostaną ukończone wszystkie inne pobierania związane z Twoją prośbą.

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

Jeśli pobieranie przekracza 200 MB, a użytkownik nie korzysta 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 pobieranie jest duże, a użytkownik utraci połączenie Wi-Fi, pobieranie zostanie wstrzymane i do kontynuowania pobierania przy użyciu mobilnej transmisji danych wymagana będzie wyraźna zgoda. Wstrzymany pakiet ma stanWAITING_FOR_WIFI. Aby wywołać interfejs, który poprosi użytkownika o wyrażenie zgody, użyj metody showConfirmationDialog().

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

Wymagane potwierdzenie użytkownika

Jeśli pakiet ma stan REQUIRES_USER_CONFIRMATION, pobieranie nie zostanie rozpoczęte, dopóki użytkownik nie zaakceptuje okna dialogowego wyświetlanego z ikoną showConfirmationDialog(). Ten stan może wystąpić, gdy aplikacja nie jest rozpoznawana przez Google Play, np. jeśli została zainstalowana z innego urządzenia. Pamiętaj, że wywołanie showConfirmationDialog() w tym przypadku spowoduje zaktualizowanie aplikacji. Po aktualizacji musisz ponownie poprosić o pakiety AI.

Oto przykładowa implementacja odbiornika:

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

Po osiągnięciu przez żądanie pobrania stanu COMPLETED możesz uzyskać dostęp do pakietu AI za pomocą wywołań systemu plików. Aby uzyskać dostęp do folderu głównego pakietu AI, użyj metody getPackLocation().

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

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

Aby określić urządzenia lub grupy urządzeń, które mają otrzymywać pakiety AI, postępuj zgodnie z instrukcjami dotyczącymi kierowania na urządzenia.

Inne metody interfejsu Play AI Delivery API

Oto dodatkowe metody interfejsu API, których możesz używać 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

Użyj polecenia removePack() , aby zaplanować usunięcie pakietu AI.

Pobieranie lokalizacji wielu pakietów AI

Użyj getPackLocations() aby zbiorczo sprawdzić stan wielu pakietów AI, co zwraca mapę pakietów AI i ich lokalizacji. Mapa zwracana przez getPackLocations() zawiera wpis dla 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 właściwości urządzeń, takie 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ć kierowane do 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 masz wtyczkę Androida do obsługi Gradle (AGP) w wersji co najmniej 8.10.0. Jest on dołączony do Androida Studio (wersja Meerkat 2 i nowsze). Pobierz najnowszą stabilną wersję Android Studio.

Włączanie tej funkcji 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 nazwieqti_v79, która zawiera wszystkie urządzenia z układem 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 dowolny z jej selektorów.

Selektor urządzeń może mieć jedną lub więcej właściwości urządzenia. Urządzenie jest wybierane, jeśli pasuje do wszystkich właściwości urządzenia selektora.

Jeśli urządzenie pasuje do kilku grup, wyświetli się na nim treść grupy, która jest zdefiniowana jako pierwsza w pliku XML. Kolejność, w jakiej zdefiniujesz grupy w pliku XML, określa 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 jawnie.

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

  • device_ram: wymagania dotyczące pamięci RAM urządzenia
    • min_bytes (włącznie): minimalna wymagana pamięć RAM (w bajtach).
    • max_bytes (exclusive): maksymalna wymagana pamięć RAM (w bajtach)
  • included_device_ids: modele urządzeń, które mają być uwzględnione w tym selektorze(maksymalnie 10 000 identyfikatorów urządzeń w grupie). Warunek jest spełniony, 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 urządzeń w grupie). Ten warunek jest spełniony, 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 urządzenie musi mieć, aby kwalifikować się do wyboru przez ten selektor (maksymalnie 100 funkcji w grupie). Aby spełnić ten warunek, urządzenie musi mieć wszystkie funkcje systemu z tej listy.

    System Lista funkcji

    • name: funkcja systemowa;

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

    System Lista funkcji

    • name: funkcja systemowa;

  • układ SOC: układy SOC, które mają być uwzględnione w tym selektorze. Aby spełnić ten warunek, 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:

  • Sprawdzanie poszczególnych urządzeń za pomocą katalogu urządzeń i znajdowanie kodu producenta i modelu w miejscach pokazanych w przykładzie poniżej (w przypadku Google Pixel 4a producent to „Google”, a kod modelu to „sunfish”).

    strona Pixela 4a w katalogu urządzeń;

    strona Pixela 4a w katalogu urządzeń;

  • Pobierz plik CSV z obsługiwanymi urządzeniami i użyj wartości Manufacturer (Producent) i Model Code (Kod modelu) w polach build_brand i build_device.

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

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 pliku konfiguracji względem modułu głównego. Dzięki temu plik konfiguracji zostanie spakowany z pakietem aplikacji.

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

Korzystanie z kierowania na urządzenia w przypadku pakietów AI

Możesz zachować optymalny rozmiar na urządzeniach, dostarczając duże modele tylko na urządzenia, które mogą je uruchomić.

Podziel pakiety AI według grup urządzeń, korzystając z istniejących katalogów pakietów AI utworzonych w ostatnim kroku i dodając do odpowiednich folderów (jak opisano poniżej) sufiksy #group_myCustomGroup1, #group_myCustomGroup2 itp. Podczas korzystania z pakietów AI w aplikacji nie musisz odwoływać się do folderów za pomocą sufiksu (innymi słowy, sufiks 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łasz się do ai-pack-name/assets/image-classifier/ bez żadnych przyrostków.

Urządzenia w myCustomGroup1 otrzymają wszystkie zasoby z image-classifier#group_myCustomGroup1/, a urządzenia w myCustomGroup2 – wszystkie zasoby z 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ślną wersję pakietu AI. Obejmuje to wszystko, co nie znajduje się w katalogu z #group_suffix.

Po pobraniu pakietu AI możesz sprawdzić, czy model jest dostępny, korzystając z klasy AssetManager w przypadku pakietów instalowanych w momencie instalacji lub z klasy AiPackManager w przypadku pakietów szybkiego dostępu i pakietów na żądanie. Przykłady tego działania są podane dla wszystkich trybów wyświetlania w przykładowej aplikacji.

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

Kierowanie na urządzenia możesz też stosować w przypadku modułów funkcji. Zamiast dzielić moduły funkcji na podgrupy według grup 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 należące do myCustomGroup1 lub myCustomGroup2, zmień 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, korzystając z wewnętrznego udostępniania aplikacji lub narzędzia Bundletool.

Wewnętrzne udostępnianie aplikacji

Wewnętrzne udostępnianie aplikacji umożliwia szybkie wygenerowanie adresu URL na podstawie pakietu aplikacji. Po kliknięciu tego adresu na urządzeniu lokalnym zainstalujesz dokładnie to, co Google Play zainstalowałoby na tym urządzeniu, gdyby ta wersja aplikacji była dostępna w ś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ą bundletool (w wersji 1.18.0 lub nowszej) i wgrać je na urządzenie. Aby przetestować aplikację lokalnie za pomocą narzędzia bundletool:

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

  2. Wygeneruj pliki APK za pomocą flagi --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 wgrać pliki APK:

    # 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 będą one pobierane automatycznie po zainstalowaniu aplikacji z pliku APK. Programiści muszą o nie poprosić 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 sprawdzić, jak Twój 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ę.

Sprawdź, czy instalowane są prawidłowe pliki APK

Aby mieć pewność, że na urządzeniu są instalowane tylko prawidłowe pliki APK, użyj tej metody:

adb shell pm path {packageName}

Powinien pojawić się ekran podobny do tego:

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 pakiety APK utworzone z modułów funkcji i pakietów AI przesyłanych podczas instalacji. Pakiety AI na żądanie i szybkie pakiety AI nie są instalowane jako pliki APK.

Testowanie i publikowanie w Google Play

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

Gdy to zrobisz, możesz stopniowo publikować aktualizację aplikacji w wersji produkcyjnej za pomocą 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 korzystać z poszczególnych trybów wyświetlania reklam oraz konfiguracji kierowania na urządzenia. Aby rozpocząć, zapoznaj się z sekcją testowanie lokalne.

Powiązane artykuły

Dowiedz się więcej o pakietach aplikacji na Androida i zapoznaj się z materiałami referencyjnymi dotyczącymi pakietu SDK AI Delivery.