Play for On-device AI – program wcześniejszego dostępu (EAP)

Wprowadzenie

Play for On-device AI wykorzystuje zalety pakietów Android App Bundle i rozpowszechniania w Google Play do dystrybucji niestandardowych modeli ML, dzięki czemu możesz poprawić wydajność modelu przy mniejszej złożoności ekosystemu bez dodatkowych kosztów. Umożliwia ono publikowanie w Google Play pojedynczego artefaktu zawierającego kod, zasoby i modele uczenia maszynowego oraz wybór spośród wielu opcji dostarczania i kierowania.

Zalety

  • Prześlij jeden artefakt publikowania do Google Play i bezpłatnie deleguj hosting, dostarczanie, aktualizacje i kierowanie do Google Play.
  • Przesyłaj modele ML w momencie instalacji, szybko po instalacji lub na żądanie.
    • Dostarczanie danych w momencie instalacji może zagwarantować, że bardzo duży model będzie dostępny w momencie otwarcia aplikacji. Model zostanie zainstalowany jako plik APK.
    • Przesyłanie bezpośrednio po instalacji odbywa się automatycznie w tle. Użytkownicy mogą otworzyć aplikację, zanim model zostanie w pełni pobrany. Model zostanie pobrany do wewnętrznej pamięci aplikacji.
    • Dostarczanie na żądanie umożliwia żądanie modelu w czasie wykonywania, co jest przydatne, jeśli model jest wymagany tylko w przypadku niektórych procesów użytkownika. Model zostanie pobrany do pamięci wewnętrznej aplikacji.
  • dostarczać warianty modeli ML kierowane na konkretne urządzenia na podstawie modelu urządzenia, właściwości systemu lub pamięci RAM;
  • Dzięki automatycznemu poprawianiu plików w Google Play możesz utrzymywać aktualizacje aplikacji w małym rozmiarze i optymalizować je. Oznacza to, że do pobrania są tylko różnice w plikach.

co należy wziąć pod uwagę

  • Korzystając z usługi Play for On-device AI, akceptujesz warunki Umowy dystrybucyjnej dla deweloperów w Google Play oraz Warunków korzystania z usługi Play Core Software Development Kit.
  • Deweloperzy biorący udział w programie wcześniejszego dostępu powinni ocenić Play for On-device AI i przekazać opinię Google Play.
  • Modeli pobranych przez Google Play na potrzeby AI na urządzeniu może używać tylko aplikacja, która pobrała dany model. Modeli nie można udostępniać innym aplikacjom, na przykład za pomocą połączenia z usługą.
  • Poszczególne pakiety AI mogą mieć rozmiar do 1, 5 GB w przypadku skompresowanych plików do pobrania. Maksymalny łączny rozmiar każdej wersji aplikacji wygenerowanej z pakietu aplikacji to 4 GB.
  • Aplikacje o rozmiarze przekraczającym 1 GB muszą mieć ustawiony poziom interfejsu SDK 21 lub wyższy.
  • W ramach programu wcześniejszego dostępu funkcje AI na urządzeniu w Google Play mogą ulec zmianie.

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

Wdrażanie AI na urządzeniach za pomocą Google Play korzysta z pakietów AI. Pakiety niestandardowych modeli, które są gotowe do dystrybucji w pakietach AI, w Twoim pakiecie aplikacji. Możesz wybrać, czy pakiet AI powinien być dostarczany w momencie instalacji, w trybie szybkiego śledzenia czy na żądanie.

Pakiety AI w pakiecie aplikacji umożliwiają korzystanie ze wszystkich dotychczasowych narzędzi do testowania i publikowania w Google Play, takich jak ścieżki testów i wdrażanie etapowe, aby zarządzać dystrybucją aplikacji z wykorzystaniem modeli niestandardowych.

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

Pakiety AI zawierają tylko modele. Biblioteki Java/Kotlin i natywne są niedozwolone. Jeśli musisz przesłać 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ł te same ustawienia pobierania i kierowania co pakiet AI.

Korzystanie z LiteRT i MediaPipe w pakietach AI

