Play pour l'IA sur l'appareil (bêta)

Introduction

Play for On-device AI apporte les avantages des Android App Bundles et de la diffusion Google Play à la distribution de modèles ML personnalisés. Vous pouvez ainsi améliorer les performances des modèles avec moins de complexité de l'écosystème d'appareils, sans frais supplémentaires. Il vous permet de publier un seul artefact sur Play contenant votre code, vos ressources et vos modèles de ML, et de choisir parmi plusieurs modes de distribution et options de ciblage.

Avantages

  • Importez un seul artefact de publication sur Google Play et déléguez l'hébergement, la diffusion, les mises à jour et le ciblage à Play sans frais supplémentaires.
  • Distribuez vos modèles de ML au moment de l'installation, rapidement ou à la demande.
    • La diffusion au moment de l'installation peut garantir qu'un très grand modèle est présent lorsque votre application est ouverte. Votre modèle sera installé en tant qu'APK.
    • La diffusion juste après s'effectue automatiquement en arrière-plan une fois votre application installée. Il est possible que les utilisateurs ouvrent votre application avant que votre modèle n'ait été entièrement téléchargé. Votre modèle sera téléchargé dans l'espace de stockage interne de votre application.
    • La diffusion à la demande vous permet de demander le modèle au moment de l'exécution, ce qui est utile si le modèle n'est requis que pour certains flux utilisateur. Votre modèle sera téléchargé dans l'espace de stockage interne de votre application.
  • Fournissez des variantes de vos modèles de ML ciblées sur des appareils spécifiques en fonction du modèle d'appareil, des propriétés du système ou de la RAM.
  • Maintenez la taille des mises à jour de votre application petite et optimisée grâce aux correctifs automatiques de Play, ce qui signifie que seules les différences entre les fichiers doivent être téléchargées.

Points à prendre en compte

Utiliser Play pour l'IA sur l'appareil

Play pour l'IA sur l'appareil utilise des packs d'IA. Vous regroupez les modèles personnalisés prêts à être distribués dans des packs d'IA de votre app bundle. Vous pouvez choisir si le pack d'IA doit être distribué au moment de l'installation, par le biais d'une distribution rapide ou encore à la demande.

En regroupant les packs d'IA avec votre app bundle, vous pouvez utiliser tous les outils de test et de publication existants de Play, tels que les canaux de test et les déploiements progressifs, pour gérer la distribution de votre application avec vos modèles personnalisés.

Les packs d'IA sont mis à jour en même temps que le fichier binaire de l'application. Si la nouvelle version de votre application n'apporte aucune modification à un pack d'IA, le processus de correction automatique de Play s'assurera que l'utilisateur n'a pas à le télécharger à nouveau. Play ne téléchargera que les éléments modifiés lors de la mise à jour de l'application.

Les packs d'IA ne contiennent que des modèles. Les bibliothèques Java/Kotlin et natives ne sont pas autorisées. Si vous devez fournir des bibliothèques ou du code pour exécuter votre modèle de ML, déplacez-les dans le module de base ou dans un module de fonctionnalité. Vous pouvez configurer votre module de fonctionnalité pour qu'il ait les mêmes paramètres de téléchargement et de ciblage que le pack d'IA.

Utiliser LiteRT et MediaPipe avec les packs IA

Vous pouvez utiliser LiteRT et MediaPipe avec les packs d'IA. Empaquetez votre modèle dans un pack AI, puis accédez-y en suivant les instructions pour les packs d'installation ou pour les packs de distribution rapide et à la demande.

Autres ressources :

Premiers pas avec les packs d'IA

