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:

1. No índice do repositório, navegue até com.android.tools.build > aapt2.
2. Copie o nome da versão mais recente do AAPT2.

3. 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

4. Navegue até o URL em um navegador. O download do AAPT2 é iniciado em seguida.

5. 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

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

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

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

Opções de dump

Use as seguintes opções com dump:

Tabela 5. Opções de dump

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

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

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.