LiteRT i MediaPipe możesz używać z pakietami AI. Spakuj model w pakiecie AI, a potem uzyskaj do niego dostęp, korzystając z instrukcji dotyczących pakietów install-time 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 Google Play w przypadku AI na urządzeniach:

  1. Aby dołączyć do programu EAP, podaj identyfikator konta dewelopera w Google Play.
  2. Spakuj modele do pakietów AI w pakiecie aplikacji na Androida i określ, jak mają być dostarczane.
  3. [Opcjonalnie] Jeśli chcesz dostarczać różne modele na różne urządzenia, możesz skonfigurować kierowanie na urządzenia dla swoich pakietów AI. Możesz na przykład dostarczyć pakiet AI A do konkretnego modelu urządzenia, pakiet AI B do urządzeń z co najmniej 6 GB pamięci RAM, a wszystkie inne urządzenia mogą nie otrzymać żadnego modelu.
  4. [Opcjonalnie] Jeśli korzystasz z przesyłania na żądanie lub szybkiego przesyłania, zintegruj bibliotekę Play AI Delivery Library z aplikacją, aby pobierać pakiety AI w miarę potrzeby.
  5. Przetestuj i opublikuj pakiet aplikacji w Google Play.

Podaj identyfikator konta dewelopera w Google Play

Ta funkcja jest dostępna w ramach wcześniejszego dostępu, dlatego aby uzyskać dostęp do Google Play w ramach funkcji AI na urządzeniu, musisz dodać swoje konto dewelopera do listy zaufanych. Potwierdź identyfikatory konta dewelopera w Google Play i nazwy pakietów aplikacji u menedżera ds. partnerów w Google Play lub u członka zespołu ds. AI na urządzeniu. Określ, czy modele będą kierowane na konkretne urządzenia (jest to krok 3 z poprzedniej sekcji). Obecnie zapraszamy wybranych partnerów Google Play do przetestowania tej funkcji.

Sprawdzanie wersji wtyczki Androida do obsługi Gradle

Aby korzystać z pakietów AI, sprawdź, czy wersja wtyczki Android Gradle (AGP) to co najmniej 8.8. Ta wersja jest dostarczana z Android Studio Ladybug 2.

Wyodrębnianie modelu w pakiecie AI

Aby wykonać te czynności, nie musisz uruchamiać Android Studio.

  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ą rozpoczynać się od litery i mogą zawierać tylko litery, cyfry oraz znaki 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, 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 katalogu 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 wczytywać i uruchamiać modele. Sposób wykonania tej czynności zależy od trybu dostarczania 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. Wygeneruj pakiet Android App Bundle za pomocą Gradle. W wygenerowanym pakiecie aplikacji katalog główny 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 wygeneruje plik manifestu dla każdego pakietu AI i wyśle do Ciebie folder assets/.

Konfigurowanie przesyłania w czasie instalacji

Pakiety AI skonfigurowane jako instalowane w momencie instalacji są dostępne natychmiast po uruchomieniu aplikacji. Aby uzyskać dostęp do pakietów AI obsługiwanych w tym trybie, użyj interfejsu API AssetManager w języku Java:

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 trybie szybkiego śledzenia i na żądanie

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

Zadeklaruj zależność 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 użycia pod adresem assetsPath().
null Nieznany pakiet AI lub pakiety AI są niedostępne

Pobieranie informacji o pakietach 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 obiekt Map<String, AiPackState>. Ta mapa zawiera stan każdego żądanego pakietu AI, posortowanego według nazwy:

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 umożliwiają uzyskanie informacji o rozmiarze pakietu AI, pobranej do tej pory ilości danych (jeśli jest to wymagane) oraz ilości danych już przeniesionych do aplikacji:

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

Jeśli żądanie się nie powiedzie, użyj metody errorCode(), której zwracana wartość odpowiada stałej 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 i rozmiary pobierania. Jeśli pakiet AI żądany 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, należy wdrożyć AiPackStateUpdateListener. Aktualizacje stanu są podzielone według pakietu, aby umożliwić śledzenie stanu poszczególnych pakietów AI. Możesz zacząć korzystać z dostępnych pakietów AI, zanim wszystkie inne pliki zostaną pobrane.

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

