Play para la IA integrada en el dispositivo (beta)

Introducción

Play for On-device AI ofrece los beneficios de los Android App Bundles y la publicación de Google Play a la distribución de modelos de AA personalizados para que puedas mejorar el rendimiento del modelo con menos complejidad en el ecosistema de dispositivos sin costo adicional. Te permite publicar un solo artefacto en Play que contenga tu código, recursos y modelos de AA, y elegir entre varios modos de entrega y opciones de segmentación.

Beneficios

  • Sube un solo artefacto de publicación a Google Play y delega el alojamiento, la entrega, las actualizaciones y la segmentación en Play sin costo adicional.
  • Entrega tus modelos de AA en el momento de la instalación, con seguimiento rápido o a pedido.
    • La entrega durante la instalación puede garantizar que un modelo muy grande esté presente cuando se abra tu app. Tu modelo se instalará como un APK.
    • La entrega posterior rápida se produce automáticamente en segundo plano después de que se instala la app. Es posible que los usuarios abran tu app antes de que se descargue por completo el modelo. El modelo se descargará en el espacio de almacenamiento interno de la app.
    • La entrega a pedido te permite solicitar el modelo en el tiempo de ejecución, lo que resulta útil si el modelo solo se requiere para ciertos flujos de usuarios. El modelo se descargará en el espacio de almacenamiento interno de la app.
  • Publica variantes de tus modelos de AA segmentadas para dispositivos específicos según el modelo, las propiedades del sistema o la RAM.
  • Mantén las actualizaciones de la app pequeñas y optimizadas con los parches automáticos de Play, lo que significa que solo se deben descargar las diferencias en los archivos.

Consideraciones

  • Si usas Play para la IA en el dispositivo, aceptas las condiciones del Acuerdo de Distribución para Desarrolladores de Google Play y las Condiciones del Servicio del kit de desarrollo de software de Play Core.
  • Los modelos que descarga Play para la IA en el dispositivo solo deben usarse en tus apps. Los modelos no deben ofrecerse a otras apps.
  • Los paquetes de IA individuales pueden tener un tamaño de hasta 1.5 GB, según sus tamaños de descarga comprimidos. El tamaño acumulativo máximo de la app de cualquier versión de tu app generada a partir de tu paquete de aplicación es de 4 GB.
  • Las apps de más de 1 GB deben establecer el nivel de SDK mínimo en 21 o superior.

Cómo usar Play para la IA integrada en el dispositivo

Play para la IA integrada en el dispositivo usa paquetes de IA. Empaqueta en paquetes de IA los modelos personalizados que están listos para la distribución en tu paquete de aplicación. Puedes elegir si el paquete de IA se debe entregar en el momento de la instalación, con seguimiento rápido o a pedido.

Si empaquetas los paquetes de IA con tu paquete de aplicación, puedes usar todas las herramientas de prueba y lanzamiento existentes de Play, como los segmentos de prueba y los lanzamientos por etapas, para administrar la distribución de tu app con tus modelos personalizados.

Los paquetes de IA se actualizan junto con el objeto binario de la app. Si la nueva versión de tu app no realiza cambios en un paquete de IA, el proceso de aplicación de parches automático de Play garantizará que el usuario no tenga que volver a descargarlo. Play solo descargará lo que cambió cuando actualice la app.

Los paquetes de IA solo contienen modelos. No se permiten bibliotecas nativas ni de Java o Kotlin. Si necesitas enviar bibliotecas o código para ejecutar tu modelo de AA, muévelo al módulo básico o a un módulo de funciones. Puedes configurar tu módulo de funciones para que tenga la misma configuración de descarga y segmentación que el paquete de IA.

Usa LiteRT y MediaPipe con paquetes de IA

Puedes usar LiteRT y MediaPipe con paquetes de IA. Empaqueta tu modelo en un paquete de IA y, luego, accede a él con las instrucciones para los paquetes de tiempo de instalación o para los paquetes de seguimiento rápido y a pedido.

