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 de modelos de ML personalizados. 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 com seu código, recursos e modelos de ML e 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 a hospedagem, o envio, 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 transferido por download. O modelo será salvo no espaço de armazenamento interno do app.
- A entrega on demand permite solicitar o modelo no tempo de 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 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 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
- Ao usar o Play para IA no dispositivo, você concorda com os termos do Contrato de distribuição para desenvolvedores do Google Play e com os Termos de Serviço do kit de desenvolvimento de software da Play Core.
- Os modelos baixados pelo Google Play para IA no dispositivo só podem ser usados pelos seus apps. Os modelos não podem ser oferecidos a outros apps.
- 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 com base no 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.
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 são permitidas bibliotecas Java, Kotlin e 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 download automático e on demand.
Leia mais:
- Como começar a usar o LiteRT
- O app de exemplo mostra como empacotar um modelo do LiteRT em um pacote de IA e carregá-lo no momento da execução.
- Há muitos modelos pré-treinados do LiteRT que podem ser usados em pacotes de IA para começar.
- Como começar a usar o MediaPipe
- Para pacotes de entrega rápida e on demand, use AssetCache.java
para carregar os recursos (por exemplo,
.binarypb) pelos caminhos de arquivo. - Para pacotes de instalação, use AndroidAssetUtil.java.
- Para pacotes de entrega rápida e on demand, use AssetCache.java
para carregar os recursos (por exemplo,
Começar a usar os pacotes de IA
Confira como começar a usar o Google Play para IA no dispositivo:
- Empacote seus modelos em pacotes de IA no Android App Bundle e especifique como eles precisam ser entregues.
- [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.
- [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.
- 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 para um pacote de IA
O Android Studio não é necessário para as etapas a seguir.
- 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.
No diretório do pacote de IA, crie um arquivo
build.gradlee 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 ]" } }No arquivo
build.gradledo 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"] }No arquivo
settings.gradledo 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'No pacote de IA, crie um diretório
src/main/assets/.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.gradlesettings.gradleapp/ai-pack-name/build.gradleai-pack-name/src/main/assets/your-model-directories
Adicione código para carregar e executar seus modelos. A maneira de fazer isso depende do modo de entrega dos pacotes de IA. Veja as instruções para install-time e fast-follow/on-demand abaixo.
[Opcional] Configure a segmentação por dispositivo para disponibilizar modelos diferentes para dispositivos diferentes.
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 na 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 automática ou on demand, use a biblioteca Play AI Delivery.
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 |
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 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 usando
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 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 interface e 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
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.
Após a 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; } } }
Como alternativa, use o método getPackStates() para conferir o status
dos downloads atuais. AiPackStates contém o progresso do download,
o status do download e os códigos do 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
encontrar 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.
Para acessar o caminho para o diretório assets, use 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. 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,
o que 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 para dispositivos específicos. Por exemplo, é possível garantir que um modelo grande seja entregue apenas a dispositivos com muita RAM ou entregar versões diferentes de um modelo para dispositivos diferentes.
É possível segmentar propriedades do dispositivo de destino, como:
- System on chip
- Modelo do dispositivo
- RAM do dispositivo
- Recursos do sistema
Visão geral das etapas necessárias
Siga estas etapas para ativar a segmentação por dispositivo:
- Defina os grupos de dispositivos em um arquivo XML.
- Especifique quais partes do pacote devem ser enviadas para quais grupos de dispositivos.
- [Opcional] Teste a configuração localmente.
- 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). 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, é possível definir um grupo de dispositivos chamado
qti_v79 que contém 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 será 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 dessa lista para atender a essa propriedade.
- manufacturer: fabricante do system on chip
- model: modelo do system on chip
Combinar propriedades do seletor com AND e OR
Por exemplo, o seletor a seguir cria a condição para todos os dispositivos com mais de 7 GB de RAM e que são um Pixel 4:
<config:device-selector ram-min-bytes="7000000000">
<config:included-device-id brand="google" device="flame"/>
</config:device-selector>
Essa condição também é escrita da seguinte forma:
Se você quiser uma condição OR, crie seletores separados em um único grupo de dispositivos. Por exemplo, os seletores a seguir criam a condição para todos os dispositivos com mais de 7 GB de RAM ou que são um Pixel 4:
<config:device-selector ram-min-bytes="7000000000"/>
<config:device-selector>
<config:included-device-id brand="google" device="flame"/>
</config:device-selector>
Essa condição também é escrita da seguinte forma:
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".


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 no 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 vão receber 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, use o AssetManager para verificar se o modelo está presente em 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, você pode 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:
Crie seu pacote de apps com o Android Studio ou o bundletool.
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
Conecte um dispositivo e execute
bundletoolpara 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-followse comportam como pacoteson-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 em vez do 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 on-demand e fast-follow 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ê poderá 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.