Jeśli pobieranie zajmuje więcej niż 200 MB, a użytkownik nie jest połączony z siecią Wi-Fi, pobieranie nie rozpocznie się, dopóki użytkownik nie wyrazi wyraźnej zgody na kontynuowanie pobierania za pomocą połączenia z komórkowym połączeniem transmisji danych. Podobnie, jeśli pobieranie jest duże, a użytkownik utraci połączenie Wi-Fi, pobieranie zostanie wstrzymane i do dalszego pobierania za pomocą mobilnej transmisji danych będzie wymagana wyraźna zgoda. Wstrzymany pakiet ma stanWAITING_FOR_WIFI. Aby wywołać proces w interfejsie, który poprosi użytkownika o zgodę, użyj metody showConfirmationDialog().

Jeśli aplikacja nie wywołuje 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 rozpocznie się, dopóki użytkownik nie zaakceptuje wyświetlonego okna showConfirmationDialog(). Ten stan może wystąpić, gdy aplikacja nie jest rozpoznawana przez Google Play – na przykład jeśli została zainstalowana z innego urządzenia. Pamiętaj, że w tym przypadku wywołanie funkcji showConfirmationDialog() spowoduje zaktualizowanie aplikacji. Po aktualizacji musisz ponownie poprosić o pakiety AI.

Poniżej znajduje się 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 tym, jak żądanie pobierania dotrze do stanu COMPLETED, możesz uzyskać dostęp do pakietu AI za pomocą wywołań systemu plików. Aby uzyskać folder główny 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ć, używając wygodnej 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, możesz postępować zgodnie z instrukcjami dotyczącymi kierowania na urządzenia.

Inne metody interfejsu Play AI Delivery API

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

Anuluj prośbę

Użyj opcji cancel(), aby anulować aktywne żądanie pakietu AI. Pamiętaj, że ta prośba jest realizowana zgodnie z zasadą „dokładamy wszelkich starań”.

Usuwanie pakietu AI

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

Pobieranie lokalizacji wielu pakietów AI

Użyj opcji getPackLocations(), aby zapytać o stan wielu pakietów AI zbiorczo. W odpowiedzi otrzymasz 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 przesyłać różne wersje modelu na różne urządzenia.

Możesz kierować reklamy na właściwości urządzenia, 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ą trafić do których 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, sprawdź, czy wersja wtyczki Android Gradle (AGP) to co najmniej 8.10.0-alpha01. Jest ona dostępna w pakiecie z Android Studio Meerkat 2, który jest w wersji canary.

Włączanie tej funkcji w pluginie 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 systemem na chipie 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ę maksymalnie z 5 selektorów urządzeń. Urządzenie jest uwzględniane w grupie urządzeń, jeśli spełnia kryteria dowolnego z selektorów urządzeń.

Selektor urządzeń może mieć co najmniej 1 usługę. Urządzenie jest wybierane, jeśli odpowiada wszystkim właściwościom urządzenia selektora.