Lecturas adicionales:

Comienza a usar los paquetes de IA

A nivel general, así puedes comenzar a usar Play para la IA integrada en el dispositivo:

  1. Empaqueta tus modelos en paquetes de IA en tu Android App Bundle y especifica cómo se deben entregar los paquetes de IA.
  2. [Opcional] Si deseas publicar diferentes modelos en diferentes dispositivos, puedes configurar la segmentación por dispositivos para tus paquetes de IA. Por ejemplo, podrías entregar el paquete de IA A a un modelo de dispositivo específico, el paquete de IA B a dispositivos con al menos 6 GB de RAM y todos los demás dispositivos podrían no recibir ningún modelo.
  3. [Opcional] Si usas la entrega on demand o de seguimiento rápido, integra la biblioteca de Play AI Delivery en tu app para descargar los paquetes de IA según sea necesario.
  4. Prueba y lanza tu paquete de aplicación en Google Play.

Cómo verificar la versión del complemento de Android para Gradle

Para usar los paquetes de IA, asegúrate de que la versión del complemento de Gradle para Android (AGP) sea al menos la 8.8. Esta versión se incluye en Android Studio Ladybug 2.

Extrae tu modelo en un paquete de IA

No se requiere Android Studio para los siguientes pasos.

  1. En el directorio de nivel superior de tu proyecto, crea un directorio para el paquete de IA. Se usa el nombre de ese directorio como el nombre del paquete de IA. Los nombres de los paquetes de IA deben comenzar con una letra y solo pueden contener letras, números y guiones bajos.

  2. En el directorio del paquete de IA, crea un archivo build.gradle y agrega el siguiente código. Asegúrate de especificar el nombre del paquete de IA y solo un tipo de entrega:

    // 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. En el archivo build.gradle de la app del proyecto, agrega el nombre de cada paquete de IA de tu proyecto, como se muestra a continuación:

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

  4. En el archivo settings.gradle del proyecto, incluye todos los paquetes de IA de tu proyecto, como se muestra a continuación:

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

  5. Dentro de tu paquete de IA, crea un directorio src/main/assets/.

  6. Coloca tus modelos en el directorio src/main/assets. Aquí también puedes crear subdirectorios. Ahora la estructura del directorio de tu app debería verse de la siguiente manera:

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

  7. Agrega código para cargar y ejecutar tus modelos. La forma de hacerlo dependerá del modo de entrega de tus paquetes de IA. Consulta las instrucciones para el tiempo de instalación y el seguimiento rápido o a pedido a continuación.

  8. [Opcional] Configura la segmentación por dispositivos para publicar diferentes modelos en diferentes dispositivos.

  9. Compila el Android App Bundle con Gradle. En el paquete de aplicación que se generó, el directorio raíz ahora incluye lo siguiente:

    • ai-pack-name/manifest/AndroidManifest.xml: Configura el identificador y el modo de entrega del paquete de IA.
    • ai-pack-name/assets/your-model-directories: Es el directorio que contiene todos los recursos entregados como parte del paquete de IA.

    Gradle genera el manifiesto para cada paquete de IA y genera el directorio assets/ por ti.

Cómo configurar la entrega durante la instalación

Los paquetes de IA configurados como de instalación están disponibles inmediatamente en el lanzamiento de la app. Usa la API de AssetManager de Java para acceder a los paquetes de IA que se entregan en este modo:

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

Cómo configurar la entrega rápida y a pedido

Para descargar paquetes de IA con entrega de seguimiento rápido o a pedido, usa la biblioteca de Play AI Delivery.

Declara la dependencia de la biblioteca de Play AI Delivery

En el archivo build.gradle de tu app, declara una dependencia en la biblioteca de Play AI Delivery:

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

Comprueba el estado

Cada paquete de IA se almacena en una carpeta independiente del almacenamiento interno de la app. Usa el método getPackLocation() para determinar la carpeta raíz de un paquete de IA. Este método devuelve los siguientes valores:

Valor que se devuelve Estado
Un objeto AiPackLocation válido La carpeta raíz del paquete de IA está lista para acceder de inmediato a assetsPath()
null No se conoce el paquete de IA o los paquetes de IA no están disponibles

Obtén información de descarga sobre paquetes de IA

Usa el método
getPackStates() para determinar el tamaño de la descarga y si ya se está descargando el paquete.

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

getPackStates() es un método asíncrono que devuelve un Task<AiPackStates>. El método packStates() de un objeto AiPackStates devuelve un elemento Map<String, AiPackState>. Este mapa contiene el estado de cada paquete de IA solicitado, codificado por su nombre:

Map<String, AiPackState> AiPackStates#packStates()

La solicitud final se muestra mediante lo siguiente:

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

Los siguientes métodos AiPackState proporcionan el tamaño del paquete de IA, la cantidad descargada hasta el momento (si se solicita) y la cantidad que ya se transfirió a la app:

Para obtener el estado de un paquete de IA, usa el método status(), que devuelve el estado como un número entero que corresponde a un campo constante en la clase AiPackStatus. Un paquete de IA que aún no está instalado tiene el estado AiPackStatus.NOT_INSTALLED.

Si falla una solicitud, usa el método errorCode(), cuyo valor que se devuelve corresponde a un campo constante en la clase AiPackErrorCode.

Instalar

Usa el método fetch() para descargar un paquete de IA por primera vez o llama a fin de que se complete la actualización de un paquete de IA:

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

Este método devuelve un objeto AiPackStates que contiene una lista de paquetes y sus estados y tamaños de descarga iniciales. Si ya se está descargando un paquete de IA solicitado a través de fetch(), se devolverá el estado de descarga y no se iniciará ninguna descarga adicional.

Supervisa los estados de descarga

Debes implementar un objeto AiPackStateUpdateListener para realizar un seguimiento del progreso de la instalación de paquetes de IA. Las actualizaciones de estado se desglosan por paquete para admitir el seguimiento del estado de paquetes de IA individuales. Puedes comenzar a usar los paquetes de IA disponibles antes de que se completen todas las demás descargas de la solicitud.

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)
Descargas grandes

Si la descarga supera los 200 MB y el usuario no está conectado a una red Wi-Fi, no se iniciará la descarga hasta que el usuario otorgue explícitamente su consentimiento para continuar con la descarga a través de una conexión de datos móviles. Del mismo modo, si la descarga es grande y el usuario pierde la conexión Wi-Fi, esta se detiene y se necesita el consentimiento explícito para continuar usando una conexión de datos móviles. Un paquete detenido tiene el estado WAITING_FOR_WIFI. Para activar el flujo de la IU a fin de solicitar el consentimiento del usuario, usa el método showConfirmationDialog().

Ten en cuenta que si la app no llama a este método, la descarga se detiene y se reanudará automáticamente cuando el usuario vuelva a una conexión Wi-Fi.

Confirmación del usuario obligatoria

Si un paquete tiene el estado REQUIRES_USER_CONFIRMATION, la descarga no continuará hasta que el usuario acepte el diálogo que se muestra con showConfirmationDialog(). Este estado puede ocurrir cuando Play no reconoce la app, por ejemplo, si se transfirió de forma local. Ten en cuenta que, en este caso, llamar a showConfirmationDialog() hará que se actualice la app. Después de la actualización, deberás volver a solicitar los paquetes de IA.

A continuación, se muestra un ejemplo de implementación de un objeto de escucha:

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

También puedes usar el método getPackStates() para obtener el estado de las descargas actuales. AiPackStates contiene el progreso de descarga, el estado de descarga y los códigos de error con fallas.

Accede a los paquetes de IA

Puedes acceder a un paquete de IA a través de llamadas al sistema de archivos después de que la solicitud de descarga alcance el estado COMPLETED. Usa el método getPackLocation() para obtener la carpeta raíz del paquete de IA.

