Esta página foi traduzida pela API Cloud Translation.

AAPT2

O AAPT2 (Android Asset Packaging Tool) é uma ferramenta de build que o Android Studio e o Plug-in do Android para Gradle usam para compilar e empacotar recursos de apps. O AAPT2 analisa, indexa e compila os recursos em um formato binário que é otimizado para a plataforma Android.

O Plug-in do Android para Gradle 3.0.0 e versões mais recentes ativam o AAPT2 por padrão. Normalmente, não é necessário invocar o aapt2. No entanto, se você preferir usar seu terminal e seu sistema de build em vez do Android Studio, vai poder usar o AAPT2 na linha de comando. Também é possível depurar erros de builds de depuração relacionados ao AAPT2 a partir da linha de comando. Para isso, o AAPT2 está disponível como uma ferramenta autônoma no Android SDK Build Tools 26.0.2 e versões mais recentes.

Para fazer o download do Android SDK Build Tools na linha de comando, use o sdkmanager e execute o seguinte comando:

sdkmanager "build-tools;build-tools-version"

Depois de fazer o download do SDK Build Tools, encontre o AAPT2 em android_sdk/build-tools/version/.

Como as revisões do Android SDK Build Tools não são lançadas com frequência, a versão do AAPT2 incluída no SDK Build Tools pode não ser a mais recente. Para saber como instalar a versão mais recente do AAPT2, faça o download do AAPT2 no Google Maven.

Para usar o AAPT2 na linha de comando no Linux ou Mac, execute o comando aapt2. No Windows, execute o comando aapt2.exe.

O AAPT2 oferece suporte para uma compilação mais rápida de recursos, ativando a compilação incremental. Para realizar a compilação incremental, o processamento de recursos é separado em duas etapas:

Compile: compila arquivos de recursos em formatos binários.
Link: mescla todos os arquivos compilados e compacta-os em um único pacote.

Essa separação ajuda a melhorar a performance de builds incrementais. Por exemplo, se houver mudanças em um único arquivo, você vai precisar recompilar somente esse arquivo.

Fazer o download do AAPT2 no Google Maven

Para instalar a versão mais recente do AAPT2 que não está incluída no SDK Build Tools, faça o download do AAPT2 no repositório Maven do Google da seguinte maneira:

No índice do repositório, navegue até com.android.tools.build > aapt2.
Copie o nome da versão mais recente do AAPT2.
Insira o nome da versão que você copiou no seguinte URL e especifique seu sistema operacional de destino: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/ aapt2-version/aapt2-aapt2-version-[windows | linux | osx].jar

Por exemplo, para fazer o download da versão 3.2.0-alpha18-4804415 para Windows, use: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/ 3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar
Navegue até o URL em um navegador. O download do AAPT2 é iniciado em seguida.
Descompacte o arquivo JAR que você acabou de transferir.

O arquivo JAR vai ter um executável aapt2 e algumas bibliotecas de que o executável depende.

Compilação

O AAPT2 oferece suporte para a compilação de todos os tipos de recursos do Android, como drawables e arquivos XML. Ao invocar o AAPT2 para compilação, transmita um único arquivo de recurso como entrada por invocação. Em seguida, o AAPT2 analisa o arquivo e gera um arquivo binário intermediário com a extensão .flat.

Ou seja, ao transmitir diretórios inteiros, o AAPT2 recompila todos os arquivos do diretório, mesmo quando apenas um recurso foi modificado. Embora seja possível transmitir diretórios de recursos com mais de um arquivo de recursos para o AAPT2 usando a sinalização --dir, você não vai ter os benefícios da compilação incremental de recursos dessa maneira.

Os tipos de arquivo de saída podem ser diferentes com base na entrada fornecida para compilação, conforme mostrado na tabela a seguir:

Tabela 1. Os tipos de arquivo de entrada e saída para compilação

Entrada Saída

Arquivos de recursos XML, como String e Style, localizados no diretório res/values/. Tabela de recursos com *.arsc.flat como extensão.

