Play para IA no dispositivo (Beta)

Introdução

O Play para IA no dispositivo traz os benefícios dos Android App Bundles e da entrega do Google Play para a distribuição personalizada de modelos de ML. Assim, você pode melhorar o desempenho do modelo com menos complexidade no ecossistema de dispositivos sem custo financeiro adicional. Ele permite publicar um único artefato no Google Play contendo seu código, recursos e modelos de ML, além de escolher 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 hospedagem, entrega, atualizações e segmentação ao Play sem custo financeiro adicional.
  • Entregue seus modelos de ML no momento da instalação, com exibição rápida ou on demand.
    • A entrega no momento da instalação garante que um modelo muito grande esteja presente quando o app é aberto. Seu modelo será instalado como um APK.
    • O envio rápido após a instalação acontece automaticamente em segundo plano depois que o app é instalado. Os usuários podem abrir o app antes que o modelo seja totalmente baixado. O modelo será baixado para o espaço de armazenamento interno do app.
    • Com a entrega sob demanda, você pode solicitar o modelo no tempo de execução, o que é útil se ele for necessário apenas para determinados fluxos de usuários. O modelo será baixado para o espaço de armazenamento interno do app.
  • Entregue variantes dos seus modelos de ML segmentadas para dispositivos específicos com base no modelo, nas propriedades do sistema ou na RAM.
  • Mantenha as atualizações de apps pequenas e otimizadas com a inclusã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 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, com acompanhamento rápido ou on demand.

Ao empacotar pacotes de IA com o pacote de apps, 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 correção automática do Google Play vai garantir que o usuário não precise fazer o download novamente. O Google Play só baixa o que mudou quando atualiza o app.

Os pacotes de IA contêm apenas modelos. Não são permitidas bibliotecas nativas e Java/Kotlin. Se você precisar enviar bibliotecas ou código para executar seu 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 seu 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

De maneira geral, veja como começar a usar o Google 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, você pode entregar 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 não receber nenhum modelo.
  3. [Opcional] Se você estiver usando a entrega sob demanda ou rápida, integre a biblioteca Play AI Delivery ao seu 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. Essa versão vem com o Android Studio Ladybug 2.

Extrair o modelo para 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 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 o código para carregar e executar seus modelos. A maneira de fazer isso depende do modo de entrega dos seus pacotes de IA. Confira as instruções para install-time e fast-follow/on-demand 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 "no momento da instalação" ficam disponíveis imediatamente na inicialização do app. Use a API Java AssetManager para acessar pacotes de IA veiculados nesse 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 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, 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 ainda não 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 baixado, o status do download será retornado e nenhum outro download 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 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 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 transferido por sideload. Chamar showConfirmationDialog() neste 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. 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 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

Com a segmentação por dispositivo, você tem mais controle 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 a dispositivos com RAM alta ou entregar versões diferentes de um modelo a dispositivos diferentes.

É possível segmentar propriedades de dispositivos, como:

Visão geral das etapas necessárias

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

  1. Defina seus grupos de dispositivos em um arquivo XML.
  2. Especifique quais partes do pacote devem ir para quais grupos de dispositivos.
  3. [Opcional] Teste sua 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 é incluído no Android Studio (Meerkat 2 e versões mais recentes). Faça o download da 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, você pode definir um grupo de dispositivos chamado qti_v79 que contenha todos os dispositivos com o sistema Qualcomm SM8750 em um chip:

<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 satisfizer 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 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: modelos de dispositivo a serem incluídos neste seletor (máximo de 10.000 device_ids por grupo). Essa propriedade é satisfeita 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 é satisfeita 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 satisfazer 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 nessa lista, ele não vai satisfazer 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 nesta lista para satisfazer 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 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 apps

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 relativo ao módulo principal. Isso garante que o arquivo de configuração seja empacotado com o pacote do app.

A cláusula deviceGroup garante que os APKs gerados no seu 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 seus modelos grandes apenas para dispositivos que podem 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 adicionando o sufixo às pastas apropriadas (conforme descrito abaixo) com #group_myCustomGroup1, #group_myCustomGroup2 etc. Ao usar os pacotes de IA no seu app, não é necessário adicionar o sufixo às pastas. Em outras palavras, o sufixo é 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ê faria referência a 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á dentro de 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 instalação ou o AiPackManager para pacotes de acompanhamento rápido e sob demanda. Exemplos de como fazer isso são mostrados para todos os modos de exibição 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 módulos de recursos por grupo de dispositivos, você especifica se o módulo inteiro deve ser entregue 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 dele:

<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 um lançamento para o novo pacote, é possível testar localmente 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 para esse dispositivo se a 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, gere APKs usando bundletool (1.18.0 ou mais recente) e faça sideload no seu dispositivo. Siga estas etapas para testar o app localmente usando 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 a 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 é 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

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

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

App de exemplo usando o Google Play para IA no dispositivo

Faça o download do app de exemplo.

Ele demonstra como usar cada um dos modos de veiculação e a configuração de segmentação por dispositivo. Consulte a seção 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.