Google Play no programa de acesso antecipado (PAA) da IA no dispositivo

Introdução

O Play para IA no dispositivo traz os benefícios dos Android App Bundles e do envio do Google Play para a distribuição de modelos ML personalizados. Assim, você pode melhorar a performance do modelo com menos complexidade do ecossistema sem custo financeiro extra. Ele permite que você publique um único artefato no Google Play contendo seu código, recursos e modelos de ML e escolha entre vários modos de entrega e opções de segmentação.

Vantagens

  • Faça upload de um único artefato de publicação no Google Play e delegue a hospedagem, o envio, as atualizações e a segmentação para o Google Play sem custo financeiro extra.
  • Envie seus modelos de ML no momento da instalação, em exibição rápida ou on demand.
    • A entrega no momento da instalação pode garantir que um modelo muito grande esteja presente quando o app for aberto. Seu modelo será instalado como um APK.
    • O envio rápido ocorre automaticamente em segundo plano depois que o app é instalado. Os usuários podem abrir o app antes que o modelo seja completamente transferido. O modelo será transferido para o espaço de armazenamento interno do app.
    • O envio sob demanda permite que você solicite o modelo no momento da execução, o que é útil se o modelo for necessário apenas para determinados fluxos de usuários. O modelo será transferido para o espaço de armazenamento interno do app.
  • Forneça variantes dos seus modelos de ML segmentadas para dispositivos específicos com base no modelo do dispositivo, nas propriedades do sistema ou na RAM.
  • Mantenha as atualizações do app pequenas e otimizadas com o patch automático do Google Play, o que significa que apenas as diferenças nos arquivos precisam ser baixadas.

Considerações

  • Ao usar a Play para IA no dispositivo, você concorda com os termos do Contrato de distribuição para desenvolvedores do Google Play e dos Termos de Serviço do kit de desenvolvimento de software da Play Core.
  • Os desenvolvedores que participam do programa de acesso antecipado precisam avaliar o Google Play para IA no dispositivo e enviar feedback.
  • Os modelos baixados pelo Google Play para a IA no dispositivo só podem ser usados pelo app que fez o download. Os modelos não podem ser oferecidos a outros apps, por exemplo, por uma conexão de serviço.
  • Os pacotes de IA individuais podem ter até 1,5 GB, com base nos tamanhos de download compactados. O tamanho máximo cumulativo de qualquer versão do app gerada a partir do pacote é de 4 GB.
  • Os apps com mais de 1 GB precisam definir o nível mínimo do SDK como 21 ou mais recente.
  • Durante o programa de acesso antecipado, o Play para IA no dispositivo está sujeito a mudanças.

Como usar o Google Play para IA no dispositivo

O Google Play para IA no dispositivo usa pacotes de IA. Você empacota modelos personalizados prontos para distribuição em pacotes de IA no seu pacote de apps. É possível escolher se o pacote de IA será enviado no momento da instalação, em exibição rápida ou on demand.

Ao empacotar pacotes de IA com seu pacote de apps, você pode usar todas as ferramentas de teste e lançamento do Google Play, como faixas de teste e lançamentos em etapas, para gerenciar a distribuição do app com seus modelos personalizados.

Os pacotes de IA são atualizados junto com o binário do app. Se a nova versão do app não fizer alterações em um pacote de IA, o processo de correção automática do Google Play vai garantir que o usuário não precise fazer o download novamente. O Google Play só vai fazer o download do que foi alterado quando atualizar o app.

Os pacotes de IA só contêm modelos. Bibliotecas Java/Kotlin e nativas não são permitidas. Se você precisar enviar bibliotecas ou código para executar seu modelo de ML, mova-o para o módulo base ou um módulo de recurso. É possível configurar o módulo de recurso para que ele tenha as mesmas configurações de download e segmentação que o pacote de IA.

Usar o LiteRT e o MediaPipe com pacotes de IA

É possível usar o LiteRT e o MediaPipe com pacotes de IA. Empacote seu modelo em um pacote de IA e acesse usando as instruções para pacotes de instalação ou para pacotes de acompanhamento rápido e sob demanda.

Leia mais:

Começar a usar pacotes de IA

