Cette page a été traduite par l'API Cloud Translation.

Play pour le programme en accès anticipé (PAA) de l'IA sur l'appareil
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Introduction

Play pour l'IA sur l'appareil offre 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 une complexité d'écosystème réduite, et ce sans frais supplémentaires. Il vous permet de publier un seul artefact sur Play contenant votre code, vos composants et vos modèles de ML, et de choisir parmi plusieurs modes de diffusion 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, en mode distribution rapide 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 distribution rapide s'effectue automatiquement en arrière-plan une fois votre application installée. Les utilisateurs peuvent ouvrir votre application avant que votre modèle ne soit 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 parcours 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 système ou de la RAM.
Réduisez la taille des mises à jour d'applications et optimisez-les grâce au correctif automatique de Play. Cela signifie que seules les différences entre les fichiers doivent être téléchargées.

Points à prendre en compte

En utilisant Play pour l'IA sur l'appareil, vous acceptez les conditions du Contrat relatif à la distribution pour les développeurs Google Play et les Conditions d'utilisation du software development kit (kit de développement logiciel) Play Core.
Les développeurs qui participent au programme en accès anticipé doivent évaluer Play pour l'IA sur l'appareil et fournir des commentaires à Google Play.
Les modèles téléchargés par Play pour l'IA sur l'appareil ne peuvent être utilisés que par l'application qui les a téléchargés. Les modèles ne doivent pas être proposés à d'autres applications, par exemple via une connexion de service.
Les packs d'IA individuels peuvent atteindre 1,5 Go, en fonction de leur taille de téléchargement compressée. La taille cumulée maximale de toute version de votre application générée à partir de votre app bundle est de 4 Go.
Les applications de plus de 1 Go doivent définir le niveau de SDK minimal sur 21 ou version ultérieure.
Les fonctionnalités Play pour l'IA sur l'appareil sont susceptibles de changer pendant le programme d'accès anticipé.

Utiliser Play pour l'IA sur l'appareil

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

En empaquetant des 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 par étapes, pour gérer la distribution de votre application avec vos modèles personnalisés.

Les packs d'IA sont mis à jour avec le fichier binaire de l'application. Si la nouvelle version de votre application ne modifie pas un pack d'IA, le processus de correction automatique de Play garantit que l'utilisateur n'a pas besoin de le télécharger à nouveau. Play ne téléchargera que ce qui a changé 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 expédier des bibliothèques ou du code pour exécuter votre modèle de ML, déplacez-les dans le module de base ou un module de fonctionnalité. Vous pouvez configurer votre module de fonctionnalités afin qu'il dispose des mêmes paramètres de téléchargement et de ciblage que le pack d'IA.

Utiliser LiteRT et MediaPipe avec les packs d'IA

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

Complément d'informations:

Premiers pas avec LiteRT
- L'application exemple montre comment empaqueter un modèle LiteRT dans un pack d'IA et le charger au moment de l'exécution.
- De nombreux modèles LiteRT pré-entraînés sont disponibles dans les packs d'IA pour vous aider à vous lancer.
Premiers pas avec MediaPipe
- Pour les packs à distribution rapide et à la demande, vous pouvez utiliser AssetCache.java pour charger vos éléments (par exemple, .binarypb) par leur chemin d'accès.
- Pour les packages au moment de l'installation, vous pouvez utiliser AndroidAssetUtil.java.

Premiers pas avec les packs d'IA

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