Voici comment commencer à utiliser Play pour l'IA sur l'appareil :

  1. Empaquetez vos modèles dans des packs d'IA dans votre Android App Bundle et spécifiez comment les packs d'IA doivent être distribués.
  2. [Facultatif] Si vous souhaitez diffuser différents modèles sur différents appareils, vous pouvez configurer le ciblage par appareil pour vos packs d'IA. Par exemple, vous pouvez fournir le pack d'IA A à un modèle d'appareil spécifique, le pack d'IA B aux appareils disposant d'au moins 6 Go de RAM, et aucun modèle à tous les autres appareils.
  3. [Facultatif] Si vous utilisez la distribution à la demande ou rapide, intégrez la bibliothèque Play AI Delivery à votre application pour télécharger vos packs d'IA selon vos besoins.
  4. Testez votre app bundle et publiez-le sur Google Play.

Vérifier la version du plug-in Android Gradle

Pour utiliser les packs d'IA, assurez-vous que votre version du plug-in Android Gradle (AGP) est au moins la version 8.8. Cette version est fournie avec Android Studio Ladybug 2.

Extraire votre modèle dans un pack d'IA

Android Studio n'est pas nécessaire pour les étapes suivantes.

  1. Dans le répertoire racine de votre projet, créez un répertoire pour le pack d'IA. Ce nom de répertoire est utilisé comme nom du pack d'IA. Les noms de packs d'IA doivent commencer par une lettre et ne peuvent contenir que des lettres, des chiffres et des traits de soulignement.

  2. Dans le répertoire du pack d'IA, créez un fichier build.gradle et ajoutez-y le code suivant. Veillez à spécifier le nom du pack d'IA et un seul type de distribution :

    // 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. Dans le fichier build.gradle de l'application du projet, ajoutez le nom de chaque pack d'IA de votre projet comme indiqué ci-dessous :

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

  4. Dans le fichier settings.gradle du projet, incluez tous les packs d'IA de votre projet comme indiqué ci-dessous :

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

  5. Dans votre pack d'IA, créez un répertoire src/main/assets/.

  6. Placez vos modèles dans le répertoire src/main/assets. Vous pouvez aussi créer des sous-répertoires dans ce répertoire. La structure de répertoire de votre application devrait maintenant se présenter comme suit :

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

  7. Ajoutez du code pour charger et exécuter vos modèles. La procédure à suivre dépend du mode d'envoi de vos packs d'IA. Consultez les instructions pour install-time et fast-follow/on-demand ci-dessous.

  8. [Facultatif] Configurez le ciblage par types d'appareil pour diffuser différents modèles sur différents appareils.

  9. Compilez le package Android App Bundle avec Gradle. Dans l'app bundle généré, le répertoire racine inclut désormais les éléments suivants :

    • ai-pack-name/manifest/AndroidManifest.xml : configure l'identifiant et le mode de distribution du pack d'IA
    • ai-pack-name/assets/your-model-directories : répertoire contenant tous les éléments distribués dans le pack d'IA

    Gradle génère le fichier manifeste pour chaque pack d'IA et fournit le répertoire assets/ pour vous.

Configurer la distribution au moment de l'installation

Les packs d'IA configurés pour l'installation sont disponibles immédiatement au lancement de l'application. Utilisez l'API Java AssetManager pour accéder aux packs d'IA diffusés dans ce mode :

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

Configurer la distribution rapide et à la demande

Pour télécharger des packs d'IA avec une distribution rapide ou à la demande, utilisez la bibliothèque Play AI Delivery.

Déclarer la dépendance à la bibliothèque Play AI Delivery

Dans le fichier build.gradle de votre application, déclarez une dépendance à la bibliothèque Play AI Delivery :

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

Vérifier l'état

Chaque pack d'IA est stocké dans un dossier distinct de la mémoire de stockage interne de l'application. Utilisez la méthode getPackLocation() pour déterminer le dossier racine d'un pack d'IA. Cette méthode renvoie les valeurs suivantes :

Valeur renvoyée État
Un objet AiPackLocation valide Le dossier racine du pack d'IA est prêt pour un accès immédiat sur assetsPath()
null Pack d'IA inconnu ou packs d'IA non disponibles

Obtenir des informations de téléchargement sur les packs d'IA

Utilisez la méthode
getPackStates() pour déterminer la taille du téléchargement et si le pack est déjà en cours de téléchargement.

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