De maneira geral, confira como começar a usar o Google Play para IA no dispositivo:

  1. Informe o ID da sua conta de desenvolvedor do Google Play para participar do EAP.
  2. Empacotar seus modelos em pacotes de IA no Android App Bundle e especificar como os pacotes de IA precisam ser enviados.
  3. [Opcional] Se você quiser enviar modelos diferentes para dispositivos diferentes, é possível configurar a segmentação por dispositivo para seus pacotes de IA. Por exemplo, você pode enviar o pacote de IA A para um modelo de dispositivo específico, o pacote de IA B para dispositivos com pelo menos 6 GB de RAM, e todos os outros dispositivos podem receber nenhum modelo.
  4. [Opcional] Se você estiver usando o envio sob demanda ou rápido, integre a biblioteca Play AI Delivery ao seu app para fazer o download dos pacotes de IA conforme necessário.
  5. Teste e lance seu pacote de apps no Google Play.

Informe o ID da sua conta de desenvolvedor do Google Play

Como esse recurso está em acesso antecipado, sua conta de desenvolvedor precisa estar na lista de permissões para ter acesso ao Google Play para IA no dispositivo. Confirme os IDs de conta de desenvolvedor do Google Play e os nomes dos pacotes de apps para seu gerente de parcerias do Google Play ou um membro da equipe de IA no dispositivo. Especifique se você vai segmentar seus modelos para dispositivos específicos (esta é a etapa 3 da seção anterior). No momento, estamos convidando alguns parceiros do Google Play para testar esse recurso.

Verificar a versão do Plug-in do Android para Gradle

Para usar pacotes de IA, verifique se a versão do Plug-in do Android para Gradle (AGP) é pelo menos 8.8. Essa versão é empacotada com o Android Studio Ladybug 2.

Extrair o modelo em um pacote de IA

O Android Studio não é necessário para as etapas a seguir.

  1. No diretório de nível superior do projeto, crie um diretório para o pacote de IA. Esse nome de diretório é usado como o nome do pacote de IA. Os nomes de pacotes de IA precisam começar com uma letra e só podem conter letras, números e sublinhados.

  2. No diretório do pacote de IA, crie um arquivo build.gradle e adicione o seguinte código. Especifique o nome do pacote de IA e apenas um 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. No arquivo build.gradle do app do projeto, adicione o nome de cada pacote de IA, conforme mostrado abaixo:

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

  4. No arquivo settings.gradle do projeto, inclua todos os pacotes de IA, conforme mostrado abaixo:

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

  5. No pacote de IA, crie um diretório src/main/assets/.

  6. Coloque seus modelos no diretório src/main/assets. Você também pode criar subdiretórios nesse local. A estrutura de diretórios do seu app agora terá a seguinte aparência:

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

  7. Adicione código para carregar e executar seus modelos. A maneira de fazer isso depende do modo de entrega dos pacotes de IA. Confira as instruções para tempo de instalação e acesso rápido/sob demanda abaixo.

  8. [Opcional] Configure a segmentação por dispositivo para veicular modelos diferentes em dispositivos diferentes.

  9. Crie o Android App Bundle com o Gradle. No pacote de apps gerado, o diretório de nível raiz agora inclui o seguinte:

    • ai-pack-name/manifest/AndroidManifest.xml: configura o identificador e o modo de entrega do pacote de IA
    • ai-pack-name/assets/your-model-directories: diretório que contém todos os recursos enviados como parte do pacote de IA

    O Gradle gera o manifesto para cada pacote de IA e gera o diretório assets/ para você.

Configurar o envio no momento da instalação

Os pacotes de IA configurados como tempo de instalação ficam disponíveis imediatamente na inicialização do app. Use a API Java AssetManager para acessar pacotes de IA veiculados neste modo:

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

Configurar o envio rápido e sob demanda

Para fazer o download de pacotes de IA com entrega rápida ou sob demanda, use a Biblioteca de Entrega Play AI.

Declarar dependência da biblioteca Play AI Delivery

No arquivo build.gradle do app, declare uma dependência na biblioteca Play AI Delivery:

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

Verificar status

Cada pacote de IA é armazenado em uma pasta separada no armazenamento interno do app. Use o método getPackLocation() para determinar a pasta raiz de um pacote de IA. Esse método retorna os seguintes valores:

Valor de retorno Status
Um objeto AiPackLocation válido A pasta raiz do pacote de IA está pronta para acesso imediato em assetsPath()
null Pacotes de IA desconhecidos ou indisponíveis

Receber informações de download sobre pacotes de IA

Use o método
getPackStates() para determinar o tamanho do download e se o pacote já está sendo transferido por download.

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

getPackStates() é um método assíncrono que retorna um Task<AiPackStates>. O método packStates() de um objeto AiPackStates retorna um Map<String, AiPackState>. Esse mapa contém o estado de cada pacote de IA solicitado, codificado pelo nome:

Map<String, AiPackState> AiPackStates#packStates()

A solicitação final é mostrada por:

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

Os métodos AiPackState abaixo fornecem o tamanho do pacote de IA, o valor transferido por download até o momento (se solicitado) e o valor já transferido ao app:

Para saber o status de um pacote de IA, use o método status(), que retorna o status como um número inteiro que corresponde a um campo de constante na classe AiPackStatus. Um pacote de IA que ainda não foi instalado tem o status AiPackStatus.NOT_INSTALLED.

Se uma solicitação falhar, use o método errorCode(), cujo valor de retorno corresponde a um campo de constante na classe AiPackErrorCode.

Instalar

Use o método fetch() para fazer o download de um pacote de IA pela primeira vez ou chame a atualização de um pacote de IA para concluir:

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

Esse método retorna um objeto AiPackStates contendo uma lista de pacotes e os estados e tamanhos iniciais de download deles. Se um pacote de IA solicitado pelo fetch() já estiver sendo feito, o status do download será retornado e nenhum download adicional será iniciado.

.

Monitorar estados de download

Implemente um AiPackStateUpdateListener para monitorar o progresso da instalação de pacotes de IA. As atualizações de status são divididas por pacote para auxiliar no monitoramento do status de pacotes de IA individuais. Você pode começar a usar os pacotes de IA disponíveis antes que todos os outros downloads da sua solicitação sejam concluídos.

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

Se o download for maior que 200 MB e o usuário não estiver conectado ao Wi-Fi, o download não será iniciado até que o usuário conceda explicitamente o consentimento para prosseguir com o download usando uma conexão de dados móveis. Da mesma forma, se o download for grande e o usuário perder a conexão ao Wi-Fi, o download será pausado e o consentimento explícito será necessário para continuar usando uma conexão de dados móveis. Um pacote pausado tem o estado WAITING_FOR_WIFI. Para acionar o fluxo da IU para solicitar o consentimento do usuário, use o método showConfirmationDialog().

Se o app não chamar esse método, o download será pausado e retomado automaticamente somente quando o usuário voltar a se conectar por Wi-Fi.

Confirmação do usuário necessária

Se um pacote tiver o status REQUIRES_USER_CONFIRMATION, o download não vai continuar até que o usuário aceite a caixa de diálogo mostrada com showConfirmationDialog(). Esse status pode ocorrer quando o app não é reconhecido pelo Google Play, por exemplo, se ele foi instalado por sideload. Chamar showConfirmationDialog() neste caso vai atualizar o app. Após a atualização, será necessário solicitar os pacotes de IA novamente.

Este é um exemplo de implementação de um listener:

AiPackStateUpdateListener aiPackStateUpdateListener = new AiPackStateUpdateListener() {
    private final ActivityResultLauncher<IntentSenderRequest> activityResultLauncher =
      registerForActivityResult(
          new ActivityResultContracts.StartIntentSenderForResult(),
          new ActivityResultCallback<ActivityResult>() {
            @Override
            public void onActivityResult(ActivityResult result) {
              if (result.getResultCode() == RESULT_OK) {
                Log.d(TAG, "Confirmation dialog has been accepted.");
              } else if (result.getResultCode() == RESULT_CANCELED) {
                Log.d(TAG, "Confirmation dialog has been denied by the user.");
              }
            }
          });

    @Override
    public void onStateUpdate(AiPackState aiPackState) {
      switch (aiPackState.status()) {
        case AiPackStatus.PENDING:
          Log.i(TAG, "Pending");
          break;

        case AiPackStatus.DOWNLOADING:
          long downloaded = aiPackState.bytesDownloaded();
          long totalSize = aiPackState.totalBytesToDownload();
          double percent = 100.0 * downloaded / totalSize;

          Log.i(TAG, "PercentDone=" + String.format("%.2f", percent));
          break;

        case AiPackStatus.TRANSFERRING:
          // 100% downloaded and assets are being transferred.
          // Notify user to wait until transfer is complete.
          break;

        case AiPackStatus.COMPLETED:
          // AI pack is ready to use. Run the model.
          break;

        case AiPackStatus.FAILED:
          // Request failed. Notify user.
          Log.e(TAG, aiPackState.errorCode());
          break;

        case AiPackStatus.CANCELED:
          // Request canceled. Notify user.
          break;

        case AiPackStatus.WAITING_FOR_WIFI:
        case AiPackStatus.REQUIRES_USER_CONFIRMATION:
          if (!confirmationDialogShown) {
            aiPackManager.showConfirmationDialog(activityResultLauncher);
            confirmationDialogShown = true;
          }
          break;

        case AiPackStatus.NOT_INSTALLED:
          // AI pack is not downloaded yet.
          break;
        case AiPackStatus.UNKNOWN:
          Log.wtf(TAG, "AI pack status unknown")
          break;
      }
    }
}

Se preferir, use o método getPackStates() para ver o status dos downloads atuais. AiPackStates contém o progresso do download, o status do download e todos os códigos de erro de falha.

Acessar pacotes de IA

É possível acessar um pacote de IA usando chamadas do sistema de arquivos depois que a solicitação de download chega ao estado COMPLETED. Use o método getPackLocation() para acessar a pasta raiz do pacote de IA.

Os pacotes de IA são armazenados no diretório assets dentro do diretório raiz do pacote de IA. Você pode acessar o caminho para o diretório assets usando o método de conveniência assetsPath(). Use o método abaixo para acessar o caminho de um 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;
}

Configurar a segmentação por dispositivo

Siga as instruções de segmentação por dispositivo para especificar os dispositivos ou grupos de dispositivos que vão receber seus pacotes de IA.

Outros métodos da API Play AI Delivery

Veja a seguir alguns métodos adicionais de API que podem ser usados no seu app.

Cancelar solicitação

Use cancel() para cancelar uma solicitação ativa de pacote de IA. Observe que essa solicitação é uma operação de melhor esforço.

Remover um pacote de IA

Use removePack() para programar a remoção de um pacote de IA.

Acessar locais de vários pacotes de IA

Use getPackLocations() para consultar o status de vários pacotes de IA em massa. Isso retorna um mapa de pacotes de IA e os locais deles. O mapa retornado por getPackLocations() contém uma entrada para cada pacote que está atualmente salvo e atualizado.

Segmentação por dispositivo

A segmentação por dispositivo oferece um controle mais preciso sobre quais partes do pacote de apps são entregues a dispositivos específicos. Por exemplo, é possível garantir que um modelo grande seja entregue apenas para dispositivos com RAM alta ou enviar diferentes versões de um modelo para dispositivos diferentes.

É possível segmentar propriedades do dispositivo, como:

Visão geral das etapas necessárias

Siga as etapas abaixo para ativar a segmentação por dispositivo:

  1. Defina os grupos de dispositivos em um arquivo XML.
  2. Especifique quais partes do pacote devem ser enviadas para quais grupos de dispositivos.
  3. [Opcional] Teste a configuração localmente.
  4. Faça upload do pacote (que contém o arquivo XML) para o Google Play.

Verificar a versão do Plug-in do Android para Gradle

Para usar a segmentação por dispositivo, verifique se a versão do Plug-in do Android para Gradle (AGP) é pelo menos 8.10.0-alpha01. Ele é empacotado com o Android Studio Meerkat 2, que está no canário.

Ativar esse recurso no Plug-in do Android para Gradle

A segmentação por dispositivo precisa ser ativada explicitamente no arquivo gradle.properties:

android.experimental.enableDeviceTargetingConfigApi=true

Criar um arquivo XML de configuração de segmentação por dispositivo

O arquivo de configuração de segmentação por dispositivo é um arquivo XML em que você define seus grupos de dispositivos personalizados. Por exemplo, você pode definir um grupo de dispositivos chamado qti_v79 que contém todos os dispositivos com o sistema on-chip Qualcomm SM8750:

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

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

</config:device-targeting-config>

