Play per l'AI on-device (beta)

Introduzione

Play for On-device AI offre i vantaggi degli Android App Bundle e della distribuzione di Google Play alla distribuzione di modelli ML personalizzati, in modo da migliorare le prestazioni dei modelli con una minore complessità dell'ecosistema dei dispositivi senza costi aggiuntivi. Consente di pubblicare un singolo artefatto su Play contenente codice, asset e modelli ML e di scegliere tra diverse modalità di pubblicazione e opzioni di targeting.

Vantaggi

  • Carica un singolo artefatto di pubblicazione su Google Play e delega a Play l'hosting, la distribuzione, gli aggiornamenti e il targeting senza costi aggiuntivi.
  • Pubblica i tuoi modelli ML al momento dell'installazione, in rapida successione o on demand.
    • La distribuzione in fase di installazione può garantire che un modello molto grande sia presente quando l'app viene aperta. Il modello verrà installato come APK.
    • La pubblicazione rapida successiva avviene automaticamente in background dopo l'installazione dell'app. Gli utenti potrebbero aprire la tua app prima che il modello sia stato scaricato completamente. Il modello verrà scaricato nello spazio di archiviazione interno dell'app.
    • La pubblicazione on demand ti consente di richiedere il modello in fase di runtime, il che è utile se il modello è necessario solo per determinati flussi utente. Il modello verrà scaricato nello spazio di archiviazione interno dell'app.
  • Pubblica varianti dei tuoi modelli ML destinate a dispositivi specifici in base al modello di dispositivo, alle proprietà di sistema o alla RAM.
  • Mantieni gli aggiornamenti delle app piccoli e ottimizzati con l'applicazione automatica di patch di Play, il che significa che devono essere scaricate solo le differenze nei file.

Considerazioni

  • Utilizzando Play per l'AI on-device, accetti i termini del Contratto di distribuzione per gli sviluppatori di Google Play e dei Termini di servizio del kit di sviluppo software Play Core.
  • I modelli scaricati da Play per l'AI on-device devono essere utilizzati solo dalle tue app. I modelli non devono essere offerti ad altre app.
  • I singoli pacchetti di AI possono avere una dimensione massima di 1,5 GB, in base alle dimensioni di download compresse. La dimensione cumulativa massima dell'app di qualsiasi versione generata dal tuo app bundle è 4 GB.
  • Le app di dimensioni superiori a 1 GB devono impostare il livello SDK minimo su 21 o superiore.

Come utilizzare Play per l'AI on-device

Play per l'AI on-device utilizza i pacchetti AI. Puoi raggruppare i modelli personalizzati pronti per la distribuzione nei pacchetti AI nel tuo app bundle. Puoi scegliere se il pacchetto AI deve essere pubblicato al momento dell'installazione, in modalità rapida successiva o on demand.

Se includi i pacchetti AI nell'app bundle, puoi utilizzare tutti gli strumenti di test e rilascio esistenti di Play, come i gruppi di test e le implementazioni in più fasi, per gestire la distribuzione dell'app con i tuoi modelli personalizzati.

I pacchetti AI vengono aggiornati insieme al binario dell'app. Se la nuova release dell'app non apporta modifiche a un pacchetto AI, la procedura di patching automatico di Play garantirà che l'utente non debba scaricarlo di nuovo. Google Play scaricherà solo le modifiche quando aggiornerà l'app.

I pacchetti AI contengono solo modelli. Le librerie Java/Kotlin e native non sono consentite. Se devi spedire librerie o codice per eseguire il modello ML, spostali nel modulo base o in un modulo di funzionalità. Puoi configurare il modulo delle funzionalità in modo che abbia le stesse impostazioni di download e targeting del pacchetto AI.

Utilizzare LiteRT e MediaPipe con i pacchetti AI

Puoi utilizzare LiteRT e MediaPipe con i pacchetti AI. Pacchettizza il modello in un pacchetto AI e poi accedi seguendo le istruzioni per i pacchetti al momento dell'installazione o per i pacchetti rapidi successivi e on demand.