Los paquetes de IA se almacenan en el directorio assets dentro del directorio raíz del paquete de IA. Puedes obtener la ruta al directorio assets con el método útil assetsPath(). Usa el siguiente método para obtener la ruta a un recurso específico:

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

Cómo configurar la segmentación por dispositivo

Puedes seguir las instrucciones de segmentación por dispositivo para especificar los dispositivos o grupos de dispositivos que deben recibir tus paquetes de IA.

Otros métodos de la API de Play AI Delivery

Estos son algunos métodos de API adicionales que te recomendamos usar en tu app.

Cancelar solicitud

Usa cancel() para cancelar una solicitud activa de paquete de IA. Ten en cuenta que esta solicitud es una operación de mejor esfuerzo.

Cómo quitar un paquete de IA

Usa removePack() para programar la eliminación de un paquete de IA.

Obtén las ubicaciones de varios paquetes de IA

Usa getPackLocations() para consultar el estado de varios paquetes de IA de forma masiva, lo que devuelve un mapa de los paquetes de IA y sus ubicaciones. El mapa que devuelve getPackLocations() contiene una entrada para cada paquete que se descarga y está actualizado.

Segmentación por dispositivo

La segmentación por dispositivo te brinda un mayor control sobre qué partes de tu paquete de aplicación se entregan a dispositivos específicos. Por ejemplo, podrías asegurarte de que un modelo grande solo se publique en dispositivos con RAM alta o podrías publicar diferentes versiones de un modelo en diferentes dispositivos.

Puedes segmentar tus anuncios según las propiedades del dispositivo, como las siguientes:

Descripción general de los pasos requeridos

Sigue estos pasos para habilitar la segmentación por dispositivo:

  1. Define tus grupos de dispositivos en un archivo XML.
  2. Especifica qué partes de tu paquete deben ir a qué grupos de dispositivos.
  3. [Opcional] Prueba tu configuración de forma local.
  4. Sube tu paquete (que contiene el archivo XML) a Google Play.

Cómo verificar la versión del complemento de Android para Gradle

Para usar la segmentación por dispositivo, asegúrate de que tu versión del complemento de Android para Gradle (AGP) sea al menos la 8.10.0. Se incluye en Android Studio (Meerkat 2 y versiones posteriores). Descarga la versión estable más reciente de Android Studio.

Cómo habilitar esta función en el complemento de Android para Gradle

La segmentación por dispositivo debe habilitarse de forma explícita en tu archivo gradle.properties:

android.experimental.enableDeviceTargetingConfigApi=true

Crea un archivo XML de configuración de segmentación por dispositivo

El archivo de configuración de segmentación por dispositivo es un archivo XML en el que defines tus grupos de dispositivos personalizados. Por ejemplo, podrías definir un grupo de dispositivos llamado qti_v79 que contenga todos los dispositivos con el sistema en chip Qualcomm SM8750:

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="qti_v79">
        <config:device-selector>
            <config:system-on-chip manufacturer="QTI" model="SM8750"/>
        </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

Un grupo de dispositivos se compone de hasta 5 selectores de dispositivos. Un dispositivo se incluye en un grupo de dispositivos si satisface cualquiera de sus selectores de dispositivos.

Un selector de dispositivos puede tener una o más propiedades de dispositivos. Un dispositivo se selecciona si coincide con todas las propiedades del dispositivo del selector.

Si un dispositivo coincide con varios grupos, se entregará el contenido del grupo que se defina primero en el archivo XML. El orden en el que defines los grupos en el archivo XML es tu orden de prioridad.

Si un dispositivo no coincide con ningún grupo, recibirá el grupo predeterminado "otro". Este grupo se genera automáticamente y no debe definirse de forma explícita.