getPackStates() est une méthode asynchrone qui renvoie un Task<AiPackStates>. La méthode packStates() d'un objet AiPackStates renvoie un Map<String, AiPackState>. Cette carte contient l'état de chaque pack d'IA demandé, associé à son nom :

Map<String, AiPackState> AiPackStates#packStates()

La requête finale est affichée comme suit :

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

Les méthodes AiPackState suivantes fournissent la taille du pack d'IA, le nombre d'éléments téléchargés jusqu'à présent (si demandé) et le montant déjà transféré vers l'application :

Pour connaître l'état d'un pack d'IA, utilisez la méthode status(), qui renvoie l'état sous la forme d'un entier correspondant à un champ constant dans la classe AiPackStatus. Un pack d'IA qui n'est pas encore installé est à l'état AiPackStatus.NOT_INSTALLED.

Si une requête échoue, utilisez la méthode errorCode(), dont la valeur renvoyée correspond à un champ constant dans la classe AiPackErrorCode.

Installer

Utilisez la méthode fetch() pour télécharger un pack d'IA pour la première fois ou appeler la mise à jour d'un pack d'IA :

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

Cette méthode renvoie un objet AiPackStates contenant une liste de packs, ainsi que leurs états et tailles de téléchargement initiaux. Si un pack d'IA demandé via fetch() est déjà en cours de téléchargement, l'état du téléchargement est renvoyé et aucun téléchargement supplémentaire n'est lancé.

Surveiller l'état des téléchargements

Vous devez mettre en œuvre un AiPackStateUpdateListener pour suivre la progression de l'installation des packs d'IA. Les mises à jour de l'état sont réparties par pack afin de permettre le suivi de l'état de chaque pack d'IA. Vous pouvez commencer à utiliser les packs d'IA disponibles avant la fin de tous les autres téléchargements.

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)
Téléchargements volumineux

Si le téléchargement fait plus de 200 Mo et que l'utilisateur n'est pas connecté à un réseau Wi-Fi, le téléchargement ne démarre pas tant que l'utilisateur n'a pas explicitement accepté de poursuivre le téléchargement via une connexion de données mobiles. De même, si le téléchargement est volumineux et que l'utilisateur perd la connexion au réseau Wi-Fi, le téléchargement est suspendu et l'utilisateur doit explicitement accepter de poursuivre le téléchargement à l'aide d'une connexion de données mobiles. Un pack mis en pause possède l'état WAITING_FOR_WIFI. Pour déclencher le flux de l'interface utilisateur afin d'inviter l'utilisateur à donner son consentement, utilisez la méthode showConfirmationDialog().

Notez que si l'application n'appelle pas cette méthode, le téléchargement est suspendu et ne reprendra automatiquement que lorsque l'utilisateur sera de nouveau connecté à un réseau Wi-Fi.

Confirmation de l'utilisateur requise

Si un pack est à l'état REQUIRES_USER_CONFIRMATION, le téléchargement ne se poursuit pas tant que l'utilisateur n'a pas accepté la boîte de dialogue affichée avec showConfirmationDialog(). Cet état peut s'afficher lorsque l'application n'est pas reconnue par Play, par exemple si elle a été installée par chargement latéral. Notez que l'appel de showConfirmationDialog() dans ce cas entraînera la mise à jour de l'application. Après la mise à jour, vous devrez à nouveau demander les packs d'IA.

Voici un exemple d'implémentation d'un écouteur :

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

Vous pouvez également utiliser la méthode getPackStates() pour obtenir l'état des téléchargements actuels. AiPackStates contient la progression du téléchargement, l'état du téléchargement et les codes d'erreur éventuels.

Accéder aux packs IA

Vous pouvez accéder à un pack d'IA à l'aide d'appels au système de fichiers, une fois que la requête de téléchargement a atteint l'état COMPLETED. Utilisez la méthode getPackLocation() pour obtenir le dossier racine du pack d'IA.