Per approfondire:

Inizia a utilizzare i pacchetti AI

A livello generale, ecco come iniziare a utilizzare Play per l'AI on-device:

  1. Pacchettizza i modelli in pacchetti di AI nell'Android App Bundle e specifica come devono essere distribuiti i pacchetti di AI.
  2. [Facoltativo] Se vuoi pubblicare modelli diversi su dispositivi diversi, puoi configurare il targeting per dispositivo per i tuoi pacchetti AI. Ad esempio, potresti distribuire il pacchetto AI A a un modello di dispositivo specifico, il pacchetto AI B ai dispositivi con almeno 6 GB di RAM e tutti gli altri dispositivi potrebbero non ricevere alcun modello.
  3. [Facoltativo] Se utilizzi la pubblicazione on demand o fast-follow, integra la libreria Play AI Delivery nella tua app per scaricare i pacchetti AI in base alle necessità.
  4. Testa e rilascia l'app bundle su Google Play.

Controllare la versione del plug-in Android per Gradle

Per utilizzare i pacchetti AI, assicurati che la versione del plug-in Android per Gradle (AGP) sia almeno 8.8. Questa versione è inclusa in Android Studio Ladybug 2.

Estrai il modello in un pacchetto AI

Android Studio non è necessario per i passaggi successivi.

  1. Nella directory di primo livello del progetto, crea una directory per il pacchetto AI. Questo nome di directory viene utilizzato come nome del pacchetto AI. I nomi dei pacchetti AI devono iniziare con una lettera e possono contenere solo lettere, numeri e trattini bassi.

  2. Nella directory del pacchetto AI, crea un file build.gradle e aggiungi il seguente codice. Assicurati di specificare il nome del pacchetto AI e un solo tipo di consegna:

    // 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. Nel file build.gradle dell'app del progetto, aggiungi il nome di ogni pacchetto AI nel tuo progetto come mostrato di seguito:

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

  4. Nel file settings.gradle del progetto, includi tutti i pacchetti AI nel tuo progetto come mostrato di seguito:

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

  5. All'interno del pacchetto AI, crea una directory src/main/assets/.

  6. Inserisci i tuoi modelli nella directory src/main/assets. Qui puoi anche creare sottodirectory. La struttura di directory della tua app dovrebbe ora avere il seguente aspetto:

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

  7. Aggiungi il codice per caricare ed eseguire i modelli. La modalità dipende dalla modalità di invio dei pacchetti di IA. Consulta le istruzioni per install-time e fast-follow/on-demand di seguito.

  8. [Facoltativo] Configura il targeting per dispositivo per pubblicare modelli diversi su dispositivi diversi.

  9. Crea l'Android App Bundle con Gradle. Nell'app bundle generato, la directory di primo livello ora include quanto segue:

    • ai-pack-name/manifest/AndroidManifest.xml: configura l'identificatore e la modalità di pubblicazione del pacchetto AI
    • ai-pack-name/assets/your-model-directories: Directory che contiene tutti gli asset forniti come parte del pacchetto AI

    Gradle genera il manifest per ogni pacchetto AI e restituisce la directory assets/ per te.

Configurare la distribuzione al momento dell'installazione

I pacchetti AI configurati come install-time sono immediatamente disponibili all'avvio dell'app. Utilizza l'API Java AssetManager per accedere ai pacchetti AI pubblicati in questa modalità:

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

Configurare la pubblicazione rapida successiva e on demand

Per scaricare i pacchetti AI con la distribuzione rapida o on demand, utilizza la libreria Play AI Delivery.

Dichiarare la dipendenza dalla libreria Play AI Delivery

Nel file build.gradle della tua app, dichiara una dipendenza dalla libreria Play AI Delivery:

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

Verifica lo stato

Ogni pacchetto AI viene archiviato in una cartella separata nella memoria interna dell'app. Utilizza il metodo getPackLocation() per determinare la cartella principale di un pacchetto AI. Questo metodo restituisce i seguenti valori:

Valore restituito Stato
Un oggetto AiPackLocation valido La cartella principale del pacchetto AI è pronta per l'accesso immediato all'indirizzo assetsPath()
null Pacchetto AI sconosciuto o pacchetti AI non disponibili

Ottenere informazioni sul download dei pacchetti di AI

Utilizza il metodo
getPackStates() per determinare le dimensioni del download e se il pacchetto è già in fase di download.

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

getPackStates() è un metodo asincrono che restituisce un Task<AiPackStates>. Il metodo packStates() di un oggetto AiPackStates restituisce un Map<String, AiPackState>. Questa mappa contiene lo stato di ogni pacchetto AI richiesto, identificato dal nome:

Map<String, AiPackState> AiPackStates#packStates()

La richiesta finale è mostrata di seguito:

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;
            });

I seguenti AiPackState metodi forniscono le dimensioni del pacchetto AI, l'importo scaricato finora (se richiesto) e l'importo già trasferito all'app:

Per ottenere lo stato di un pacchetto AI, utilizza il metodo status(), che restituisce lo stato come numero intero corrispondente a un campo costante nella classe AiPackStatus. Un pacchetto AI non ancora installato ha lo stato AiPackStatus.NOT_INSTALLED.

Se una richiesta non va a buon fine, utilizza il metodo errorCode(), il cui valore restituito corrisponde a un campo costante nella classe AiPackErrorCode.

Installa

Utilizza il metodo fetch() per scaricare un pacchetto AI per la prima volta o chiamare l'aggiornamento di un pacchetto AI per completare:

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

Questo metodo restituisce un oggetto AiPackStates contenente un elenco di pacchetti e le relative dimensioni e stati di download iniziali. Se un pacchetto AI richiesto tramite fetch() è già in fase di download, viene restituito lo stato del download e non viene avviato alcun download aggiuntivo.

Monitorare gli stati di download

Devi implementare un AiPackStateUpdateListener per monitorare l'avanzamento dell'installazione dei pacchetti AI. Gli aggiornamenti di stato sono suddivisi per pacchetto per supportare il monitoraggio dello stato dei singoli pacchetti di AI. Puoi iniziare a utilizzare i pacchetti AI disponibili prima che tutti gli altri download per la tua richiesta siano completati.

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)
Download di grandi dimensioni

Se il download supera i 200 MB e l'utente non è connesso al Wi-Fi, il download non viene avviato finché l'utente non dà il proprio consenso esplicito a procedere con il download utilizzando una connessione dati mobili. Allo stesso modo, se il download è di grandi dimensioni e l'utente perde la connessione Wi-Fi, il download viene messo in pausa ed è necessario il consenso esplicito per procedere utilizzando una connessione dati mobili. Un pacchetto in pausa ha lo stato WAITING_FOR_WIFI. Per attivare il flusso dell'interfaccia utente per chiedere il consenso all'utente, utilizza il metodo showConfirmationDialog().

Tieni presente che se l'app non chiama questo metodo, il download viene messo in pausa e riprenderà automaticamente solo quando l'utente si riconnetterà a una rete Wi-Fi.

Conferma utente obbligatoria

Se un pacchetto ha lo stato REQUIRES_USER_CONFIRMATION, il download non procede finché l'utente non accetta la finestra di dialogo visualizzata con showConfirmationDialog(). Questo stato può verificarsi quando l'app non viene riconosciuta da Google Play, ad esempio se è stata installata tramite sideload. Tieni presente che la chiamata showConfirmationDialog() in questo caso causerà l'aggiornamento dell'app. Dopo l'aggiornamento, dovrai richiedere nuovamente i pacchetti AI.

Di seguito è riportato un esempio di implementazione di un listener:

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

In alternativa, puoi utilizzare il metodo getPackStates() per ottenere lo stato dei download correnti. AiPackStates contiene l'avanzamento del download, lo stato del download ed eventuali codici di errore.

Accedere ai pacchetti AI

