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 de ML personnalisés. Vous pouvez ainsi améliorer les performances des modèles tout en réduisant la complexité de l'écosystème d'appareils, sans frais supplémentaires. Il vous permet de publier sur Play un seul artefact contenant votre code, vos éléments 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.
  • Proposez vos modèles de ML au moment de l'installation, en téléchargement rapide ou à la demande.
    • La diffusion au moment de l'installation peut garantir qu'un modèle très volumineux est présent lorsque votre application est ouverte. Votre modèle sera installé en tant qu'APK.
    • La livraison rapide s'effectue automatiquement en arrière-plan après l'installation de votre application. Les utilisateurs peuvent ouvrir votre application avant que votre modèle ne soit complètement téléchargé. Votre modèle sera téléchargé dans l'espace de stockage interne de votre application.
    • La livraison à 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.
  • Proposez des variantes de vos modèles de ML ciblant des appareils spécifiques en fonction du modèle d'appareil, des propriétés système ou de la RAM.
  • Les mises à jour d'applications restent légères et optimisées grâce à l'application automatique de correctifs par Play, ce qui signifie que seules les différences entre les fichiers doivent être téléchargées.

Remarques

  • En utilisant Play pour l'IA on-device, vous acceptez les conditions du Contrat relatif à la distribution pour les développeurs Google Play et les Conditions d'utilisation du kit de développement logiciel Play Core.
  • Les modèles téléchargés par Play pour l'IA sur l'appareil ne doivent être utilisés que par vos applications. Les modèles ne doivent pas être proposés à d'autres applications.
  • Les packs d'IA individuels peuvent atteindre 1,5 Go, en fonction de leur taille de téléchargement compressée. La taille maximale cumulée 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 plus.

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 app bundle. Vous pouvez choisir de diffuser le pack d'IA au moment de l'installation, en 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 en même temps que le 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 garantit que l'utilisateur n'aura pas à le télécharger à nouveau. Play ne téléchargera que les modifications 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é de sorte 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 d'IA, puis accédez-y en suivant les instructions pour les packs d'installation ou pour les packs de distribution rapide et à la demande.

Complément d'informations :

Premiers pas avec les packs d'IA

De manière générale, 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 diffusés.
  2. [Facultatif] Si vous souhaitez diffuser différents modèles sur différents appareils, vous pouvez configurer le ciblage par types d'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 dotés d'au moins 6 Go de RAM, et aucun modèle à tous les autres appareils.
  3. [Facultatif] Si vous utilisez la livraison à la demande ou la livraison rapide, intégrez la bibliothèque Play AI Delivery à votre application pour télécharger vos packs d'IA selon vos besoins.
  4. Testez et publiez votre app bundle sur Google Play.

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 fournie avec Android Studio Ladybug 2.

Extraire votre modèle dans un pack IA

Android Studio n'est pas requis 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 des 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 de diffusion de vos packs d'IA. Consultez les instructions pour install-time et fast-follow/à la demande 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 être installés au moment de l'installation sont disponibles immédiatement au lancement de l'application. Utilisez l'API AssetManager Java 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 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 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 IA inconnu ou packs 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 présente 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é téléchargée de manière indépendante). Notez que l'appel de showConfirmationDialog() dans ce cas entraînera la mise à jour de l'application. Après la mise à jour, vous devrez demander à nouveau 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 types d'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 demande

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 types d'appareil vous permet de mieux contrôler les parties de votre app bundle qui sont diffusées sur des appareils spécifiques. Par exemple, vous pouvez vous assurer qu'un modèle volumineux 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 :

Présentation des étapes requises

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

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

Vérifier la version du plug-in Android Gradle

Pour utiliser le ciblage par types d'appareil, assurez-vous que votre version du plug-in Android Gradle (AGP) est au moins la version 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 types d'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 types d'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 qui contient tous les appareils équipés du système sur une 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 au maximum. Un appareil est inclus dans un groupe d'appareils s'il correspond à 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 d'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 sera placé dans le groupe par défaut "Autre". Ce groupe est généré automatiquement et ne doit pas être défini explicitement.

Propriétés d'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 satisfaire 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 de l'une des puces de cette liste pour satisfaire 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'appareils

    page du Pixel 4a dans le catalogue d'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 du ciblage par types d'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 est le 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 types d'appareil pour vos packs IA

Vous pouvez optimiser la taille sur les appareils en ne diffusant vos grands modèles que sur les 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 à l'étape précédente et en ajoutant un suffixe 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'ajouter de suffixe aux dossiers (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 feriez référence à ai-pack-name/assets/image-classifier/ sans aucun suffixe.

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 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 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 installés au moment de l'installation ou d'AiPackManager pour les packs installés en distribution rapide et à la demande. Des exemples de cette procédure 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 à un groupe d'appareils.

Pour diffuser un module de fonctionnalité sur des 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 avec le partage interne d'application ou 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 afin d'installer exactement ce que Google Play installerait pour cet appareil si cette version de l'application était disponible dans un canal de test ou de production.

Consultez les instructions concernant 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 charger de manière indépendante 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

Les restrictions des tests en local avec bundletool sont les 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 bons APK 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 devez 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 cette liste ne contient que des APK, 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 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 de 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 types d'appareil. Pour commencer, consultez la section Tests locaux.

Ressources associées

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