Les packs d'IA sont stockés dans le répertoire assets du répertoire racine du pack d'IA. Vous pouvez obtenir le chemin d'accès au répertoire assets à l'aide de la méthode pratique assetsPath(). Utilisez la méthode suivante pour obtenir le chemin d'accès à un élément spécifique :

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

Configurer le ciblage par types d'appareil

Vous pouvez suivre les instructions de ciblage par appareil pour spécifier les appareils ou groupes d'appareils qui doivent recevoir vos packs d'IA.

Autres méthodes de l'API Play AI Delivery

Voici quelques méthodes d'API supplémentaires que vous pouvez utiliser dans votre application.

Annuler la requête

Utilisez cancel() pour annuler une requête active relative au pack d'IA. Notez que cette requête est effectuée dans la mesure du possible.

Supprimer un pack IA

Utilisez removePack() pour planifier la suppression d'un pack d'IA.

Obtenir les emplacements de plusieurs packs d'IA

Utilisez getPackLocations() pour interroger de façon groupée l'état de plusieurs packs d'IA, ce qui renvoie une carte des packs d'IA et de leur emplacement. La carte renvoyée par getPackLocations() contient une entrée pour chaque pack actuellement téléchargé et à jour.

Ciblage par types d'appareil

Le ciblage par appareil vous permet de contrôler plus précisément les parties de votre app bundle qui sont distribuées à des appareils spécifiques. Par exemple, vous pouvez vous assurer qu'un grand modèle n'est diffusé que sur les appareils dotés d'une grande quantité de RAM ou diffuser différentes versions d'un modèle sur différents appareils.

Vous pouvez cibler des propriétés d'appareil telles que :

Présentation des étapes requises

Pour activer le ciblage par appareil, procédez comme suit :

  1. Définissez vos groupes d'appareils dans un fichier XML.
  2. Spécifiez les parties de votre bundle qui doivent être envoyées à quels groupes d'appareils.
  3. [Facultatif] Testez votre configuration en local.
  4. Importez votre bundle (contenant le fichier XML) sur Google Play.

Vérifier la version du plug-in Android Gradle

Pour utiliser le ciblage par appareil, assurez-vous que votre version du plug-in Android Gradle (AGP) est au moins la 8.10.0. Il est fourni avec Android Studio (Meerkat 2 et versions ultérieures). Téléchargez la dernière version stable d'Android Studio.

Activer cette fonctionnalité dans le plug-in Android Gradle

Le ciblage par appareil doit être activé explicitement dans votre fichier gradle.properties :

android.experimental.enableDeviceTargetingConfigApi=true

Créer un fichier XML de configuration du ciblage par types d'appareil

Le fichier de configuration du ciblage des appareils est un fichier XML dans lequel vous définissez vos groupes d'appareils personnalisés. Par exemple, vous pouvez définir un groupe d'appareils appelé qti_v79 qui contient tous les appareils dotés du système sur puce 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 groupe d'appareils est composé d'au maximum cinq sélecteurs d'appareils. Un appareil est inclus dans un groupe d'appareils s'il répond à l'un de ses sélecteurs d'appareils.

Un sélecteur d'appareils peut comporter une ou plusieurs propriétés d'appareil. Un appareil est sélectionné s'il correspond à toutes les propriétés de l'appareil du sélecteur.

Si un appareil correspond à plusieurs groupes, il recevra le contenu du groupe défini en premier dans le fichier XML. L'ordre dans lequel vous définissez les groupes dans le fichier XML correspond à l'ordre de priorité.

Si un appareil ne correspond à aucun groupe, il est attribué au groupe "Autre" par défaut. Ce groupe est généré automatiquement et ne doit pas être défini de manière explicite.