Todos os outros arquivos de recursos.

Entrada	Saída
Arquivos de recursos XML, como String e Style, localizados no diretório `res/values/`.	Tabela de recursos com `*.arsc.flat` como extensão.
Todos os outros arquivos de recursos.	Todos os arquivos, exceto os do diretório `res/values/`, são convertidos em arquivos XML binários com a extensão `.flat`. Além disso, todos os arquivos PNG são processados por padrão e adotam a extensão `.png.flat`. Se você optar por não compactar PNGs, vai poder usar a opção `--no-crunch` durante a compilação.

Todos os arquivos, exceto os do diretório res/values/, são convertidos em arquivos XML binários com a extensão *.flat.

Além disso, todos os arquivos PNG são processados por padrão e adotam a extensão *.png.flat. Se você optar por não compactar PNGs, vai poder usar a opção --no-crunch durante a compilação.

Os arquivos de saída AAPT2 não são executáveis. É necessário incluir esses arquivos binários posteriormente como entrada na fase de vinculação a fim de gerar um APK. No entanto, o arquivo APK gerado não é um executável que pode ser implantado em um dispositivo Android imediatamente, porque ele não contém arquivos DEX e não está assinado.

Sintaxe de compile

A sintaxe geral para usar compile é a seguinte:

aapt2 compile path-to-input-files [options] -o output-directory/

No exemplo a seguir, o AAPT2 compila arquivos de recursos nomeados values.xml e myImage.png individualmente:

aapt2 compile project_root/module_root/src/main/res/values-en/strings.xml -o compiled/
aapt2 compile project_root/module_root/src/main/res/drawable/myImage.png -o compiled/

Conforme mostrado na tabela 1, o nome do arquivo de saída depende do nome do arquivo de entrada e do nome do diretório pai.

No exemplo anterior com o arquivo strings.xml como entrada, o aapt2 nomeia automaticamente o arquivo de saída como values-en_strings.arsc.flat. No entanto, o arquivo drawable compilado armazenado no diretório drawable é chamado de drawable_img.png.flat.

Opções de compile

Há várias opções que podem ser usadas com o comando compile, conforme mostrado na tabela 2:

Tabela 2. Opções de comando de compilação

Opção	Descrição
`-o path`	Especifica o caminho de saída para os recursos compilados. Essa é uma sinalização obrigatória porque você precisa especificar um caminho para um diretório em que o AAPT2 pode gerar e armazenar os recursos compilados.
`--dir directory`	Especifica o diretório para procurar recursos. Embora você possa usar essa sinalização para compilar vários arquivos de recursos com um comando, ela desativa os benefícios da compilação incremental. Portanto, essa sinalização não deve ser usada para projetos grandes.
`--pseudo-localize`	Gera versões pseudolocalizadas de strings padrão, como `en-XA` e `en-XB`.
`--no-crunch`	Desativa o processamento de PNG. Use essa opção se você já tiver processado os arquivos PNG ou criar builds de depuração que não exijam a redução do tamanho do arquivo. A ativação dessa opção resulta em uma execução mais rápida, mas aumenta o tamanho do arquivo de saída.
`--legacy`	Trata erros que são permitidos ao usar versões anteriores do AAPT como avisos. Essa sinalização precisa ser usada para erros inesperados de tempo de compilação. Para resolver mudanças de comportamento conhecidas que podem ocorrer durante o uso do AAPT2, leia Mudanças de comportamento durante o uso do AAPT2.
`-zip file`	`file` é um arquivo ZIP que contém o diretório `res` para procurar recursos.
`-output-text-symbols file`	Gera um arquivo de texto com os símbolos de recursos no arquivo especificado.
`-preserve-visibility-of-styleables`	Se especificado, aplica as mesmas regras de visibilidade para estilos que são usados para todos os outros recursos. Caso contrário, todos os estilos podem ser definidos como públicos.
`-visibility [public\|private\|default\|]`	Define a visibilidade dos recursos compilados para o nível especificado.
`-trace-folder folder`	Gera um fragmento de trace JSON de `systrace` para a pasta especificada.
`-source-path path`	Define o caminho do arquivo de origem do arquivo de recursos compilado como caminho.
`-h`	Mostra a ajuda de ferramentas.
`-v`	Ativa o registro detalhado.