Puoi accedere a un pacchetto AI utilizzando le chiamate al file system dopo che la richiesta di download raggiunge lo stato COMPLETED. Utilizza il metodo getPackLocation() per ottenere la cartella principale del pacchetto AI.

I pacchetti AI vengono memorizzati nella directory assets all'interno della directory principale del pacchetto AI. Puoi ottenere il percorso della directory assets utilizzando il metodo pratico assetsPath(). Per ottenere il percorso di un asset specifico, utilizza il seguente metodo:

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

Configurare il targeting per dispositivo

Puoi seguire le istruzioni per il targeting per dispositivo per specificare i dispositivi o i gruppi di dispositivi che devono ricevere i tuoi pacchetti di AI.

Altri metodi dell'API Play AI Delivery

Di seguito sono riportati alcuni metodi API aggiuntivi che potresti voler utilizzare nella tua app.

Annulla richiesta

Utilizza cancel() per annullare una richiesta di pacchetto AI attivo. Tieni presente che questa richiesta è un'operazione di tipo best effort.

Rimuovere un pacchetto AI

Utilizza removePack() per pianificare la rimozione di un pacchetto AI.

Ottenere le posizioni di più pacchetti AI

Utilizza getPackLocations() per eseguire query sullo stato di più pacchetti AI collettivamente, restituendo una mappa dei pacchetti AI e delle relative posizioni. La mappa restituita da getPackLocations() contiene una voce per ogni pacchetto attualmente scaricato e aggiornato.

Targeting per dispositivo

Il targeting per dispositivo ti offre un controllo più preciso sulle parti del bundle dell'app che vengono distribuite a dispositivi specifici. Ad esempio, potresti assicurarti che un modello di grandi dimensioni venga pubblicato solo sui dispositivi con RAM elevata oppure potresti pubblicare versioni diverse di un modello su dispositivi diversi.

Puoi scegliere come target le proprietà del dispositivo, ad esempio:

Panoramica dei passaggi richiesti

Per attivare il targeting per dispositivo:

  1. Definisci i gruppi di dispositivi in un file XML.
  2. Specifica quali parti del bundle devono essere inviate a quali gruppi di dispositivi.
  3. [Facoltativo] Testa la configurazione localmente.
  4. Carica il bundle (contenente il file XML) su Google Play.

Controllare la versione del plug-in Android per Gradle

Per utilizzare il targeting per dispositivo, assicurati che la versione del plug-in Android per Gradle (AGP) sia almeno 8.10.0. È incluso in Android Studio (Meerkat 2 e versioni successive). Scarica l'ultima versione stabile di Android Studio.

Attiva questa funzionalità nel plug-in Android per Gradle

Il targeting per dispositivo deve essere attivato in modo esplicito nel file gradle.properties:

android.experimental.enableDeviceTargetingConfigApi=true

Crea un file XML di configurazione del targeting per dispositivo

Il file di configurazione del targeting dei dispositivi è un file XML in cui definisci i tuoi gruppi di dispositivi personalizzati. Ad esempio, potresti definire un gruppo di dispositivi chiamato qti_v79 che contenga tutti i dispositivi con il system on chip 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>

Un gruppo di dispositivi è composto da un massimo di 5 selettori di dispositivi. Un dispositivo è incluso in un gruppo di dispositivi se soddisfa uno qualsiasi dei relativi selettori.

Un selettore di dispositivi può avere una o più proprietà del dispositivo. Un dispositivo viene selezionato se corrisponde a tutte le proprietà del dispositivo del selettore.

Se un dispositivo corrisponde a più gruppi, verrà visualizzato il contenuto del gruppo definito per primo nel file XML. L'ordine in cui definisci i gruppi nel file XML è l'ordine di priorità.

Se un dispositivo non corrisponde a nessun gruppo, riceverà il gruppo "altro" predefinito. Questo gruppo viene generato automaticamente e non deve essere definito in modo esplicito.