Propriétés de l'appareil disponibles

  • device_ram : configuration requise pour la RAM de l'appareil.
    • min_bytes (inclus) : quantité de RAM minimale requise (en octets).
    • max_bytes (exclu) : quantité de RAM maximale requise (en octets).
  • included_device_ids : modèles d'appareils à inclure dans ce sélecteur (10 000 device_ids par groupe au maximum). Cette propriété est satisfaite si l'appareil correspond à un device_id de la liste.
    • build_brand : fabricant de l'appareil.
    • build_device : code du modèle de l'appareil.
  • excluded_device_ids : modèles d'appareils à exclure dans ce sélecteur (10 000 device_ids par groupe au maximum). Cette propriété est satisfaite si l'appareil ne correspond à aucun device_id de la liste.
    • build_brand : fabricant de l'appareil.
    • build_device : code du modèle de l'appareil.

  • required_system_features : fonctionnalités qu'un appareil doit avoir pour être pris en compte par ce sélecteur (100 fonctionnalités maximum par groupe). Un appareil doit disposer de toutes les fonctionnalités système de cette liste pour répondre à cette propriété.

    Référence des fonctionnalités système

    • name : fonctionnalité système

  • forbidden_system_features : fonctionnalités dont l'appareil ne doit pas être équipé pour être pris en compte par ce sélecteur (100 fonctionnalités maximum par groupe). Si un appareil possède l'une des fonctionnalités système de cette liste, il ne répond pas à cette propriété.

    Référence des fonctionnalités système

    • name : fonctionnalité système

  • system-on-chip : systèmes sur une puce à inclure dans ce sélecteur. Un appareil doit disposer d'un des chipsets de cette liste pour répondre à cette propriété.

Voici un exemple montrant toutes les propriétés d'appareil possibles :

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

Codes officiels du fabricant et du modèle de l'appareil

Pour trouver le bon formatage pour le fabricant de l'appareil et le code du modèle, utilisez le catalogue d'appareils dans la Google Play Console en suivant l'une de ces méthodes :

  • Inspectez les appareils individuels à l'aide du catalogue d'appareils, et trouvez le fabricant et le code du modèle aux emplacements indiqués dans l'exemple ci-dessous. (Pour un Google Pixel 4a, le fabricant est "Google" et le code du modèle est "sunfish".)

    page du Pixel 4a dans le catalogue d&#39;appareils

    page du Pixel 4a dans le catalogue d&#39;appareils

  • Téléchargez un fichier CSV des appareils compatibles, et utilisez le fabricant et le code du modèle pour les champs build_brand et build_device, respectivement.

Inclure votre fichier de configuration de ciblage par appareil dans votre app bundle

Ajoutez le code suivant au fichier build.gradle de votre module principal :

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 correspond au chemin d'accès à votre fichier de configuration par rapport au module principal. Cela garantit que votre fichier de configuration est inclus dans votre app bundle.

La clause deviceGroup garantit que les APK générés à partir de votre bundle sont divisés par groupes d'appareils.

Utiliser le ciblage par appareil pour vos packs d'IA

Vous pouvez optimiser la taille sur les appareils en ne fournissant vos grands modèles qu'aux appareils capables de les exécuter.

