bundletool
é a ferramenta que o Android Studio, o Plug-in
do Android para
Gradle e o Google Play usam para criar um Android App Bundle. bundletool
pode converter um pacote de app para vários APKs que serão implantados em dispositivos.
Os Android SDK Bundles (ASBs) e os APKs deles são criados com a bundletool
. Ela também
está disponível como uma ferramenta de linha de comando para que você possa criar pacotes de apps e
SDKs e recriar o build do lado do servidor do Google Play para APKs
do seu app ou
do SDK ativado no momento da execução.
Fazer o download de bundletool
Faça o download do bundletool
no
repositório do GitHub, caso ainda não tenha feito.
Criar e testar um pacote de app
Você pode usar o Android Studio ou a ferramenta de linha de comando bundletool
para criar seu
Android App Bundle e testar os APKs gerados por esse pacote de app.
Criar um pacote de app
Use o Android Studio e o Plug-in do Android para Gradle para
criar e assinar um Android App Bundle.
No entanto, se não for possível usar o ambiente de desenvolvimento integrado porque você está usando um servidor
de build contínuo, por exemplo, também é possível
criar seu pacote de app na linha de comando
e assiná-lo usando
jarsigner
.
Para saber mais sobre a criação de pacotes de app com a bundletool
,
consulte Criar um pacote de app usando a bundletool.
Gerar um conjunto de APKs no seu pacote de app
Depois de criar o Android App Bundle, é importante testar como ele é usado pelo Google Play para gerar APKs e como esses APKs se comportam quando são implantados em um dispositivo.
Há duas maneiras de testar o pacote de app:
- Use a ferramenta de linha de comando
bundletool
localmente. - Faça upload do seu pacote no Play Console usando o Google Play com uma faixa de teste.
Esta seção explica como usar a bundletool
para testar seu
pacote de app localmente.
Quando a bundletool
gera APKs no pacote de app, ela inclui os
APKs gerados em um contêiner chamado arquivo de conjunto de APKs, que usa a extensão
de arquivo .apks
. Para gerar um conjunto de APKs para todas as configurações de dispositivo com suporte
usando seu pacote de app, aplique o comando bundletool build-apks
, como
mostrado abaixo.
bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Se você quiser implantar os APKs em um dispositivo, inclua também as informações de assinatura
do app, como mostrado no comando a seguir. Se você não especificar
informações de assinatura, a bundletool
vai tentar assinar seus APKs com uma chave de
depuração.
bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks --ks=/MyApp/keystore.jks --ks-pass=file:/MyApp/keystore.pwd --ks-key-alias=MyKeyAlias --key-pass=file:/MyApp/key.pwd
A tabela a seguir descreve em mais detalhes as diversas flags e opções que
você pode usar com o comando bundletool build-apks
:
Flag | Descrição |
---|---|
--bundle=path |
(Obrigatória) Especifica o caminho para o pacote de apps criado usando o Android Studio. Para saber mais, leia Criar seu projeto. |
--output=path |
(Obrigatória) Especifica o nome do arquivo
.apks de saída, que contém todos os artefatos do APK para seu
app. Para testar os artefatos desse arquivo em um dispositivo, siga as etapas da
seção sobre como implantar APKs
em um dispositivo conectado.
|
--overwrite |
Substitui qualquer arquivo de saída existente pelo
caminho especificado usando a opção --output . Se você
não incluir essa flag e o arquivo de saída já existir, haverá um
erro de build.
|
--aapt2=path |
Especifica um caminho personalizado para o AAPT2.
Por padrão, o bundletool inclui a própria versão do AAPT2.
|
--ks=path |
(Opcional) Especifica o caminho para o keystore de implantação usado para
assinar os APKs. Se você não incluir essa flag,
a bundletool vai tentar assinar seus APKs com uma chave de assinatura de
depuração.
|
--ks-pass=pass:password ou --ks-pass=file:/path/to/file |
Especifica a senha do keystore. Se você
especificar uma senha em texto simples, qualifique-a com pass: .
Se você transmitir o caminho para um arquivo que contém a senha, qualifique-o
com file: . Se você especificar um keystore usando
a flag --ks sem especificar --ks-pass ,
o bundletool solicitará uma senha na linha de comando.
|
--ks-key-alias=alias |
Especifica o alias da chave de assinatura que você quer usar. |
--key-pass=pass:password ou --key-pass=file:/path/to/file |
Especifica a senha da chave de assinatura. Se você
especificar uma senha em texto simples, qualifique-a com pass: .
Se você transmitir o caminho para um arquivo que contém a senha, qualifique-o
com file: . Se essa senha é idêntica à senha do keystore, você pode omitir a flag. |
--connected-device |
Instrui o bundletool a criar APKs voltados à
configuração de um dispositivo conectado. Se você não incluir essa sinalização,
a bundletool vai gerar APKs para todas as configurações de dispositivos com suporte para seu
app.
|
--device-id=serial-number |
Se você tiver mais de um dispositivo conectado, use essa flag para especificar o ID serial do dispositivo em que você quer implantar o app. |
--device-spec=spec_json |
Fornece um caminho para um
arquivo .json que especifica a configuração do dispositivo
de destino. Para saber mais, acesse a seção sobre como
Gerar e usar arquivos JSON de especificação de
dispositivo.
|
--mode=universal |
Define o modo como universal . Use essa opção se quiser que
bundletool crie um único APK que inclua todo o código
e os recursos do seu app para que ele seja compatível com todas as
configurações de dispositivos a que o app oferece suporte.
Observação: a Lembre-se de que esses APKs são maiores que os otimizados para uma configuração de dispositivo específica. No entanto, eles são mais fáceis de compartilhar com testadores internos que, por exemplo, querem testar seu app em diversas configurações de dispositivos. |
--local-testing
|
Permite que seu pacote de app faça testes locais.
Os testes locais permitem ciclos de teste rápidos e iterativos, sem a necessidade
de fazer upload em servidores do Google Play.
Para ver um exemplo de como testar a instalação do módulo usando a
flag |
Implantar APKs em um dispositivo conectado
Depois de gerar um conjunto de APKs, a bundletool
pode implantar a combinação certa
de APKs desse conjunto em um dispositivo conectado.
Por exemplo, se você tiver um dispositivo conectado com o Android 5.0 (nível 21 da API)
ou mais recente, a bundletool
transmite o APK base, os APKs do módulo de recursos e
os APKs de configuração necessários para executar seu app nesse dispositivo. Como alternativa, se
o dispositivo conectado estiver executando o Android 4.4 (API de nível 20) ou anterior,
a bundletool
vai procurar um multi-APK compatível para implantar no dispositivo.
Para implantar o app com um conjunto de APKs, use o comando install-apks
e especifique
o caminho do conjunto usando a
flag --apks=/path/to/apks
, conforme
mostrado no comando a seguir. Se houver vários dispositivos conectados,
especifique o dispositivo de destino adicionando a
flag --device-id=serial-id
.
bundletool install-apks --apks=/MyApp/my_app.apks
Gerar um conjunto de APKs específico para o dispositivo
Se você não quiser criar um conjunto de APKs para todas as configurações de dispositivos com suporte no
app, crie APKs voltados apenas para a configuração de um dispositivo
conectado usando a opção --connected-device
, como mostrado no comando a seguir.
Se houver vários dispositivos conectados, especifique o dispositivo incluindo a
flag --device-id=serial-id
.
bundletool build-apks --connected-device --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Gerar e usar arquivos JSON de especificação de dispositivo
A bundletool
pode gerar um conjunto de APKs voltado a uma configuração
de dispositivo especificada por um arquivo JSON. Para gerar primeiro um arquivo JSON para um
dispositivo conectado, execute este comando:
bundletool get-device-spec --output=/tmp/device-spec.json
A bundletool
cria um arquivo JSON para seu dispositivo no diretório da ferramenta. Em seguida, você
pode transmiti-lo à bundletool
para gerar um conjunto de APKs
voltados apenas à configuração descrita nesse arquivo JSON, da seguinte forma:
bundletool build-apks --device-spec=/MyApp/pixel2.json --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
Criar manualmente um JSON de especificação de dispositivo
Se você não tem acesso ao dispositivo para que quer criar um conjunto de APKs direcionado (por exemplo, um amigo quer testar seu app com um dispositivo que você não tem disponível), crie um arquivo JSON manualmente usando este formato:
{
"supportedAbis": ["arm64-v8a", "armeabi-v7a"],
"supportedLocales": ["en", "fr"],
"screenDensity": 640,
"sdkVersion": 27
}
Em seguida, você pode transmitir esse JSON ao comando bundle extract-apks
, conforme descrito
na seção anterior.
Extrair APKs específicos do dispositivo de um conjunto de APKs já existente
Se você já tiver um conjunto de APKs e quiser extrair dele um subconjunto de APKs
que segmentam uma configuração do dispositivo específico, use o comando extract-apks
e defina um JSON de especificação de dispositivo, conforme mostrado a seguir.
bundletool extract-apks --apks=/MyApp/my_existing_APK_set.apks --output-dir=/MyApp/my_pixel2_APK_set.apks --device-spec=/MyApp/bundletool/pixel2.json
Medir os tamanhos estimados de download de APKs em um conjunto
Para medir os tamanhos estimados de download de APKs em um conjunto, considerando uma
distribuição compactada para transmissão via cabo, use o comando get-size total
:
bundletool get-size total --apks=/MyApp/my_app.apks
Modifique o comportamento do comando get-size total
usando as
seguintes flags:
Flag | Descrição |
---|---|
--apks=path |
(Obrigatória) Especifica o caminho para o arquivo do conjunto de APKs já existente com um tamanho de download em processo de medição. |
--device-spec=path |
Especifica o caminho para o arquivo de especificação do dispositivo (com base
em get-device-spec ou construído manualmente) para uso em correspondência.
Você pode especificar um caminho parcial para avaliar um conjunto de configurações.
|
--dimensions=dimensions
| Especifica as dimensões usadas ao calcular as estimativas de tamanho. Aceita
uma lista separada por vírgulas de SDK , ABI ,
SCREEN_DENSITY e LANGUAGE . Para medir em
todas as dimensões, especifique ALL .
|
--instant |
Mede o tamanho de download dos APKs instantâneos, em vez dos
APKs instaláveis. Por padrão, a bundletool mede os
tamanhos de download de APKs instaláveis.
|
--modules=modules |
Especifica uma lista de módulos separados por vírgulas no conjunto de APKs a ser considerado
na medição. O comando bundletool inclui automaticamente
todos os módulos dependentes para o conjunto especificado. Por padrão, o
comando mede o tamanho do download de todos os módulos instalados durante o
primeiro download.
|
Criar um pacote de app com uma dependência do pacote de SDKs (experimental)
Você pode criar seu Android App Bundle com uma dependência do Android SDK Bundle (ASB) na linha de comando e assiná-lo usando o jarsigner.
Cada módulo de pacote de app inclui um arquivo de buffer de protocolo do módulo (.pb
):
runtime_enabled_sdk_config.pb
. Esse arquivo contém a lista de SDKs
de que um módulo de pacote de app depende. Para a definição completa desse arquivo,
consulte o arquivo
runtime_enabled_sdk_config.proto
.
Para criar um pacote de app com uma dependência do pacote de SDKs, siga as etapas da seção sobre
como criar um pacote de app usando a bundletool e adicione um
arquivo runtime_enabled_sdk_config.pb
ao ZIP de cada módulo do app
com código e recursos compilados.
Alguns campos importantes no arquivo runtime_enabled_sdk_config.pb
:
Síntese do certificado: uma síntese do certificado SHA-256 da chave usada para assinar os APKs do SDK. Corresponde ao certificado no arquivo
SdkMetadata.pb
no formato Android SDK Archive.ID do pacote de recursos: o ID do pacote em que todos os recursos do SDK são remapeados ao gerar APKs para incorporar o SDK no app. Isso possibilita a compatibilidade com versões anteriores.
Um SDK pode aparecer apenas em um módulo. Se vários módulos dependerem do mesmo SDK, a duplicação vai ser eliminada e movida para o módulo base. Diferentes módulos não podem depender de diferentes versões do SDK.
Gerar APKs de um pacote de app com uma dependência do pacote de SDKs (experimental)
Para gerar APKs do seu pacote de app, siga as etapas na seção sobre
como gerar um conjunto de APKs no pacote de app
ou
como gerar um dispositivo específico de APKs
e forneça o comando bundletool build-apks
com os SDKs de que
o app depende. Esses SDKs podem ser fornecidos no formato de pacote do SDK ou do
SDK Archive.
Você pode fornecer os SDKs como pacotes ao adicionar a sinalização --sdk-bundles
da
seguinte maneira:
bundletool build-apks --bundle=app.aab --sdk-bundles=sdk1.asb,sdk2.asb \ --output=app.apks
É possível fornecer os SDKs como arquivos SDK ao adicionar a sinalização --sdk-archives
da seguinte maneira:
bundletool build-apks --bundle=app.aab --sdk-archives=sdk1.asar,sdk2.asar \ --output=app.apks
Gerar APKs de um pacote de app com uma dependência do pacote de SDKs para dispositivos sem suporte à biblioteca de SDKs
Dispositivos anteriores ao Android 13 não oferecem suporte à instalação nem execução de bibliotecas do SDK
no SDK Runtime. O Bundletool esconde a complexidade da compatibilidade com versões anteriores
gera diversas variantes do seu conjunto de APKs para o mesmo pacote de app quando você
execute bundletool build-apks
com a opção --sdk-bundles
ou --sdk-archives
.
As diversas variantes segmentam dispositivos com recursos diferentes:
- Há uma variante para dispositivos mais recentes, em que o SDK é instalado como um componente do app. Além disso, os APKs do app não incluem conteúdo do SDK.
- Há uma ou mais variantes para dispositivos mais antigos em que os APKs do SDK são adicionados para o APK do app definido como divisões de APK adicionais. Os APKs do SDK pertencem ao app . Nesse caso, o SDK Runtime é emulado no tempo de execução do app nos dispositivo.
Assim como na geração de APKs para pacotes de apps sem dependências do SDK,
bundletool extract-apks
e bundletool install-apks
retornam um conjunto filtrado de
APKs da melhor variante para o dispositivo conectado ou para o dispositivo fornecido
configuração
Para casos de uso avançados em que você só tem interesse em gerar divisões de APK
de um arquivo de SDK para um aplicativo específico para dispositivos mais antigos, use o
bundletool build-sdk-apks-for-app
da seguinte maneira:
bundletool build-sdk-apks-for-app --app-properties=app-properties.json \ --sdk-archive=sdk.asar --output=sdk.apks
O arquivo app-properties
precisa conter os campos descritos no
arquivo runtime_enabled_sdk_config.proto
. É assim que o app-properties
é semelhante a:
{
"package_name": "com.my.app",
"version_code": 1234,
"min_sdk_version": 21,
"resources_package_id": 0x7e
}
O comando bundletool build-sdk-apks-for-app
gera o subconjunto de apps
Os APKs que correspondem ao conteúdo do SDK abaixo do nome do pacote do app Você pode
combinar esses APKs com outros que têm o conteúdo do app. Por exemplo, se
você os constrói de forma separada e incremental e instalados juntos em um dispositivo
sem suporte ao SDK Runtime.
Criar e testar um pacote de SDKs (experimental)
Use bundletool
para criar um ASB e gerar os
arquivos necessários para instalação e distribuição.
Criar um pacote de SDKs
Você pode criar seu ASB na linha de comando e assiná-lo usando o jarsigner.
Para criar um pacote de SDKs, siga estas etapas:
Gere o manifesto e os recursos do pacote de SDKs no formato proto seguindo as mesmas etapas de um pacote de app.
Empacote o código compilado e os recursos do seu SDK em um arquivo ZIP base, como faria com um módulo do app.
Gere um arquivo
SdkModulesConfig.pb.json
e umSdkBundleConfig.pb.json
correspondentes ao formato descrito nas especificações do Android SDK Bundle.Crie seu ASB usando o comando
bundletool build-sdk-bundle
da seguinte maneira:
bundletool build-sdk-bundle --sdk-bundle-config=SdkBundleConfig.pb.json \ --sdk-modules-config=SdkModulesConfig.pb.json \ --modules=base.zip --output=sdk.asb
A tabela a seguir descreve em mais detalhes as diversas flags e opções que você pode configurar ao
usar o comando bundletool build-sdk-bundle
.
Flag | Descrição |
---|---|
--modules |
(Obrigatória) O arquivo do módulo que você quer usar para criar o ASB final. |
--output |
(Obrigatória) O caminho em que você quer que o ASB seja criado. |
--sdk-modules-config |
(Obrigatória) O caminho para um arquivo JSON que descreve a configuração dos módulos do SDK. Para saber como formatar o arquivo JSON, consulte a seção de especificações do Android SDK Bundle. |
--sdk-bundle-config |
O caminho para um arquivo JSON que descreve a configuração do pacote de SDKs. Para saber como formatar o arquivo JSON, consulte a seção de especificações do Android SDK Bundle. |
--metadata-file |
O arquivo em que os metadados do ASB serão incluídos.
O formato do valor da flag é
<bundle-path>:<physical-file> ,
em que <bundle-path> indica o local do arquivo dentro do
diretório de metadados do pacote de SDKs, e <physical-file> é
um arquivo já existente que contém os dados brutos a serem armazenados. A flag pode ser
repetida.
|
--overwrite |
Se definida, essa opção substitui qualquer saída anterior. |
Gerar APKs de um pacote de SDKs
Depois de criar seu ASB, você pode testar um pacote de SDKs localmente
gerando os APKs com o comando bundletool build-sdk-apks
, conforme mostrado no
código a seguir:
bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks
Quando a bundletool
gera APKs no pacote de SDKs, a ferramenta os inclui
em um contêiner chamado arquivo de conjunto de APKs, que usa a extensão
de arquivo .apks
. A bundletool
gera um único APK autônomo do pacote de SDKs, que é destinado a
todas as configurações do dispositivo.
Se você quiser implantar o ASB em um dispositivo, também vai precisar incluir as informações de assinatura do app, como mostrado neste comando:
bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks \ --ks=keystore.jks \ --ks-pass=file:/keystore.pwd \ --ks-key-alias=KeyAlias \ --key-pass=file:/key.pwd
A tabela a seguir descreve em mais detalhes as diversas flags e opções que você pode configurar ao
usar o comando bundletool build-sdk-apks
.
Flag | Descrição |
---|---|
--sdk-bundle |
(Obrigatória) O caminho para o pacote de SDKs. É preciso ter a extensão
.asb .
|
--output |
(Obrigatória) Por padrão, o caminho em que você quer que o arquivo de conjunto de APKs
seja criado. Como alternativa, se você usar
--output-format=DIRECTORY ,
esse vai ser o caminho para o diretório em que você quer que os APKs gerados sejam armazenados.
|
--ks |
O caminho para o keystore que você quer usar para assinar os APKs gerados. |
--ks-key-alias |
O alias da chave que vai ser usada no keystore para assinar os APKs gerados. |
--key-pass |
A senha da chave no keystore que vai ser usado para assinar os APKs gerados. Se você transmitir a senha em texto não criptografado, vai precisar prefixar o valor
com Se essa flag não estiver definida, a senha do keystore será testada. Se ela não for aceita, o terminal da linha de comando vai pedir outra senha. |
--ks-pass |
A senha do keystore que vai ser usado para assinar os APKs gerados. Se você transmitir a senha em texto não criptografado, vai precisar prefixar o valor
com Se essa flag não estiver definida, o terminal de linha de comando vai solicitar uma senha. |
--aapt2 |
Caminho para o binário AAPT2 que vai ser usado. |
--output-format |
O formato de saída dos APKs gerados. Por padrão, essa opção é definida como
APK_SET , que gera APKs no arquivo do conjunto de APKs
criado. Se definido como DIRECTORY , ele vai enviar os APKs para o
diretório especificado por --output . |
--verbose |
Se definida, essa opção exibe informações extras sobre a execução do comando na saída padrão. |
--version-code |
O código da versão do SDK. Esse é o código da versão usado pela Plataforma Android para instalar o APK, não a versão do SDK. Essa opção pode ser definida como um valor arbitrário. Se não for definido, o padrão vai ser 0. |
--overwrite |
Se definida, essa opção substitui qualquer saída anterior. |
Implantar, extrair e medir o tamanho dos APKs do SDK
Siga as mesmas etapas usadas para implantar APKs em um dispositivo conectado, extrair APKs específicos do dispositivo de um conjunto de APKs já existente e medir os tamanhos estimados de download de APKs em um conjunto de APKs.
Gerar um SDK Archive com base em um pacote de SDKs
Depois de fazer upload do ASB no canal de distribuição,
como o Google Play, o ASB é transformado em um Android SDK
Archive (.asar
) para distribuição aos desenvolvedores de apps pelo Maven. Para
saber mais sobre o formato, consulte a seção sobre a
especificação de formato do SDK Archive.
Depois de criar seu ASB, você pode testar a geração de um
Android SDK Archive localmente usando o comando bundletool build-sdk-asar
, conforme
mostrado no código abaixo:
bundletool build-sdk-asar --sdk-bundle=sdk.asb --output=sdk.asar \ --apk-signing-key-certificate=keycert.txt
A tabela a seguir descreve em mais detalhes as diversas flags e opções que você pode configurar ao
usar o comando bundletool build-sdk-asar
.
Flag | Descrição |
---|---|
--apk-signing-key-certificate |
(Obrigatória) O caminho para o certificado de assinatura do APK do SDK. Esse é o
certificado correspondente à chave que você usou para assinar os APKs no
comando build-sdk-apks .
|
--output |
(Obrigatória) O caminho em que você quer que o arquivo .asar seja
criado.
|
--sdk-bundle |
(Obrigatória) O caminho para o pacote de SDKs. É preciso ter a extensão
.asb .
|
--overwrite |
Se definida, essa opção substitui qualquer saída anterior. |
Formatos de SDKs ativados no momento de execução (experimental)
Os SDKs ativados no momento de execução apresentam dois formatos de arquivo do Android:
- O Android SDK Bundle (
.asb
), usado para publicar o SDK ativado no momento de execução em app stores. - O Android SDK Archive (
.asar
), usado para distribuir o SDK ativado no momento de execução no Maven.
O formato Android SDK Bundle
Um pacote de SDKs é um formato de publicação para SDKs ativados pelo ambiente de execução. Ele contém todo o código e os recursos do SDK, incluindo o código de qualquer biblioteca de que o SDK depende. Ele não inclui o código e os recursos de outros SDKs ativados no momento de execução que são obrigatórios para seu SDK.
Um Android SDK Bundle (ASB) é um arquivo ZIP assinado com a extensão
.asb
. O código e os recursos do SDK são organizados nele da mesma forma que você
encontraria em um APK. Um ASB também contém vários arquivos de configuração que ajudam
a gerar os APKs instaláveis.
A lista a seguir descreve alguns dos arquivos ASB em mais detalhes:
SdkBundleConfig.pb
: um arquivo de configuração no formato proto contendo a lista de SDKs ativados no momento de execução que são obrigatórios para seu SDK. Para ver a definição completa, consulte o arquivosdk_bundle_config.proto
.modules.resm
: um arquivo ZIP que contém todos os dados necessários para gerar os APKs do SDK.SdkModulesConfig.pb
: um arquivo de configuração no formato proto. Esse arquivo contém o nome, a versão e o nome da classe do ponto de entrada do SDK do framework (SandboxedSdkProvider
). Para ver a definição completa, consulte o arquivosdk_modules_config.proto
.base/
: o único módulo que contém o código e os recursos do SDK.manifest/
: o manifesto do SDK no formato proto.dex/
: o código compilado no formato DEX. Vários arquivos DEX podem ser fornecidos.res/
,lib/
eassets/
: esses diretórios são idênticos aos de um APK comum. Os caminhos nesses diretórios são preservados ao gerar os APKs do SDK.root/
: esse diretório armazena arquivos que são mais tarde realocados para a raiz dos APKs do SDK. Por exemplo, ele pode incluir recursos baseados em Java que o SDK carrega usando o métodoClass.getResource()
. Os caminhos dentro desse diretório também são preservados.
BUNDLE-METADATA
: esse diretório inclui arquivos de metadados que contêm informações úteis para ferramentas ou app stores. Esses arquivos de metadados podem incluir mapeamentos do ProGuard e a lista completa de arquivos DEX do SDK. Os arquivos neste diretório não são empacotados nos APKs do SDK.
O formato Android SDK Archive
O Android SDK Archive é o formato de distribuição de um SDK ativado no momento de execução no
Maven. Este é um arquivo ZIP com a extensão .asar
. Esse arquivo
contém todas as informações necessárias para que as ferramentas de criação de apps gerem
um Android App Bundle que dependa do SDK ativado no momento de execução.
A lista a seguir descreve em mais detalhes alguns dos arquivos do Android SDK Bundle:
SdkMetadata.pb
: um arquivo de configuração no formato proto contendo o nome e a versão do SDK, além do resumo do certificado da chave usada para assinar os APKs gerados para esse SDK. Para ver a definição completa, consulte o arquivosdk_metadata.proto
.modules.resm
: um arquivo ZIP que contém todos os dados necessários para gerar os APKs do SDK. Ele é o mesmo que o arquivo.resm
no Android SDK Bundle.AndroidManifest.xml
: o arquivo de manifesto do SDK no formato de texto XML.
Outros recursos
Para saber mais sobre o uso de bundletool
, assista a
Pacotes de app: como testar pacotes com a bundletool e o Play Console.