Proprietà del dispositivo disponibili

  • device_ram: requisiti di RAM del dispositivo
    • min_bytes (inclusivo): RAM minima richiesta (in byte)
    • max_bytes (esclusivo): RAM massima richiesta (in byte)
  • included_device_ids: modelli di dispositivo da includere in questo selettore (massimo 10.000 device_id per gruppo). Questa proprietà è soddisfatta se il dispositivo corrisponde a qualsiasi device_id nell'elenco.
    • build_brand: produttore del dispositivo
    • build_device: codice del modello di dispositivo
  • excluded_device_ids: modelli di dispositivi da escludere in questo selettore (massimo 10.000 device_id per gruppo). Questa proprietà viene soddisfatta se il dispositivo non corrisponde a nessun device_id nell'elenco.
    • build_brand: produttore del dispositivo
    • build_device: codice del modello di dispositivo

  • required_system_features: funzionalità che un dispositivo deve avere per essere incluso in questo selettore (massimo 100 funzionalità per gruppo). Un dispositivo deve disporre di tutte le funzionalità di sistema in questo elenco per soddisfare questa proprietà.

    Riferimento alle funzionalità di sistema

    • name: Una funzionalità di sistema

  • forbidden_system_features: funzionalità che un dispositivo non deve avere per essere incluso in questo selettore (massimo 100 funzionalità per gruppo). Se un dispositivo dispone di una delle funzionalità di sistema in questo elenco, non soddisfa questa proprietà.

    Riferimento alle funzionalità di sistema

    • name: Una funzionalità di sistema

  • system on chip: system on chip da includere in questo selettore. Un dispositivo deve avere uno dei chip di questo elenco per soddisfare questa proprietà.

Ecco un esempio che mostra tutte le proprietà del dispositivo possibili:

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

Codici ufficiali del produttore e del modello del dispositivo

Puoi trovare la formattazione corretta per il produttore del dispositivo e il codice modello utilizzando il catalogo dei dispositivi su Google Play Console, in uno dei seguenti modi:

  • Ispezionando i singoli dispositivi utilizzando il catalogo dei dispositivi e trovando il codice del produttore e del modello nelle posizioni mostrate nell'esempio seguente (per Google Pixel 4a, il produttore è"Google" e il codice del modello è"sunfish").

    Pagina di Pixel 4a nel catalogo dei dispositivi

    Pagina di Pixel 4a nel catalogo dei dispositivi

  • Scaricando un file CSV dei dispositivi supportati e utilizzando Manufacturer e Model Code per i campi build_brand e build_device, rispettivamente.

Includi il file di configurazione del targeting per dispositivo nell'app bundle

Aggiungi quanto segue al file build.gradle del modulo principale:

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 è il percorso del file di configurazione relativo al modulo principale. In questo modo, il file di configurazione viene incluso nel tuo app bundle.

La clausola deviceGroup garantisce che gli APK generati dal tuo bundle siano divisi per gruppi di dispositivi.

Utilizzare il targeting per dispositivo per i pacchetti di AI

Puoi mantenere le dimensioni ottimizzate sui dispositivi distribuendo i modelli di grandi dimensioni solo ai dispositivi in grado di eseguirli.

Suddividi i pacchetti AI per gruppi di dispositivi prendendo le directory dei pacchetti AI esistenti create nell'ultimo passaggio e aggiungendo il suffisso alle cartelle appropriate (come descritto di seguito) con #group_myCustomGroup1, #group_myCustomGroup2 e così via. Quando utilizzi i pacchetti AI nella tua app, non dovrai indirizzare le cartelle per suffisso (in altre parole, il suffisso viene rimosso automaticamente durante il processo di build).

Dopo il passaggio precedente, il codice potrebbe avere il seguente aspetto:

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

In questo esempio, devi fare riferimento a ai-pack-name/assets/image-classifier/ senza suffissi.

I dispositivi in myCustomGroup1 riceveranno tutti gli asset in image-classifier#group_myCustomGroup1/, mentre i dispositivi in myCustomGroup2 riceveranno tutti gli asset in image-classifier#group_myCustomGroup2/.