Propiedades de dispositivos disponibles

  • device_ram: Requisitos de RAM del dispositivo
    • min_bytes (inclusive): RAM mínima requerida (en bytes)
    • max_bytes (exclusive): RAM máxima requerida (en bytes)
  • included_device_ids: Modelos de dispositivos que se incluirán en este selector (10,000 device_ids por grupo como máximo). Esta propiedad se cumple si el dispositivo coincide con algún device_id de la lista.
    • build_brand: Fabricante del dispositivo
    • build_device: Código del modelo del dispositivo
  • excluded_device_ids: Modelos de dispositivos que se excluirán en este selector (10,000 device_ids por grupo como máximo). Esta propiedad se cumple si el dispositivo no coincide con ningún device_id de la lista.
    • build_brand: Fabricante del dispositivo
    • build_device: Código del modelo del dispositivo

  • required_system_features: Son las funciones que un dispositivo debe tener para que se lo incluya en este selector (100 funciones por grupo como máximo). Un dispositivo debe tener todas las funciones del sistema de esta lista para satisfacer esta propiedad.

    Referencia de las funciones del sistema

    • name: Una función del sistema

  • forbidden_system_features: Son las funciones que un dispositivo no debe tener para que se incluya en este selector (100 funciones por grupo como máximo). Si un dispositivo tiene alguna de las funciones del sistema que se detallan en esta lista, no satisface esta propiedad.

    Referencia de las funciones del sistema

    • name: Una función del sistema

  • system-on-chip: Sistemas en chip que se incluirán en este selector. Un dispositivo debe tener cualquier chip de esta lista para satisfacer esta propiedad.

A continuación, se muestra un ejemplo con todas las propiedades posibles del dispositivo:

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

Códigos oficiales del fabricante y el modelo del dispositivo

Puedes encontrar el formato correcto para el fabricante y el código del modelo del dispositivo en el catálogo de dispositivos de Google Play Console optando por una de las siguientes maneras:

  • Inspecciona los dispositivos individuales con el catálogo de dispositivos y encuentra el fabricante y el código del modelo en las ubicaciones como se muestra en el siguiente ejemplo (para un Google Pixel 4a, el fabricante es "Google" y el código del modelo es "sunfish").

    Página del Pixel 4a en el catálogo de dispositivos

    Página del Pixel 4a en el catálogo de dispositivos

  • Descarga un archivo CSV de dispositivos compatibles y usa el Fabricante y el Código del modelo para los campos build_brand y build_device, respectivamente.

Incluye el archivo de configuración de segmentación por dispositivo en tu paquete de aplicación

Agrega lo siguiente al archivo build.gradle de tu módulo 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 es la ruta de acceso de tu archivo de configuración en relación con el módulo principal. Esto garantiza que el archivo de configuración se empaquete con tu paquete de aplicación.

La cláusula deviceGroup garantiza que los APKs generados a partir de tu paquete se dividan por grupos de dispositivos.

Usa la segmentación por dispositivo para tus paquetes de IA

Puedes mantener la optimización del tamaño en los dispositivos entregando tus modelos grandes solo a los dispositivos que puedan ejecutarlos.

Para subdividir tus paquetes de IA por grupos de dispositivos, toma los directorios de paquetes de IA existentes que creaste en el último paso y agrega el sufijo correspondiente a las carpetas (como se describe a continuación) con #group_myCustomGroup1, #group_myCustomGroup2, etcétera. Cuando uses los paquetes de IA en tu app, no necesitarás agregar el sufijo a las carpetas (en otras palabras, el sufijo se quita automáticamente durante el proceso de compilación).

Después del paso anterior, podría verse así:

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

En este ejemplo, harías referencia a ai-pack-name/assets/image-classifier/ sin ningún sufijo.

Los dispositivos en myCustomGroup1 recibirán todos los recursos en image-classifier#group_myCustomGroup1/, mientras que los dispositivos en myCustomGroup2 recibirán todos los recursos en image-classifier#group_myCustomGroup2/.

Los dispositivos que no pertenezcan a myCustomGroup1 ni a myCustomGroup2 recibirán un paquete ai-pack-name vacío.