Link

Na fase de vinculação, o AAPT2 mescla todos os arquivos intermediários gerados pela fase de compilação, como tabelas de recursos, arquivos XML binários e arquivos PNG processados, e agrupa os arquivos em um único APK. Além disso, outros arquivos auxiliares, como R.java e arquivos de regras do ProGuard, podem ser gerados durante essa fase. No entanto, o APK gerado não contém bytecode DEX e não está assinado. Não é possível implantar esse APK em um dispositivo.

Se você não estiver usando o Plug-in do Android para Gradle para criar o app na linha de comando, vai poder usar outras ferramentas de linha de comando, como d8, para compilar bytecode Java no bytecode DEX, e apksigner, para assinar o APK.

Sintaxe de link

A sintaxe geral para usar link é esta:

aapt2 link path-to-input-files [options] -o
outputdirectory/outputfilename.apk --manifest AndroidManifest.xml

No exemplo a seguir, o AAPT2 mescla os dois arquivos intermediários, drawable_Image.flat e values_values.arsc.flat, com o arquivo AndroidManifest.xml. O AAPT2 vincula o resultado ao arquivo android.jar, que contém os recursos definidos no pacote android:

 aapt2 link -o output.apk
 -I android_sdk/platforms/android_version/android.jar
    compiled/res/values_values.arsc.flat
    compiled/res/drawable_Image.flat --manifest /path/to/AndroidManifest.xml -v

Opções de link

É possível usar as seguintes opções com o comando link:

Tabela 3. Opções de comando de link