Um grupo de dispositivos é composto por até cinco seletores de dispositivo. Um dispositivo é incluído em um grupo se ele atende a qualquer um dos seletores.

Um seletor de dispositivo pode ter uma ou mais propriedades de dispositivo. Um dispositivo é selecionado se corresponder a todas as propriedades do dispositivo do seletor.

Se um dispositivo corresponder a vários grupos, será enviado o conteúdo do grupo definido primeiro no arquivo XML. A ordem em que você define grupos no arquivo XML é a ordem de prioridade.

Se um dispositivo não corresponder a nenhum grupo, ele vai receber o grupo padrão "Outros". Esse grupo é gerado automaticamente e não precisa ser definido explicitamente.

Propriedades do dispositivo disponíveis

  • device_ram: requisitos de RAM do dispositivo
    • min_bytes (inclusivo): mínimo de RAM necessária (em bytes).
    • max_bytes (exclusivo): máximo de RAM necessária (em bytes).
  • included_device_ids: os modelos de dispositivo que serão incluídos nesse seletor (máximo de 10.000 device_ids por grupo). Essa propriedade é atendida se o dispositivo corresponder a qualquer device_id na lista.
    • build_brand: fabricante do dispositivo.
    • build_device: código do modelo do dispositivo.
  • excluded_device_ids: modelos de dispositivo a serem excluídos neste seletor (máximo de 10.000 device_ids por grupo). Essa propriedade é atendida se o dispositivo não corresponder a nenhum device_id na lista.
    • build_brand: fabricante do dispositivo.
    • build_device: código do modelo do dispositivo.

  • required_system_features: recursos que um dispositivo precisa ter para ser incluído por esse seletor (máximo de 100 recursos por grupo). Um dispositivo precisa ter todos os recursos do sistema nessa lista para atender a essa propriedade.

    Referência de recursos do sistema

    • name: um recurso do sistema.

  • forbidden_system_features: recursos que um dispositivo não pode ter para ser incluído por esse seletor (máximo de 100 recursos por grupo). Se um dispositivo tiver algum dos recursos do sistema nesta lista, ele não atenderá a essa propriedade.

    Referência de recursos do sistema

    • name: um recurso do sistema.

  • system-on-chip: system on chips a serem incluídos neste seletor. Um dispositivo precisa ter qualquer chip dessa lista para atender a essa propriedade.

Confira um exemplo que mostra todas as propriedades possíveis do 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 oficiais do fabricante e do modelo do dispositivo

Para encontrar a formatação correta do fabricante do dispositivo e o código do modelo, use o catálogo de dispositivos no Google Play Console de uma das seguintes maneiras:

  • Inspeção dos dispositivos individuais usando o catálogo de dispositivos e encontrando o código do fabricante e do modelo nos locais, conforme mostrado no exemplo abaixo. No caso de um Google Pixel 4a, o fabricante é "Google" e o código do modelo é "sunfish".

    Página do Pixel 4a no catálogo de dispositivos

    Página do Pixel 4a no catálogo de dispositivos

  • Faça o download de um CSV dos dispositivos com suporte e use o código do fabricante e do modelo para os campos build_brand e build_device, respectivamente.

Incluir o arquivo de configuração de segmentação por dispositivo no pacote do app

Adicione o seguinte ao arquivo build.gradle do 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 é o caminho do arquivo de configuração em relação ao módulo principal. Isso garante que o arquivo de configuração seja empacotado com o pacote de apps.

A cláusula deviceGroup garante que os APKs gerados no pacote sejam divididos por grupos de dispositivos.

Usar a segmentação por dispositivo nos seus pacotes de IA

Para manter o tamanho otimizado nos dispositivos, envie apenas os modelos grandes para dispositivos que podem executá-los.

Divida seus pacotes de IA por grupos de dispositivos usando os diretórios de pacotes de IA existentes criados na última etapa e postfixando as pastas adequadas (conforme descrito abaixo) com #group_myCustomGroup1, #group_myCustomGroup2 etc. Ao usar os pacotes de IA no seu app, não será necessário endereçar pastas por postfixo. Em outras palavras, o postfixo é removido automaticamente durante o processo de build.

Após a etapa anterior, a aparência do código será esta:

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

Neste exemplo, você referenciaria ai-pack-name/assets/image-classifier/ sem sufixos.