Indiquez à Google Play l'ID de votre compte de développeur Play pour rejoindre le programme en accès anticipé.
Mettez vos modèles dans des packs d'IA dans votre Android App Bundle et spécifiez comment les packs d'IA doivent être diffusés.
[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 distribuer 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.
[Facultatif] Si vous utilisez la distribution à la demande ou la distribution rapide, intégrez la bibliothèque Play AI Delivery à votre application pour télécharger vos packs d'IA si nécessaire.
Testez et publiez votre app bundle sur Google Play.

Indiquer l'ID de votre compte de développeur Play

Étant donné que cette fonctionnalité est en accès anticipé, votre compte de développeur doit être ajouté à la liste d'autorisation pour avoir accès à Play pour l'IA sur l'appareil. Confirmez les ID de compte de développeur Play et les noms de package d'application à votre Partner Manager Google Play ou à un membre de l'équipe Play pour l'IA sur l'appareil. Indiquez si vous allez cibler vos modèles sur des appareils spécifiques (étape 3 de la section précédente). Pour le moment, nous invitons certains partenaires Play à tester cette fonctionnalité.

Vérifier la version du plug-in Android Gradle

Pour utiliser les packs d'IA, assurez-vous que la version de votre plug-in Android Gradle (AGP) est au moins la version 8.8. Cette version est empaquetée 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.

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 pack d'IA doivent commencer par une lettre et ne peuvent contenir que des lettres, des chiffres et des traits de soulignement.

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 ]"
    }
}

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"]
}
```
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'
```
Dans votre pack d'IA, créez un répertoire src/main/assets/.
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
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.
[Facultatif] Configurez le ciblage par appareil pour diffuser différents modèles sur différents appareils.
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 le moment de 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 distribution rapide ou à la demande, utilisez la bibliothèque de distribution Play AI.

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

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

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 package 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 package affiche 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 se produire lorsque l'application n'est pas reconnue par Play (par exemple, si l'application a été installée en mode hors connexion). Notez que l'appel de showConfirmationDialog() dans ce cas entraîne 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 d'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 diffusées sur des appareils spécifiques. Par exemple, vous pouvez vous assurer qu'un grand modèle n'est diffusé que sur les appareils disposant d'une grande quantité de RAM, ou vous pouvez diffuser différentes versions d'un modèle sur différents appareils.

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

Système sur une puce
Modèle de l'appareil
RAM de l'appareil
Fonctionnalités système

Présentation des étapes requises

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

Définissez vos groupes d'appareils dans un fichier XML.
Spécifiez les parties de votre bundle à attribuer à chaque groupe d'appareils.
[Facultatif] Testez votre configuration localement.
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 la version de votre plug-in Android Gradle (AGP) est au moins 8.10.0-alpha01. Il est empaqueté avec Android Studio Meerkat 2, qui est disponible en canary.

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 par appareil 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 contenant tous les appareils équipé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é de cinq sélecteurs d'appareils maximum. 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'appareil 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 correspondant au groupe défini en premier dans le fichier XML. L'ordre dans lequel vous définissez des groupes dans le fichier XML correspond à votre ordre de priorité.

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

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 (1 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 (1 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ème sur une puce à inclure dans ce sélecteur. Un appareil doit disposer d'une puce de cette liste pour répondre à cette propriété.
- manufacturer : fabricant du système sur puce
- model: modèle SoC

Conseil : L'ajout de plusieurs propriétés dans un même sélecteur crée un opérateur logique ET, comme illustré dans l'exemple ci-dessous.

    <config:device-selector ram-min-bytes="7000000000">
        <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

crée la condition pour tous les appareils qui correspondent à des Pixel 4 ET qui disposent de plus de 7 Go de RAM, également écrit comme suit :

Si vous souhaitez utiliser une condition OU, créez des sélecteurs distincts dans un seul groupe d'appareils, par exemple:

    <config:device-selector ram-min-bytes="7000000000"/>
    <config:device-selector>
          <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

crée la condition pour tous les appareils qui correspondent à des Pixel 4 OU qui disposent de plus de 7 Go de RAM, également écrit comme suit :

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".)
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 de votre fichier de configuration par rapport au module principal. Cela garantit que votre fichier de configuration est empaqueté avec 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 maintenir la taille optimisée sur les appareils en ne distribuant vos grands modèles qu'aux appareils qui peuvent les exécuter.

Subdivisez vos packs d'IA par groupes d'appareils en prenant les répertoires de packs d'IA existants créés à l'étape précédente, puis en ajoutant un postfixe aux dossiers appropriés (comme décrit ci-dessous) avec #group_myCustomGroup1, #group_myCustomGroup2, etc. Lorsque vous utilisez les packs d'IA dans votre application, vous n'avez pas besoin d'adresser les dossiers par postfixe (en d'autres termes, le postfixe 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 référencer ai-pack-name/assets/image-classifier/ sans postfixe.

Les appareils de myCustomGroup1 recevront tous les éléments de image-classifier#group_myCustomGroup1/, tandis que les appareils de myCustomGroup2 recevront tous les éléments de image-classifier#group_myCustomGroup2/.

Les appareils qui n'appartiennent ni à myCustomGroup1 ni à myCustomGroup2 recevront un package 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 élément qui ne se trouve pas dans un répertoire avec un #group_suffix.

Une fois que vous avez téléchargé le pack d'IA, vous pouvez vérifier si votre modèle est présent à l'aide d'AssetManager pour les packs au moment de l'installation ou d'AiPackManager pour les packs en distribution rapide et à la demande. Des exemples sont présentés 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 diffusé en fonction de l'appartenance au 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 nouveau bundle, vous pouvez effectuer des tests locaux à 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 que 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'application.

Bundletool

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

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

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

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

Les tests en local avec bundletool présentent les limites suivantes:

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és sont installés

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 vous ne verrez que des APK dans cette liste, qui sont créés à partir de modules de fonctionnalités et de packs d'IA au moment de l'installation. Les packs d'IA à la demande et à distribution rapide 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 à l'aide d'un canal de test interne.

Une fois cette étape effectuée, vous pouvez déployer progressivement la mise à jour de votre application en production avec des déploiements par étapes.

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

Contactez votre Partner Manager Google Play pour accéder à notre application exemple.

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

Envoyer des commentaires

Les participants au programme en accès anticipé doivent signaler les problèmes et partager leurs commentaires. Vous pouvez contacter votre Partner Manager Google Play ou l'équipe Play pour l'IA sur l'appareil.

Contenu associé

En savoir plus sur les Android App Bundles et consulter les références du SDK de diffusion de l'IA

Play pour le programme en accès anticipé (PAA) de l'IA sur l'appareil Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Introduction

Avantages

Points à prendre en compte

Utiliser Play pour l'IA sur l'appareil

Utiliser LiteRT et MediaPipe avec les packs d'IA

Premiers pas avec les packs d'IA

Indiquer l'ID de votre compte de développeur Play

Vérifier la version du plug-in Android Gradle

Extraire votre modèle dans un pack d'IA

Configurer la distribution au moment de l'installation

Configurer la distribution rapide et à la demande

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

Vérifier l'état

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

Installer

Surveiller l'état des téléchargements

Téléchargements volumineux

Confirmation de l'utilisateur requise

Accéder aux packs IA

Configurer le ciblage par types d'appareil

Autres méthodes de l'API Play AI Delivery

Annuler la requête

Supprimer un pack d'IA

Obtenir les emplacements de plusieurs packs d'IA

Ciblage par types d'appareil

Présentation des étapes requises

Vérifier la version du plug-in Android Gradle

Activer cette fonctionnalité dans le plug-in Android Gradle

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

Propriétés de l'appareil disponibles

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

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

Utiliser le ciblage par appareil pour vos packs d'IA

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

Tester en local

Partage interne d'application

Bundletool

Limites des tests en local avec bundletool

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

Tester et publier sur Google Play

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

Envoyer des commentaires

Contenu associé

Play pour le programme en accès anticipé (PAA) de l'IA sur l'appareil
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.