I dispositivi che non appartengono a myCustomGroup1 o myCustomGroup2 riceveranno un pacchetto ai-pack-name vuoto.

Questo perché i dispositivi che non corrispondono a nessun gruppo di dispositivi riceveranno la variante predefinita del pacchetto AI. Sono inclusi tutti gli elementi che non si trovano in una directory con un #group_suffix.

Dopo aver scaricato il pacchetto AI, puoi verificare se il tuo modello è presente utilizzando AssetManager per i pacchetti al momento dell'installazione o AiPackManager per i pacchetti fast-follow e on demand. Gli esempi per farlo sono mostrati per tutte le modalità di pubblicazione nell'app di esempio.

Utilizzare il targeting per dispositivo per i moduli delle funzionalità

Puoi anche utilizzare il targeting per dispositivo per i moduli delle funzionalità. Anziché suddividere i moduli delle funzionalità per gruppo di dispositivi, specifichi se l'intero modulo deve essere distribuito in base all'appartenenza al gruppo di dispositivi.

Per pubblicare un modulo delle funzionalità sui dispositivi che appartengono a myCustomGroup1 o myCustomGroup2, modifica il relativo 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>

Testare localmente

Prima di creare una release per il nuovo bundle, puoi eseguire test in locale con la condivisione interna delle app o Bundletool.

Condivisione interna delle app

La condivisione interna delle app ti consente di utilizzare un app bundle per generare rapidamente un URL che puoi toccare su un dispositivo locale per installare esattamente ciò che Google Play installerebbe per quel dispositivo se quella versione dell'app fosse pubblicata in un canale di test o di produzione.

Consulta le istruzioni per la condivisione interna delle app.

Bundletool

In alternativa, puoi generare APK utilizzando bundletool (1.18.0 o versioni successive) e caricarli sul tuo dispositivo. Segui questi passaggi per testare la tua app localmente utilizzando bundletool:

  1. Crea il bundle dell'app con Android Studio o bundletool.

  2. Genera APK con il flag --local-testing:

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

  3. Collega un dispositivo ed esegui bundletool per caricare lateralmente gli 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

Limitazioni dei test locali con bundletool

Di seguito sono riportate le limitazioni dei test locali con bundletool:

  • I fast-follow si comportano come i on-demand. ovvero non verranno recuperati automaticamente quando l'app viene caricata in sideload. Gli sviluppatori devono richiederli manualmente all'avvio dell'app. Questa operazione non richiede modifiche al codice dell'app.
  • I pacchetti vengono recuperati dalla memoria esterna anziché da Play, quindi non puoi testare il comportamento del codice in caso di errori di rete.
  • Il test locale non copre lo scenario di attesa del Wi-Fi.
  • Gli aggiornamenti non sono supportati. Prima di installare una nuova versione della build, disinstalla manualmente la versione precedente.

Verifica che vengano installati gli APK corretti

Utilizza il seguente metodo per assicurarti che sul dispositivo vengano installati solo gli APK corretti

adb shell pm path {packageName}

Dovresti vedere qualcosa di simile a questo:

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

Tieni presente che in questo elenco vedrai solo gli APK creati da moduli delle funzionalità e pacchetti AI al momento dell'installazione. I pacchetti AI on demand e fast-follow non vengono installati come APK.

Testare e rilasciare su Google Play

Ti consigliamo di testare l'app end-to-end su Google Play con un gruppo di test interno.

Una volta fatto, puoi rilasciare in modo incrementale l'aggiornamento dell'app in produzione con le implementazioni graduali.

App di esempio che utilizza Play per l'AI on-device

Scarica l'app di esempio.

Mostra come utilizzare ciascuna modalità di pubblicazione e la configurazione del targeting per dispositivo. Per iniziare, consulta la sezione Test locali.

Contenuti correlati

Scopri di più sugli Android App Bundle e leggi i riferimenti per l'SDK AI Delivery.