Os dispositivos em myCustomGroup1 vão receber todos os recursos em image-classifier#group_myCustomGroup1/, enquanto os dispositivos em myCustomGroup2 vão receber todos os recursos em image-classifier#group_myCustomGroup2/.

Os dispositivos que não pertencem a myCustomGroup1 ou myCustomGroup2 vão receber um pacote ai-pack-name vazio.

Isso acontece porque os dispositivos que não correspondem a nenhum grupo recebem a variante padrão do pacote de IA. Isso inclui tudo o que não está em um diretório com um #group_suffix.

Depois de fazer o download do pacote de IA, você pode verificar se o modelo está presente usando o AssetManager para pacotes de instalação ou o AiPackManager para pacotes de acompanhamento rápido e sob demanda. Exemplos para fazer isso são mostrados para todos os modos de entrega no app de exemplo.

Usar a segmentação por dispositivo nos módulos de recursos

Também é possível usar a segmentação por dispositivo para módulos de recursos. Em vez de subdividir módulos de recursos por grupo de dispositivos, especifique se o módulo inteiro precisa ser enviado com base na associação ao grupo de dispositivos.

Para enviar um módulo de recurso a dispositivos que pertencem a myCustomGroup1 ou myCustomGroup2, modifique o 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>

Testar localmente

Antes de criar uma versão para o novo pacote, você pode testar localmente com o Compartilhamento interno de apps ou o Bundletool.

Compartilhamento interno de apps

O Compartilhamento interno de apps permite usar um pacote de apps para gerar rapidamente um URL que pode ser tocado em um dispositivo local para instalar exatamente o que o Google Play instalaria para esse dispositivo se essa versão do app estivesse ativa em uma faixa de teste ou de produção.

Confira as instruções sobre o compartilhamento interno de apps.

Bundletool

Como alternativa, é possível gerar APKs usando o bundletool (1.18.0 ou mais recente) e fazer o sideload deles no dispositivo. Siga estas etapas para testar o app localmente usando o bundletool:

  1. Crie o pacote de apps com o Android Studio ou o bundletool.

  2. Gere APKs com a sinalização --local-testing:

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

  3. Conecte um dispositivo e execute bundletool para transferir os APKs por sideload:

    # 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

Limitações dos testes locais com o bundletool

Confira a seguir as limitações dos testes locais com o bundletool:

  • Os pacotes fast-follow se comportam como pacotes on-demand. Ou seja, eles não serão buscados automaticamente quando o app for transferido por sideload. Os desenvolvedores precisam solicitá-los manualmente quando o app for iniciado. Isso não exige nenhuma mudança no código do app.
  • Os pacotes são buscados do armazenamento externo em vez do Play. Por isso, não é possível testar como o código se comporta em caso de erros de rede.
  • Os testes locais não abrangem o cenário "Aguardando Wi-Fi".
  • Atualizações não são compatíveis. Antes de instalar uma nova versão do seu build, desinstale manualmente a versão anterior.

Verificar se os APKs corretos estão sendo instalados

Use o método a seguir para garantir que apenas os APKs corretos sejam instalados no dispositivo

adb shell pm path {packageName}

Você verá um código como este:

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

Nesta lista, você só vai encontrar APKs feitos de módulos de recursos e pacotes de IA ativados no momento da instalação. Os pacotes de IA sob demanda e de acompanhamento rápido não são instalados como APKs.

Testar e lançar no Google Play

Recomendamos que você teste seu app do início ao fim no Google Play com uma faixa de teste interno.

Depois disso, você pode lançar a atualização do app de forma incremental para a produção com lançamentos graduais.

Exemplo de app que usa o Google Play para IA no dispositivo

Entre em contato com seu gerente de parcerias do Google Play para ter acesso ao app de exemplo.

Ele demonstra como usar cada um dos modos de entrega, bem como a configuração de segmentação por dispositivo. Consulte a seção Testes locais para começar.

Enviar feedback

Os participantes do programa de acesso antecipado precisam informar problemas e enviar feedback. Entre em contato com seu gerente de parcerias do Google Play ou com a equipe de IA no dispositivo do Google Play.

Conteúdo relacionado

Saiba mais sobre os Android App Bundles e leia as referências do SDK de entrega de IA.