Play para IA no dispositivo (Beta)

Introdução

O Play para IA no dispositivo traz os benefícios dos Android App Bundles e da distribuição do Google Play para a distribuição de modelos de ML personalizados. Assim, você pode melhorar o desempenho do modelo com menos complexidade do ecossistema de dispositivos sem custo financeiro adicional. 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, a entrega, as atualizações e a segmentação ao Play sem custo financeiro adicional.
  • Disponibilize seus modelos de ML no momento da instalação, de forma rápida ou sob demanda.
    • 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.
    • A entrega rápida ocorre automaticamente em segundo plano após a instalação do app. Os usuários podem abrir o app antes que o modelo seja totalmente baixado. O modelo será transferido por download para o espaço de armazenamento interno do app.
    • A entrega sob demanda permite solicitar o modelo no momento da execução, o que é útil se o modelo for necessário apenas para determinados fluxos do usuário. O modelo será salvo no espaço de armazenamento interno do app.
  • Ofereça variantes dos seus modelos de ML direcionadas a 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 a aplicação automática de patches do Google Play, o que significa que apenas as diferenças nos arquivos precisam ser baixadas.

Considerações

Como usar o Google Play para IA no dispositivo

O Google Play para IA no dispositivo usa pacotes de IA. Você empacota modelos personalizados que estão prontos para distribuição em pacotes de IA no seu pacote de app. Você pode escolher se o pacote de IA será entregue no momento da instalação, por acompanhamento rápido ou sob demanda.

Ao empacotar pacotes de IA com seu pacote de app, você pode usar todas as ferramentas de teste e lançamento do Google Play, como faixas de teste e lançamentos graduais, 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 mudanças em um pacote de IA, o processo de patch automático do Google Play vai garantir que o usuário não precise fazer o download novamente. O Google Play só vai baixar o que mudou quando atualizar o app.

Os pacotes de IA contêm apenas modelos. Não é permitido usar Java/Kotlin e bibliotecas nativas. Se você precisar enviar bibliotecas ou código para executar o modelo de ML, mova-os 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 do 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 o modelo em um pacote de IA e acesse-o usando as instruções para pacotes de tempo de instalação ou para pacotes de acompanhamento rápido e sob demanda.

Leia mais:

Começar a usar os pacotes de IA

Confira como começar a usar o Play para IA no dispositivo:

  1. Empacote seus modelos em pacotes de IA no Android App Bundle e especifique como eles devem ser entregues.
  2. [Opcional] Se você quiser disponibilizar modelos diferentes para dispositivos diferentes, configure a segmentação por dispositivo para seus pacotes de IA. Por exemplo, é possível 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 não receberiam nenhum modelo.
  3. [Opcional] Se você estiver usando a entrega sob demanda ou rápida, integre a biblioteca Play AI Delivery ao app para baixar os pacotes de IA conforme necessário.
  4. Teste e lance seu pacote de apps no Google Play.

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

Para usar os pacotes de IA, verifique se a versão do Plug-in do Android para Gradle (AGP) é pelo menos 8.8. Esta versão é fornecida 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. O nome do diretório é usado como nome do pacote de IA. Os nomes dos 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 os 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. Veja abaixo as instruções para install-time e fast-follow/on-demand.

  8. [Opcional] Configure a segmentação por dispositivo para disponibilizar modelos diferentes para 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 install-time ficam disponíveis imediatamente após a inicialização do app. Use a API AssetManager do Java para acessar os pacotes de IA disponibilizados 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 baixar pacotes de IA com entrega rápida ou sob demanda, use a biblioteca Play AI Delivery.

Declarar dependência da biblioteca Play AI Delivery

No arquivo build.gradle do app, declare uma dependência da 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 Pacote de IA desconhecido ou indisponível

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, identificado 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 baixar 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 download de pacote de IA solicitado pelo método fetch() já estiver sendo feito, o status do download é retornado e nenhum outro download vai ser iniciado.

.

Monitorar estados de download

Implemente um AiPackStateUpdateListener para acompanhar o progresso da instalação dos pacotes de IA. As atualizações de status são divididas por pacote para auxiliar no monitoramento do status de pacotes de IA individuais. É possível 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 vai 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 a uma conexão Wi-Fi.

Confirmação do usuário necessária

Se um pacote tiver o status REQUIRES_USER_CONFIRMATION, o download não vai prosseguir 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 transferido por sideload. Chamar showConfirmationDialog() nesse caso vai fazer com que o app seja atualizado. Depois da atualização, você vai precisar 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 após a solicitação de download chegar 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. É possível 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 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 foi baixado e está atualizado.

Segmentação por dispositivo

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

É possível segmentar propriedades do dispositivo de destino, como:

Visão geral das etapas necessárias

Siga estas etapas 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. Ele é empacotado com o Android Studio (Meerkat 2 e versões mais recentes). Baixe a versão estável mais recente do Android Studio.

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, é possível definir um grupo de dispositivos chamado qti_v79 que contenha todos os dispositivos com o system 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é 5 seletores de dispositivos. Um dispositivo será incluído em um grupo de dispositivos se atender a qualquer um dos seletores.

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

Se um dispositivo corresponder a vários grupos, será enviado o conteúdo para o grupo definido primeiro no arquivo XML. A ordem em que você define os 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 deve 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 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 será 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 recurso do sistema nessa lista, ele não vai 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 nessa lista para atender a essa propriedade.

Veja 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 de fabricante e 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

  • Download de um CSV dos dispositivos com suporte e uso do 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 de 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 do seu pacote sejam divididos por grupos de dispositivos.

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

Para otimizar o tamanho nos dispositivos, envie os modelos grandes apenas para dispositivos que possam executá-los.

Subdivida seus pacotes de IA por grupos de dispositivos usando os diretórios de pacotes de IA existentes criados na última etapa e pós-fixando as pastas apropriadas (conforme descrito abaixo) com #group_myCustomGroup1, #group_myCustomGroup2 etc. Ao usar os pacotes de IA no app, não será necessário endereçar pastas por pós-fixo. Em outras palavras, o pós-fixo é 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ê usaria 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 ocorre porque os dispositivos que não correspondem a nenhum grupo de dispositivos receberão 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 baixar o pacote de IA, verifique se o modelo está presente usando o AssetManager para pacotes de momento da instalação ou o AiPackManager para pacotes de exibição rápida e on demand. Exemplos de como fazer isso são mostrados para todos os modos de entrega no app de exemplo.

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

Também é possível usar a segmentação por dispositivo para módulos de recursos. Em vez de subdividir os módulos de recurso 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, faça testes locais com o Compartilhamento interno de apps ou o Bundletool.

Compartilhamento interno de apps

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

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

Bundletool

Como alternativa, é possível gerar APKs usando 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 seu 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

Veja 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á-las manualmente quando o app é iniciado. Isso não exige mudanças no código do app.
  • Os pacotes são buscados no armazenamento externo, e não no Google Play. Portanto, não é possível testar como seu 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 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

Nessa lista, você só vai encontrar APKs criados com base em módulos de recursos e pacotes de IA de 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 de ponta a ponta no Google Play com uma faixa de teste interno.

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

App de exemplo que usa o Google Play para IA no dispositivo

Baixe o 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 de testes locais para começar.

Conteúdo relacionado

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