Jeśli urządzenie pasuje do kilku grup, będzie wyświetlana treść dla grupy zdefiniowanej jako pierwsza w pliku XML. Kolejność grup 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 należy jej definiować w prosty sposób.

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 (wyłącznie): 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ądzenia 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ą być wykluczone w tym selektorze (maksymalnie 10 000 identyfikatorów urządzenia 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 można było je uwzględnić za pomocą tego selektora (maksymalnie 100 funkcji na grupę). Aby spełniać to kryterium, 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 być uwzględnione przez ten selektor (maksymalnie 100 funkcji na grupę). Jeśli urządzenie ma którąś z funkcji systemowych z tej listy, nie spełnia tego kryterium.

    Lista funkcji systemowych

    • name: funkcja systemowa,

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

Oto przykład, który pokazuje 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>

Kody oficjalnego producenta i modelu urządzenia

Prawidłowe formatowanie kodu producenta i modelu urządzenia możesz znaleźć w katalogu urządzeń w Konsoli Google Play. Aby to zrobić:

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

  • Pobieranie pliku CSV z obsługiwanymi urządzeniami i używanie pól Manufacturer i Model Code w odpowiednich polach build_brand i build_device.

Dodawanie pliku konfiguracji kierowania na urządzenie 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 zapakowany 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ć optymalizację rozmiaru na urządzeniach, dostarczając duże modele tylko na urządzenia, na których mogą one działać.

Podziel pakiety AI według grup urządzeń, korzystając z dotychczasowych katalogów pakietów AI utworzonych w ostatnim kroku i dodając do nazw odpowiednich folderów (jak opisano poniżej) postfix #group_myCustomGroup1, #group_myCustomGroup2 itd. Korzystając z pakietów AI w aplikacji, nie musisz adresować folderów za pomocą postfixa (czyli postfix 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 użytkowników myCustomGroup1 ani myCustomGroup2, otrzymają pusty pakiet ai-pack-name.

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

Po pobraniu pakietu AI możesz sprawdzić, czy Twój model jest obecny, korzystając z AssetManager w przypadku pakietów instalowanych w czasie instalacji lub z AiPackManager w przypadku pakietów szybkiego śledzenia i na żądanie. Przykłady takiego działania są podane dla wszystkich trybów wyświetlania w przykładowej aplikacji.

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

Kierowanie na urządzenia możesz też stosować w przypadku modułów funkcji. Zamiast dzielić moduły funkcji według grupy urządzeń, możesz określić, czy cały moduł ma być dostarczany na podstawie przynależności do grupy urządzeń.

Aby przesłać moduł funkcji na urządzenia należące do 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 lokalnie

Zanim utworzysz wersję nowego pakietu, możesz przeprowadzić test lokalny za pomocą wewnętrznego udostępniania aplikacji lub narzędzia Bundletool.

Wewnętrzne udostępnianie aplikacji

Wewnętrzne udostępnianie aplikacji umożliwia korzystanie z pakietu aplikacji, aby szybko wygenerować adres URL, który możesz kliknąć na urządzeniu lokalnym, aby zainstalować dokładnie to, co Google Play zainstalowałoby na tym urządzeniu, gdyby ta wersja aplikacji była dostępna 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ą bundletool (w wersji 1.18.0 lub nowszej) i przesłać je na urządzenie. Aby przetestować aplikację lokalnie za pomocą narzędzia bundletool:

  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 załadować 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ą pobierane automatycznie, gdy aplikacja zostanie zainstalowana z poza sklepu. Deweloperzy muszą ręcznie poprosić o te uprawnienia podczas uruchamiania aplikacji. Nie wymaga to wprowadzania żadnych zmian w kodzie aplikacji.
  • Pakiety są pobierane z zewnętrznego magazynu, a nie z Google Play, więc nie możesz przetestować, jak zachowuje się Twój kod 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ą zainstalowane tylko odpowiednie pliki APK, wykonaj tę czynność:

adb shell pm path {packageName}

Powinien pojawić się komunikat 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 pliki APK utworzone z modułów funkcji i pakietów AI przesyłanych podczas instalacji. Pakiety AI na żądanie i pakiety AI do szybkiego wdrażania nie są instalowane jako pliki APK.

Testowanie i publikowanie w Google Play

Zalecamy przetestowanie aplikacji w Google Play od początku do końca za pomocą ścieżki testu wewnętrznego.

Następnie możesz stopniowo publikować aktualizację aplikacji w wersji produkcyjnej, korzystając z wdrożeń etapowych.

Przykładowa aplikacja korzystająca z Google Play w celu wdrażania AI na urządzeniu

Aby uzyskać dostęp do naszej próbnej aplikacji, skontaktuj się z menedżerem ds. partnera w Google Play.

Pokazuje on, jak korzystać z każdego z tych trybów wyświetlania, a także jak skonfigurować kierowanie na urządzenia. Aby rozpocząć, przejdź do sekcji testowanie lokalne.

Prześlij opinię

Uczestnicy programu wczesnego dostępu powinni zgłaszać problemy i przekazywać opinie. Możesz skontaktować się z menedżerem ds. partnera w Google Play lub z zespołem Google Play for On-device AI.

Powiązane artykuły

Dowiedz się więcej o pakietach aplikacji na Androida i przeczytaj informacje referencyjne dotyczące pakietu AI Delivery SDK.