Esta página foi traduzida pela API Cloud Translation.

bundletool

O bundletool é a ferramenta subjacente que o Android Studio, o Plug-in do Android para Gradle e o Google Play usam para criar um Android App Bundle. O bundletool pode converter um pacote de apps nos vários APKs implantados nos 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:

Tabela 1. Opções para 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 sinalização 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 `bundletool` inclui apenas módulos de recursos que especificam `<dist:fusing dist:include="true"/>` no manifesto em um APK universal. Para saber mais, leia sobre o manifesto do módulo de recurso. 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 conferir um exemplo de como testar a instalação do módulo usando a flag `--local-testing`, consulte Instalações do módulo de teste local.

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:

Tabela 2. Opções para o comando get-size total.

Flag	Descrição
`--apks=path`	(Obrigatória) Especifica o caminho para o arquivo do conjunto de APKs existente cujo tamanho de download está sendo medido.
`--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 de bibliotecas do SDK ou à execução delas no SDK Runtime. O Bundletool oculta a complexidade da compatibilidade com versões anteriores e gera diversas variantes do seu conjunto de APKs do mesmo pacote de app quando você executa bundletool build-apks com a opção --sdk-bundles ou --sdk-archives. As diversas variantes segmentam dispositivos com diferentes recursos:

Há uma variante para dispositivos mais recentes, em que o SDK é instalado como um pacote separado do app e os APKs não incluem nenhum conteúdo do SDK.
Há uma ou mais variantes para dispositivos mais antigos, em que os APKs do SDK são adicionados ao conjunto de APKs do app como divisões adicionais. Os APKs do SDK pertencem ao pacote do app. Nesse caso, o SDK Runtime é emulado no ambiente de execução do app no dispositivo.

Da mesma forma que você gera 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 a configuração fornecida.

Para casos de uso avançados em que você só tem interesse em gerar divisões de APK usando um arquivo do SDK para um app específico de dispositivos mais antigos, use o comando 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. O arquivo app-properties ficará assim:

{
  "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 APKs do app que corresponde ao conteúdo do SDK abaixo do nome do pacote do app. Você pode combinar esses APKs com outros que tenham o conteúdo do app. Por exemplo, se você os criar separadamente e de forma incremental e instalados juntos em um dispositivo que não tem 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 um SdkBundleConfig.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.

Tabela 3. Opções para 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.

Tabela 4. Opções para 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 `pass:`. Por exemplo, `pass:qwerty`. Se a senha for a primeira linha de um arquivo, você vai precisar prefixar o valor com `file:`. Por exemplo, `file:/tmp/myPassword.txt`. 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 `pass:`. Por exemplo, `pass:qwerty`. Se a senha for a primeira linha de um arquivo, você vai precisar prefixar o valor com `file:`. Por exemplo, `file:/tmp/myPassword.txt`. 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.

Tabela 5. Opções para 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.

**Figura 1**. O conteúdo de um Android SDK Bundle.

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 arquivo sdk_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 arquivo sdk_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/ e assets/: 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étodo Class.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.

**Figura 2**. O conteúdo de um Android SDK Archive Bundle.

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 arquivo sdk_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.