Subdivisez vos packs d'IA par groupes d'appareils en prenant les répertoires de packs d'IA existants créés à la dernière étape, et en ajoutant le suffixe #group_myCustomGroup1, #group_myCustomGroup2, etc. aux dossiers appropriés (comme décrit ci-dessous). Lorsque vous utilisez les packs d'IA dans votre application, vous n'avez pas besoin d'adresser les dossiers par suffixe (en d'autres termes, le suffixe est automatiquement supprimé lors du processus de compilation).

Après avoir effectué l'étape précédente, vous pouvez obtenir le résultat suivant :

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

Dans cet exemple, vous devez faire référence à ai-pack-name/assets/image-classifier/ sans aucun suffixe.

Les appareils du groupe myCustomGroup1 recevront tous les composants sous image-classifier#group_myCustomGroup1/, tandis que ceux du groupe myCustomGroup2 recevront tous les composants sous image-classifier#group_myCustomGroup2/.

Les appareils qui n'appartiennent ni à myCustomGroup1 ni à myCustomGroup2 recevront un pack ai-pack-name vide.

En effet, les appareils qui ne correspondent à aucun groupe d'appareils recevront la variante par défaut de votre pack IA. Cela inclut tout ce qui ne se trouve pas dans un répertoire avec un #group_suffix.

Une fois le pack d'IA téléchargé, vous pouvez vérifier si votre modèle est présent en utilisant AssetManager pour les packs à l'installation ou AiPackManager pour les packs en distribution rapide et à la demande. Des exemples d'implémentation sont fournis pour tous les modes de diffusion dans l'application exemple.

Utiliser le ciblage par types d'appareil pour vos modules de fonctionnalité

Vous pouvez également utiliser le ciblage par types d'appareil pour les modules de fonctionnalités. Au lieu de subdiviser les modules de fonctionnalités par groupe d'appareils, vous spécifiez si l'ensemble du module doit être distribué en fonction de l'appartenance à un groupe d'appareils.

Pour distribuer un module de fonctionnalité aux appareils appartenant à myCustomGroup1 ou myCustomGroup2, modifiez son 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>

Tester en local

Avant de créer une version pour votre nouvel app bundle, vous pouvez le tester localement à l'aide du partage interne d'application ou de Bundletool.

Partage interne d'application

Le partage interne d'application vous permet d'utiliser un app bundle pour générer rapidement une URL sur laquelle vous pouvez appuyer sur un appareil local pour installer exactement ce que Google Play installerait pour cet appareil si cette version de l'application était en ligne dans un canal de test ou de production.

Consultez les instructions sur le partage interne d'applications.

Bundletool

Vous pouvez également générer des APK à l'aide de bundletool (1.18.0 ou version ultérieure) et les transférer sur votre appareil. Pour tester votre application en local à l'aide de bundletool, procédez comme suit :

  1. Créez votre app bundle avec Android Studio ou bundletool.

  2. Générez des APK avec l'indicateur --local-testing :

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

  3. Connectez un appareil et exécutez bundletool pour télécharger les APK indépendamment :

    # 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

Limites des tests en local avec bundletool

Voici les limites des tests en local avec bundletool :

  • Les packs fast-follow se comportent comme des packs on-demand. Ils ne seront donc pas automatiquement récupérés lorsque l'application sera téléchargée indépendamment. Les développeurs doivent en faire la demande manuellement au début de l'application. L'opération ne nécessite aucune modification du code dans votre application.
  • Les packs récupèrent des données sur un espace de stockage externe plutôt que sur Play. Vous ne pouvez donc pas tester le comportement de votre code en cas d'erreurs réseau.
  • Les tests en local ne couvrent pas les situations d'attente de Wi-Fi.
  • Les mises à jour ne sont pas compatibles. Avant d'installer une nouvelle version de votre build, désinstallez manuellement la version précédente.

Vérifier que les APK appropriées sont installées

Utilisez la méthode suivante pour vous assurer que seuls les APK appropriés sont installés sur l'appareil.

adb shell pm path {packageName}

Vous devriez obtenir un résultat semblable au suivant :

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

Notez que seuls les APK de cette liste sont créés à partir de modules de fonctionnalités et de packs d'IA au moment de l'installation. Les packs d'IA à distribution rapide et à la demande ne sont pas installés en tant qu'APK.

Tester et publier sur Google Play

Nous vous recommandons de tester votre application de bout en bout sur Google Play avec un canal de test interne.

Une fois cette opération effectuée, vous pouvez déployer progressivement la mise à jour de votre application en production à l'aide des déploiements par étapes.

Exemple d'application utilisant Play pour l'IA sur l'appareil

Téléchargez l'exemple d'application.

Il explique comment utiliser chacun des modes de diffusion, ainsi que la configuration du ciblage par appareil. Pour commencer, consultez la section Tests locaux.

Contenu associé

En savoir plus sur les Android App Bundles et consulter les références pour le SDK AI Delivery