Opção	Descrição
`-o path`	Especifica o caminho de saída do APK de recurso vinculado. Essa é uma sinalização obrigatória porque você precisa especificar o caminho para o APK de saída que pode armazenar os recursos vinculados.
`--manifest file`	Especifica o caminho para o arquivo de manifesto do Android a ser criado. Essa é uma sinalização obrigatória porque o arquivo de manifesto inclui informações essenciais sobre seu app, como o nome do pacote e o ID do aplicativo.
`-I`	Fornece o caminho para o `android.jar` da plataforma ou outros APKs, como `framework-res.apk`, que podem ser úteis para a criação de recursos. Essa sinalização vai ser obrigatória se você estiver usando atributos com o namespace `android` nos seus arquivos de recursos.
`-A directory`	Especifica um diretório de assets a ser incluído no APK. Você pode usar esse diretório para armazenar arquivos originais não processados. Para saber mais, leia Como acessar arquivos originais.
`-R file`	Transmite um arquivo `.flat` individual para `link`, usando a semântica `overlay` sem a tag `<add-resource>`. Quando você fornece um arquivo de recurso que se sobrepõe a um arquivo existente, o último recurso em conflito fornecido é usado.
`--package-id package-id`	Especifica o ID do pacote a ser usado para o app. O ID do pacote especificado precisa ser maior ou igual a 0x7f, a menos que seja usado em combinação com `--allow-reserved-package-id`.
`--allow-reserved-package-id`	Permite o uso de um código de pacote reservado. Códigos de pacotes reservados são normalmente atribuídos a bibliotecas compartilhadas e estão no intervalo de 0x02 a 0x7e. Ao usar `--allow-reserved-package-id`, você poderá atribuir IDs que se enquadrem no intervalo de IDs de pacotes reservados. Essa opção só deve ser usada para pacotes com uma versão 26 do `min-sdk` ou anterior.
`--java directory`	Especifica o diretório em que `R.java` vai ser gerado.
`--proguard proguard_options`	Gera o arquivo de saída para as regras do ProGuard.
`--proguard-conditional-keep-rules`	Gera o arquivo de saída para as regras do ProGuard para o principal DEX.
`--no-auto-version`	Desativa o controle de versões automático de estilo e layout de SDK.
`--no-version-vectors`	Desativa o controle de versões automático de drawables de vetor. Use essa sinalização somente ao criar seu APK com a biblioteca Vector Drawable.
`--no-version-transitions`	Desativa o controle de versões automático dos recursos de transição. Use essa sinalização somente ao criar seu APK com a biblioteca Transition Support.
`--no-resource-deduping`	Desativa a desduplicação automática de recursos com valores idênticos em todas as configurações compatíveis.
`--enable-sparse-encoding`	Permite a codificação de entradas esparsas usando uma árvore de pesquisa binária. Isso é útil para otimizar o tamanho do APK, mas à custa da performance da recuperação de recursos.
`-z`	Requer localização de strings marcadas como "suggested".
`-c config`	Fornece uma lista de configurações separada por vírgulas. Por exemplo, se você tiver dependências na Biblioteca de Suporte, que contém traduções para vários idiomas, vai poder filtrar recursos apenas para a configuração de idioma fornecida, como inglês ou espanhol. Você precisa definir a configuração de idioma por um código de idioma ISO 639-1 de duas letras, opcionalmente seguido por um código de região ISO 3166-1-alfa-2 de duas letras precedido por "r" minúsculo. Por exemplo, en-rUS.
`--preferred-density density`	Permite que o AAPT2 selecione a densidade de correspondência mais próxima e remova todas as outras. Existem vários qualificadores de densidade de pixel disponíveis para uso no seu app, como ldpi, hdpi e xhdpi. Quando você especifica uma densidade preferencial, o AAPT2 seleciona e armazena a densidade de correspondência mais próxima na tabela de recursos e remove todas as outras.
`--output-to-dir`	Gera o conteúdo do APK para um diretório especificado por `-o`. Se houver algum erro durante o uso dessa sinalização, você poderá resolvê-lo atualizando para o Android SDK Build Tools 28.0.0 ou mais recente.
`--min-sdk-version min-sdk-version`	Define a versão mínima padrão do SDK a ser usada no `AndroidManifest.xml`.
`--target-sdk-version target-sdk-version`	Define a versão do SDK de destino padrão a ser usada no `AndroidManifest.xml`.
`--version-code version-code`	Especifica o código da versão a ser injetada em `AndroidManifest.xml` se nenhuma estiver presente.
`--version-name version-name`	Especifica o nome da versão a ser injetada no `AndroidManifest.xml` se nenhuma estiver presente.
`--revision-code revision-code`	Especifica o código de revisão a ser injetado no arquivo `AndroidManifest.xml` se nenhum estiver presente.
`--replace-version`	Se `--version-code`, `--version-name` ou `--revision-code` forem especificados, esses valores vão substituir qualquer valor que já esteja no manifesto. Por padrão, nada vai mudar se o manifesto já definir esses atributos.
`--compile-sdk-version-nacodeme compile-sdk-version-name`	Especifica o código da versão a ser injetada no arquivo `AndroidManifest.xml` se nenhuma estiver presente.
`--compile-sdk-version-name compile-sdk-version-name`	Especifica o nome da versão a ser injetada no arquivo `AndroidManifest.xml` se nenhuma estiver presente.
`--proto-format`	Gera recursos compilados no formato Protobuf. Adequado como entrada para `bundletool` para gerar um Android App Bundle.
`--non-final-ids`	Gera `R.java` com IDs de recursos não finais. As referências aos IDs do código do app não são inline durante a compilação de `kotlinc` ou `javac`.
`--emit-ids path`	Emite um arquivo no caminho fornecido com uma lista de nomes de tipos de recursos e os respectivos mapeamentos de IDs. Esse recurso é adequado para usar com `--stable-ids`.
`--stable-ids outputfilename.ext`	Consome o arquivo gerado por `--emit-ids` que contém a lista de nomes de tipos de recursos e os códigos atribuídos. Essa opção permite que os IDs atribuídos permaneçam estáveis mesmo quando você excluir ou adicionar novos recursos durante a vinculação.
`--custom-package package_name`	Especifica o pacote Java personalizado em que `R.java` vai ser gerado.
`--extra-packages package_name`	Gera o mesmo arquivo `R.java`, mas com nomes de pacotes diferentes.
`--add-javadoc-annotation annotation`	Adiciona uma anotação JavaDoc a todas as classes Java geradas.
`--output-text-symbols path`	Gera um arquivo de texto contendo os símbolos de recurso da classe `R` no arquivo especificado. Você precisa especificar o caminho para o arquivo de saída.
`--auto-add-overlay`	Permite o acréscimo de novos recursos em sobreposições sem usar a tag `<add-resource>`.
`--rename-manifest-package manifest-package`	Renomeia o pacote no arquivo `AndroidManifest.xml`.
`--rename-instrumentation-target-package instrumentation- target-package`	Muda o nome do pacote de destino para `instrumentation`. Essa opção precisa ser usada com `--rename-manifest-package`.
`-0 extension`	Especifica as extensões de arquivos que você não quer compactar.
`--split path:config[,config[..]]`	Divide recursos com base em um conjunto de configurações para gerar uma versão diferente do APK. É preciso especificar o caminho para o APK de saída, junto do conjunto de configurações.
`--proguard-main-dex file`	Arquivo de saída para as regras do ProGuard geradas para o DEX principal.
`--proguard-minimal-keep-rules`	Gera um conjunto mínimo de regras do ProGuard.
`--no-resource-removal`	Desativa a remoção automática de recursos sem padrões. Use essa opção somente ao criar pacotes de sobreposição de recursos no momento da execução.
`-x`	Sinalização legada que especifica o uso do identificador do pacote 0x01.
`--product products-list`	Especifica uma lista separada por vírgulas de nomes de produtos a serem mantidos.
`--no-xml-namespaces`	Remoção das informações de prefixo e URI de namespace XML do arquivo `AndroidManifest.xml` e dos binários XML em `res/*`.
`--shared-lib`	Gera uma biblioteca compartilhada do Android Runtime.
`--static-lib`	Gera uma biblioteca Android estática.
`--no-static-lib-packages`	Mescla todos os recursos da biblioteca no pacote do app.
`--no-proguard-location-reference`	Esse método impede que os arquivos das regras do ProGuard tenham uma referência ao arquivo de origem.
`--private-symbols package-name`	`package-name` especifica o nome do pacote a ser usado ao gerar `R.java` para símbolos particulares. Se não for especificado, os símbolos públicos e particulares vão usar o nome do pacote do app.
`--override-styles-instead-of-overlaying`	Faz com que os estilos definidos nos recursos `-R` substituam as definições anteriores em vez de mesclá-las.
`--rename-resources-package package-name`	Renomeia o pacote na tabela de recursos para `package-name`.
`--no-compress`	Não compacta recursos.
`--keep-raw-values`	Preserva valores brutos do atributo em arquivos XML.
`--no-compress-regex regular-expression`	Não compacta extensões que correspondem a `regular-expression`. Use o símbolo `$` no fim da linha. Usa uma gramática de expressão regular ECMAScript que diferencia maiúsculas de minúsculas.
`--warn-manifest-validation`	Trata erros de validação de manifesto como avisos.
`--exclude-configs qualifier[,qualifier[..]]`	Exclui valores de recursos com configurações que contenham os qualificadores especificados.
`--debug-mode`	Insere `android:debuggable="true"` no nó do aplicativo do manifesto, tornando o aplicativo depurável mesmo em dispositivos de produção.
`--strict-visibility`	Não permite sobreposições com diferentes níveis de visibilidade.
`--exclude-sources`	Não serializa informações do arquivo de origem ao gerar recursos no formato Protobuf.
`--trace-folder folder`	Gera o fragmento de trace JSON de `systrace` para `folder` especificado.
`--merge-only`	Mescla os recursos sem verificar as referências de recursos. Essa sinalização só deve ser usada com a sinalização `--static-lib`.
`-h`	Mostra o menu de ajuda.
`-v`	Permite maior detalhamento da saída.