Esto se debe a que los dispositivos que no coincidan con ningún grupo de dispositivos recibirán la variante predeterminada de tu paquete de IA. Esto incluye todo lo que no esté dentro de un directorio con un #group_suffix.

Una vez que hayas descargado el paquete de IA, puedes verificar si tu modelo está presente con AssetManager para los paquetes de instalación o AiPackManager para los paquetes de seguimiento rápido y a pedido. En la app de ejemplo, se muestran ejemplos para realizar esta acción en todos los modos de entrega.

Usa la segmentación por dispositivo para tus módulos de funciones

También puedes usar la segmentación por dispositivo para los módulos de funciones. En lugar de subdividir los módulos de funciones por grupo de dispositivos, debes especificar si se debe entregar el módulo completo según la pertenencia al grupo de dispositivos.

Para entregar un módulo de funciones a los dispositivos que pertenecen a myCustomGroup1 o myCustomGroup2, modifica su 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>

Realiza pruebas locales

Antes de crear una versión para tu nuevo paquete, puedes realizar pruebas locales con el uso compartido interno de apps o Bundletool.

Uso compartido de apps a nivel interno

El uso compartido interno de apps te permite usar un paquete de aplicación para generar rápidamente una URL en la que puedes presionar en un dispositivo local para instalar exactamente lo que Google Play instalaría para ese dispositivo si esa versión de la app estuviera publicada en un segmento de prueba o de producción.

Consulta las instrucciones para compartir apps a nivel interno.

Bundletool

Como alternativa, puedes generar APKs con bundletool (1.18.0 o versiones posteriores) y transferirlos de forma local a tu dispositivo. Sigue estos pasos para probar tu app de forma local con bundletool:

  1. Compila tu paquete de aplicación con Android Studio o bundletool.

  2. Genera APK con la marca --local-testing:

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

  3. Conecta un dispositivo y ejecuta bundletool para transferir los APK:

    # Example without Device Targeting Configuration
java -jar bundletool.jar install-apks --apks=output.apks

    # Example with Device Targeting Configuration (you must specify which groups the connected device belongs to)
java -jar bundletool.jar install-apks --apks=output.apks --device-groups=myCustomGroup1,myCustomGroup2

Limitaciones de las pruebas locales con bundletool

Las siguientes son limitaciones de las pruebas locales con bundletool:

  • Los paquetes fast-follow se comportan como paquetes on-demand. Es decir, no se recuperarán automáticamente cuando se transfiera la app. Los desarrolladores deben solicitarlos de forma manual cuando se inicie la app; esto no requiere cambios de código en la app.
  • Los paquetes se recuperan del almacenamiento externo en lugar de Play, por lo que no puedes probar cómo se comporta tu código en caso de errores de red.
  • Las pruebas locales no abarcan la situación de espera de Wi-Fi.
  • No se admiten actualizaciones. Antes de instalar una versión nueva de tu compilación, desinstala la versión anterior de forma manual.

Verifica que se instalen los APKs correctos

Usa el siguiente método para asegurarte de que solo se instalen los APKs correctos en el dispositivo.

adb shell pm path {packageName}

Deberías ver algo como lo siguiente:

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

Ten en cuenta que solo verás los APKs en esta lista, que se crean a partir de módulos de funciones y paquetes de IA en el momento de la instalación. Los paquetes de IA a pedido y de seguimiento rápido no se instalan como APKs.

Prueba y lanza en Google Play

Te recomendamos que pruebes tu app de extremo a extremo en Google Play con un segmento de pruebas internas.

Una vez que lo hagas, podrás lanzar de forma incremental la actualización de tu app para producción con lanzamientos en etapas.

App de ejemplo que usa Play para la IA integrada en el dispositivo

Descarga la app de ejemplo.

En él, se muestra cómo usar cada uno de los modos de entrega, así como la configuración de segmentación por dispositivo. Consulta la sección Pruebas locales para comenzar.

Contenido relacionado

Obtén más información sobre los Android App Bundles y consulta las referencias del SDK de AI Delivery.