Dump

dump é usado para imprimir informações sobre o APK gerado usando o comando link.

Sintaxe de dump

A sintaxe geral para usar dump é esta:

aapt2 dump sub-command filename.apk [options]

O exemplo a seguir imprime o conteúdo da tabela de recursos do APK especificado:

aapt2 dump resources output.apk

Subcomandos de dump

Especifique um dos seguintes subcomandos com o comando dump:

Tabela 4. Subcomandos de dump

Subcomando	Descrição
`apc`	Mostra o conteúdo do contêiner AAPT2 (APC) gerado durante a compilação.
`badging`	Mostra informações extraídas do manifesto do APK.
`configurations`	Mostra todas as configurações usadas por um recurso no APK.
`overlayable`	Mostra os recursos sobrepostos do APK.
`packagename`	Mostra o nome do pacote do APK.
`permissions`	Mostra as permissões extraídas do manifesto do APK.
`strings`	Mostra o conteúdo do pool de strings da tabela de recursos do APK.
`styleparents`	mostra os pais dos estilos usados no APK.
`resources`	Mostra o conteúdo da tabela de recursos do APK.
`xmlstrings`	Mostra strings do XML compilado do APK.
`xmltree`	Mostra uma árvore do XML compilado do APK.

Opções de dump

Use as seguintes opções com dump:

Tabela 5. Opções de dump

Opção	Descrição
`--no-values`	Suprime a saída de valores ao mostrar recursos.
`--file file`	Especifica um arquivo como argumento a ser removido do APK.
`-v`	Aumenta o detalhamento da saída.

Diff

Use diff para comparar dois APKs e identificar diferenças entre eles.

Sintaxe de diff

A sintaxe geral para usar diff é esta:

aapt2 diff first.apk second.apk

Não há opções para o comando diff.

Optimize

optimize é usado para executar otimizações nos recursos mesclados e resources.arsc antes que sejam empacotados no APK. Essa otimização pode reduzir o tamanho do APK em cerca de 1% a 3%, dependendo do tamanho e do número de recursos usados.

Sintaxe de optimize

A sintaxe geral para usar optimize é esta:

aapt2 optimize options file[,file[..]]

O exemplo a seguir otimiza os recursos em input.apk e cria um novo APK otimizado em output.apk. Ele substitui a representação fixa da tabela plana por uma árvore de pesquisa binária mais compacta, resultando em um APK menor ao custo de recuperação:

aapt2 optimize -o output.apk --enable-sparse-encoding input.apk

Opções de optimize

É possível usar as seguintes opções com optimize:

Tabela 6. Opções de optimize

Opção	Descrição
`-o path`	Especifica o caminho de saída do APK de recurso vinculado. Essa é uma sinalização obrigatória porque você precisa especificar o caminho para o APK de saída que pode armazenar os recursos vinculados.
`-d directory`	Especifica o caminho para o diretório de saída para divisões.
`-x path`	Especifica o caminho do arquivo de configuração XML.
`-p`	Mostra os artefatos de vários APKs e sai.
`--target-densities density[,density[..]]`	Especifica uma lista separada por vírgulas das densidades de tela para as quais o APK é otimizado. Todos os recursos que não seriam usados em dispositivos com densidades específicas são removidos do APK.
`--resources-config-path path`	Especifica o caminho para o arquivo `resources.cfg` que contém a lista de recursos e diretivas de cada recurso. Formato: `type/resource_name#[directive][,directive]`
`-c config[,config[..]]`	Especifica uma lista de configurações separadas por vírgulas a serem incluídas. O padrão é todas as configurações.
`--split path:config[,config[..]]`	Divide recursos com base em um conjunto de configurações para gerar uma versão diferente do APK. É preciso especificar o caminho para o APK de saída, junto do conjunto de configurações.
`--keep-artifacts artifact[,artifact[..]]`	Especifica uma lista de artefatos separados por vírgulas para manter. Se nenhum for especificado, todos os artefatos vão ser mantidos.
`--enable-sparse-encoding`	Permite a codificação de entradas esparsas usando uma árvore de pesquisa binária. Isso é útil para otimizar o tamanho do APK, mas à custa da performance da recuperação de recursos.
`--collapse-resource-names`	Recolhe nomes de recursos para um único valor no pool de strings de chaves. Os recursos são isentos usando a diretiva `no_collapse` em um arquivo especificado por `--resources-config-path`.
`--shorten-resource-paths`	Encurta os caminhos dos recursos dentro do APK.
`--resource-path-shortening-map path`	Especifica o caminho de saída do mapa de caminhos de recurso antigos para caminhos encurtados.
`-v`	Aumenta o detalhamento da saída.
`-h`	Mostra a ajuda da ferramenta.

Convert

Por padrão, o comando compile do AAPT compila os recursos em um formato binário adequado para APKs. Também é possível especificar o formato protobuf que é adequado para AABs especificando --proto-format. O comando convert converte APKs entre os dois formatos.

Sintaxe de convert

A sintaxe geral de convert é a seguinte:

aapt2 convert -o output-file options file[,file[..]]

O exemplo a seguir converte os recursos em input.apk e cria um novo APK em output.apk contendo recursos de formato protobuf. Ele substitui a representação fixa da tabela plana por uma árvore de pesquisa binária mais compacta, resultando em um APK menor ao custo de recuperação:

aapt2 convert -o output.apk --output-format proto --enable-sparse-encoding input.apk

Opções de convert

Use as seguintes opções com convert:

Tabela 7. Opções de convert

Opção	Descrição
`-o path`	Especifica o caminho de saída do APK de recurso vinculado. Essa é uma sinalização obrigatória porque você precisa especificar o caminho para o APK de saída que pode armazenar os recursos vinculados.
`--output-format [proto\|binary]`	Formato da saída. Os valores aceitos são `proto` e `binary`. Quando não definido, o padrão é `binary`.
`--enable-sparse-encoding`	Permite a codificação de entradas esparsas usando uma árvore de pesquisa binária. Isso é útil para otimizar o tamanho do APK, mas à custa da performance da recuperação de recursos.
`--keep-raw-values`	Preserva valores brutos do atributo em arquivos XML.
`-v`	Aumenta o detalhamento da saída.
`-h`	Mostra a ajuda da ferramenta.

Modo daemon

O AAPT 2.19 introduziu o modo daemon para emitir comandos. O modo daemon permite que você insira vários comandos em uma única sessão do AAPT.

Sintaxe de daemon

Inicie o modo daemon com o seguinte comando:

aapt2 daemon

Quando o modo daemon estiver em execução, vai ser possível inserir comandos. Cada argumento do comando precisa estar em uma linha separada, com uma linha em branco no final do comando. Saia do modo daemon digitando Control+D.

Considere os seguintes comandos compile individuais:

aapt2 compile project_root/module_root/src/main/res/values-en/strings.xml -o compiled/
aapt2 compile project_root/module_root/src/main/res/drawable/myImage.png -o compiled/

Esses comandos podem ser inseridos no modo daemon como:

aapt2 daemon
Ready
compile
project_root/module_root/src/main/res/values-en/strings.xml
-o
compiled/

Done
compile
project_root/module_root/src/main/res/drawable/myImage.png
-o
compiled/

Done
^D
Exiting daemon

Opções do modo daemon

A única opção para o modo daemon é --trace-folder folder, que gera um fragmento de rastreamento JSON systrace para folder especificado.

Version

Determine a versão do AAPT2 que você está usando com o comando version:

aapt2 version
Android Asset Packaging Tool (aapt) 2.19-8678579

Mudanças de comportamento durante o uso do AAPT2

Antes do AAPT2, o AAPT era a versão padrão da Android Asset Packaging Tool, que foi descontinuada. Embora o AAPT2 deva funcionar imediatamente com projetos antigos, esta seção descreve algumas mudanças de comportamento que é preciso conhecer.

Hierarquias de elementos no manifesto do Android

Nas versões anteriores do AAPT, os elementos aninhados em nós incorretos no arquivo AndroidManifest.xml eram ignorados ou geravam um aviso. Por exemplo, considere o seguinte exemplo:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
   package="com.example.myname.myapplication">
   <application
       ...
       <activity android:name=".MainActivity">
           <intent-filter>
               <action android:name="android.intent.action.MAIN" />
               <category android:name="android.intent.category.LAUNCHER" />
           </intent-filter>
           <action android:name="android.intent.action.CUSTOM" />
       </activity>
   </application>
</manifest>

As versões anteriores do AAPT simplesmente ignoravam a tag <action> posicionada incorretamente.

Com o AAPT2, você recebe o seguinte erro:

AndroidManifest.xml:15: error: unknown element <action> found.

Para resolver o problema, verifique se os elementos do manifesto estão aninhados corretamente. Para saber mais, leia a Visão geral do manifesto do app.

Declaração de recursos

Não é mais possível indicar o tipo de recurso no atributo name. O exemplo abaixo declara incorretamente um item de recurso attr:

<style name="childStyle" parent="parentStyle">
    <item name="attr/my_attr">@color/pink</item>
</style>

A declaração de um tipo de recurso dessa forma resulta no seguinte erro de build:

Error: style attribute 'attr/attr/my_attr (aka my.package:attr/attr/my_attr)'
not found.

Para resolver esse erro, declare explicitamente o tipo usando type="attr":

<style name="childStyle" parent="parentStyle">
  <item type="attr" name="my_attr">@color/pink</item>
</style>

Além disso, ao declarar um elemento <style>, o pai também precisa ser um tipo de recurso style. Caso contrário, ocorrerá um erro semelhante ao seguinte:

Error: (...) invalid resource type 'attr' for parent of style

Uso incorreto de símbolos de referência de recursos @

O AAPT2 gera erros de build quando você omite ou posiciona incorretamente símbolos de referência de recursos (@). Por exemplo, se você omitir o símbolo ao especificar um atributo de estilo:

<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
  ...
  <!-- Note the missing '@' symbol when specifying the resource type. -->
  <item name="colorPrimary">color/colorPrimary</item>
</style>

Ao compilar o módulo, o AAPT2 gera o seguinte erro de build:

ERROR: expected color but got (raw string) color/colorPrimary

Além disso, se você incluir incorretamente o símbolo ao acessar um recurso do namespace android:

...
<!-- When referencing resources from the 'android' namespace, omit the '@' symbol. -->
<item name="@android:windowEnterAnimation"/>

Ao compilar o módulo, o AAPT2 gera o seguinte erro de build:

Error: style attribute '@android:attr/windowEnterAnimation' not found

Configuração incorreta de bibliotecas

Se o app tiver uma dependência de uma biblioteca de terceiros criada com versões mais antigas do Android SDK Build Tools, ele poderá ter falha no tempo de execução sem mostrar erros ou avisos. Essa falha pode ocorrer porque, durante a criação da biblioteca, os campos R.java são declarados como final. Como resultado, todos os IDs de recursos são inline nas classes da biblioteca.

O AAPT2 depende da possibilidade de reatribuir IDs a recursos da biblioteca ao criar o app. Se a biblioteca presumir que os IDs são final e embuti-los no DEX da biblioteca, vai haver uma incompatibilidade no tempo de execução.

Para resolver esse erro, entre em contato com o autor da biblioteca para que ele a recrie usando a versão mais recente do Android SDK Build Tools e publique-a novamente.