Résumé de l'utilisation de la ligne de commande AAPT2

Présentation de l'AAPT2 :

AAPT2 (Android Asset Packaging Tool) est un outil de construction utilisé par Android Studio et le plugin Android Gradle pour compiler et empaqueter les ressources d'une application. AAPT2 analyse, indexe et compile les ressources dans un format binaire optimisé pour la plate-forme Android.
Android Gradle Plugin 3.0.0 et versions ultérieures active AAPT2 par défaut,
Nous pouvons utiliser la ligne de commande AAPT2 pour compiler les ressources de liens,

Scénario d'utilisation de la ligne de commande aapt2

Après avoir utilisé apktool pour la modification du package secondaire et la fusion des fichiers de ressources de code, il est nécessaire de recompiler le lien pour générer un index de ressources, c'est-à-dire générer un fichier R. Avant de recompiler, utilisez AAPT2 pour compiler (compiler) et lier (lien) pour générer à nouveau un fichier R.java. Utilisez les commandes javac et cvf de jdk pour générer class et jar respectivement, puis utilisez l'outil de ligne de commande dx ou R8 pour générer dex, et enfin utilisez l'outil baksmali pour générer des fichiers samli et les fusionner dans le paquet mère smali, afin que l'intégration réelle des fichiers de ressources soit réalisée.
Nous savons qu'Android Studio peut générer des fichiers aab (Android App Bundle) pour Google Play afin de télécharger des packages aab. Il utilise principalement la ligne de commande de l'outil bundletool pour encapsuler la ligne de commande, ce qui rend très simple la génération de aab. Si nous utilisons bundletool ligne de commande pour générer des fichiers aab, nous devons utiliser l'indicateur --proto-format de AAPT2 pour compiler et lier les ressources de l'application, et générer la liste et les ressources protobuf (format de tampon de protocole de Google : Protocol Buffers | Google Developers ) . la commande build-bundle de bundletool pour générer aab, et l'aab généré peut être téléchargé sur Google Play après avoir signé avec jarsigner
Si votre application ou votre jeu doit être publié à l'étranger, vous devez fournir un package aab, et les principales chaînes nationales fournissent un package apk, des canaux nationaux généralement agrégés, puis utiliser des outils de packaging pour produire des packages de canaux spécifiques, des canaux agrégés. Il est également possible de agréger les chaînes étrangères. Si les chaînes étrangères souhaitent générer des packages aab et utiliser des outils de création de packages au lieu d'Andorid Studio pour exporter des packages, AAPT2 est requis. Avant d'utiliser bundletool pour compresser les ressources, utilisez AAPT2 pour générer une liste de formats protobuf et les ressources qui s'y trouvent
Comment afficher les informations apk que nous avons générées, la commande dump d'AAPT est pratique pour afficher des informations dump sur l'APK que vous link avez généré à l'aide de la commande
AAPT2 a des exigences plus strictes sur le format et la grammaire des ressources. Là où aapt signalait des avertissements auparavant, la compilation sous aapt2 peut directement signaler des erreurs, nous écrivons donc des codes et importons des fichiers de ressources aussi standard que possible.

Comment obtenir AAPT2

Généralement, on android_sdk/build-tools/version/ peut trouver AAPT2 dans le répertoire
La dernière version AAPT2 peut également être téléchargée à partir du référentiel Maven de Google

Résumé des commandes courantes d'AAPT2

Les commandes et instructions d'utilisation suivantes proviennent de la documentation aapt2 de Google : AAPT2 | Développeurs Android | Développeurs Android

Plus tard, j'utiliserai certaines commandes pour m'entraîner, résoudre certains problèmes de scénario d'utilisation que nous avons rencontrés ci-dessus et écrire un autre article

compiler
AAPT2 prend en charge la compilation de tous les types de ressources Android tels que les drawables et les fichiers XML. Lorsque vous appelez AAPT2 pour compiler, chaque appel doit transmettre un fichier de ressources en entrée. Ensuite, AAPT2 analysera le fichier et générera un .flat fichier binaire intermédiaire avec l'extension . Cette méthode est généralement utilisée pour la compilation incrémentale, et la vitesse est très rapide. L'empaquetage dans AS devrait utiliser cette méthode. Nous pouvons également utiliser des balises --dir pour inclure plusieurs Le répertoire de ressources des fichiers de ressources est transmis à AAPT2 pour compiler tous les fichiers du répertoire et spécifier le fichier de sortie au format .zip

Le type de fichier de sortie peut varier en fonction de l'entrée que vous fournissez pour la compilation. Le tableau ci-dessous l'illustre :

entrer	sortir
Fichiers de ressources XML (tels que String et Style ), qui se trouvent `res/values/` dans le répertoire.	La table des ressources avec `*.arsc.flat` l'extension.
Tous les autres fichiers de ressources.	`res/values/` Tous les fichiers, à l'exception de ceux situés sous le répertoire, seront convertis en `.flat` fichiers XML binaires avec l'extension . De plus, par défaut, tous les fichiers PNG sont compressés et ont `.png.flat` une extension. Si vous choisissez de ne pas compresser les PNG, vous pouvez utiliser des options lors de la compilation `--no-crunch` .

Les fichiers produits par AAPT2 ne sont pas des exécutables, vous devez ajouter ces binaires en entrée plus tard dans la phase de liaison pour générer l'APK. Cependant, le fichier APK résultant n'est pas un exécutable prêt à être déployé sur un appareil Android car il ne contient pas de fichier DEX (bytecode compilé) et n'est pas signé.

Syntaxe de compilation : aapt2 compile path-to-input-files [options] -o output-directory/

options de compilation

Vous pouvez utiliser plusieurs options avec compile la commande, comme indiqué dans le tableau suivant :

options	illustrer
`-o path`	Spécifie le chemin de sortie pour les ressources compilées. Il s'agit d'un indicateur obligatoire car vous devez spécifier le chemin d'accès à un répertoire où AAPT2 peut générer et stocker des ressources compilées.
`--dir directory`	Spécifie les répertoires dans lesquels rechercher des ressources. Bien que vous puissiez utiliser cet indicateur pour compiler plusieurs fichiers de ressources avec une seule commande, il perd les avantages de la compilation incrémentielle et n'est pas recommandé pour les grands projets.
`--pseudo-localize`	Générez des versions pseudo-localisées des chaînes par défaut , telles que en-XA et en-XB.
`--no-crunch`	Désactiver le traitement PNG. Utilisez cette option si vous avez travaillé avec des fichiers PNG ou si vous souhaitez créer une version de débogage qui ne nécessite pas de réduction de la taille du fichier. L'activation de cette option accélère l'exécution, mais augmente la taille du fichier de sortie.
`--legacy`	Traitez les erreurs autorisées lors de l'utilisation de versions antérieures d'AAPT comme des avertissements. Cet indicateur doit être utilisé pour les erreurs de compilation inattendues. Pour traiter les changements de comportement connus que vous pouvez rencontrer lors de l'utilisation d'AAPT2, consultez Changements de comportement dans AAPT2 .
`-v`	Activer la journalisation détaillée.

Lien

Pendant la phase de liaison, AAPT2 combine tous les fichiers intermédiaires générés pendant la phase de compilation (tels que les tables de ressources, les fichiers XML binaires et les fichiers PNG traités) et les regroupe dans un seul fichier APK. En outre, d'autres fichiers auxiliaires tels que les fichiers de règles ProGuard sont générés à ce stade R.java . Cependant, l'APK résultant ne contient pas de bytecode DEX et n'est pas signé. Autrement dit, vous ne pouvez pas déployer cet APK sur un appareil. Si vous n'utilisez pas le plug-in Android Gradle pour créer votre application à partir de la ligne de commande , vous pouvez utiliser d'autres outils de ligne de commande, tels que l'utilisation de d8 pour compiler le bytecode Java en bytecode DEX et apksigner pour signer les APK.

syntaxe du lien

La syntaxe générale utilisée link est la suivante :

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

Dans l'exemple suivant, AAPT2 fusionne deux fichiers intermédiaires ( drawable_Image.flat et values_values.arsc.flat) avec le fichier . AndroidManifest.xmlAAPT2 android.jar relie les résultats au fichier contenant les ressources définies dans le package Android :

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

options de lien

Vous pouvez link utiliser les options suivantes avec la commande :

options	illustrer
`-o path`	Spécifie le chemin de sortie de l'APK de la ressource liée. Il s'agit d'un indicateur obligatoire , car vous devez spécifier un chemin vers l'APK de sortie où les ressources liées peuvent être placées.
`--manifest file`	Spécifie le chemin d'accès au fichier manifeste Android à générer. Il s'agit d'un indicateur obligatoire , car le fichier manifeste contient des informations de base sur votre application (telles que le nom du package et l'ID de l'application).
`-I`	Fournit `framework-res.apk`le chemin d'accès au fichier android.jar de la plate-forme ou à d'autres fichiers APK tels que , ce qui peut être utile lors de la création de fonctionnalités. Vous devez utiliser cette balise si vous souhaitez utiliser des attributs avec `android` des espaces de noms (par exemple ) dans les fichiers de ressources .`android:id`
`-A directory`	Spécifie le catalogue de ressources à inclure dans l'APK. Vous pouvez utiliser ce répertoire pour stocker des fichiers bruts non traités. Pour plus d'informations, consultez Accès aux fichiers bruts .
`-R file`	Passez un seul fichier .flat à lier, en utilisant `overlay` la sémantique, pas `<add-resource>` le balisage. Si vous fournissez un fichier de ressources qui chevauche (étend ou modifie) un fichier existant, la dernière ressource en conflit fournie sera utilisée.
`--package-id package-id`	Spécifie l'ID de bundle à utiliser pour l'application. À moins qu'il ne `--allow-reserved-package-id` soit utilisé conjointement avec , vous devez spécifier un ID de bundle supérieur ou égal à 0x7f.
`--allow-reserved-package-id`	Autoriser les ID de bundle réservés. Les ID de bundle réservés sont les ID normalement attribués aux objets partagés, allant de 0x02 à 0x7e (inclus). À l'aide de `--allow-reserved-package-id`, vous pouvez attribuer un ID compris dans la plage d'ID d'ensembles réservés. Cette option n'est disponible que pour les packages avec une version SDK minimale de 26 ou inférieure.
`--java directory`	Spécifie le répertoire dans lequel construire `R.java` .
`--proguard proguard_options`	Générez des fichiers de sortie pour les règles ProGuard.
`--proguard-conditional-keep-rules`	Générez des fichiers de sortie pour les règles ProGuard pour le dex principal.
`--no-auto-version`	Désactivez la gestion automatique des versions du SDK de style et de mise en page.
`--no-version-vectors`	Désactive la gestion automatique des versions des vecteurs dessinables. Cette option n'est disponible que si l'APK a été créé à l'aide de la bibliothèque vectorielle dessinable.
`--no-version-transitions`	Désactiver la gestion automatique des versions des ressources transformées. Cette option n'est disponible que si l'APK a été créé à l'aide de la bibliothèque de prise en charge des transformations.
`--no-resource-deduping`	Désactiver la suppression automatique des ressources en double avec la même valeur dans les configurations compatibles.
`--enable-sparse-encoding`	Permet le codage d'entrées éparses à l'aide d'arbres de recherche binaires. Cela permet d'optimiser la taille de l'APK, mais réduit les performances de récupération des ressources.
`-z`	Nécessite la localisation des chaînes marquées "suggérées".
`-c config`	Fournissez une liste de configurations séparées par des virgules. 例如，如果您依赖于支持库（该支持库包含多种语言的翻译），则可以仅针对给定的语言配置（如英语或西班牙语）过滤资源。您必须使用两个字母的 ISO 639-1 语言代码定义语言配置，后面可选择性地添加两个字母的 ISO 3166-1-alpha-2 区域代码（在区域代码前加上小写的“r”，例如 en-rUS）。
`--preferred-density density`	允许 AAPT2 选择最相符的密度并移除其他所有密度。您可以在应用中使用多种像素密度限定符，如 ldpi、hdpi 和 xhdpi。在您指定首选密度后，AAPT2 会选择最相符的密度并将其存储在资源表中，然后移除其他所有密度。
`--output-to-dir`	将 APK 内容输出到 `-o` 指定的目录中。如果您在使用此标记时遇到任何错误，可以通过升级到 Android SDK Build Tools 28.0.0 或更高版本来解决这些问题。
`--min-sdk-version min-sdk-version`	设置要用于 `AndroidManifest.xml` 的默认最低 SDK 版本。
`--target-sdk-version target-sdk-version`	设置要用于 `AndroidManifest.xml` 的默认目标 SDK 版本。
`--version-code version-code`	指定没有版本代码时要注入 `AndroidManifest.xml` 中的版本代码（整数）。
`--compile-sdk-version-name compile-sdk-version-name`	指定没有版本名称时要注入 `AndroidManifest.xml` 中的版本名称。
`--proto-format`	以 Protobuf 格式生成已编译的资源。适合作为 bundle tool 的输入，用于生成 Android App Bundle。
`--non-final-ids`	使用非最终资源 ID 生成 `R.java`（在 kotlinc/javac 编译期间，系统不会内嵌从应用的代码对这些 ID 的引用）。
`--emit-ids path`	在给定的路径下生成一个文件，该文件包含资源类型的名称及其 ID 映射的列表。它适合与 `--stable-ids` 搭配使用。
`--stable-ids outputfilename.ext`	使用通过 `--emit-ids` 生成的文件，该文件包含资源类型的名称以及为其分配的 ID 的列表。此选项可以让已分配的 ID 保持稳定，即使您在链接时删除了资源或添加了新资源也是如此。
`--custom-package package_name`	指定要在其下生成 `R.java` 的自定义 Java 软件包。
`--extra-packages package_name`	生成相同的 `R.java` 文件，但软件包名称不同。
`--add-javadoc-annotation annotation`	向已生成的所有 Java 类添加 JavaDoc 注释。
`--output-text-symbols path`	生成包含指定文件中 R 类的资源符号的文本文件。您必须指定输出文件的路径。
`--auto-add-overlay`	允许在叠加层中添加新资源，而不使用 `<add-resource>` 标记。
`--rename-manifest-package manifest-package`	重命名 `AndroidManifest.xml` 中的软件包。
`--rename-instrumentation-target-package instrumentation- target-package`	更改插桩的目标软件包的名称。它应与 `--rename-manifest-package` 结合使用。
`-0 extension`	指定您不想压缩的文件的扩展名。
`--split path:config[,config[..]]`	根据一组配置拆分资源，以生成另一个版本的 APK。您必须指定输出 APK 的路径和一组配置。
`-v`	可提高输出的详细程度。

转储

dump 用于输出有关您使用 link 命令生成的 APK 的信息。例如，以下命令的输出结果为所指定 APK 的资源表中的内容：

aapt2 dump resources output.apk

转储语法

使用 dump 的一般语法如下：

aapt2 dump sub-command filename.apk [options]

转储子命令

您需要使用 dump 命令指定以下子命令之一：

子命令	说明
`apc`	输出在编译期间生成的 AAPT2 容器（APC）的内容。
`badging`	输出从 APK 的清单中提取的信息。
`configurations`	输出 APK 中的资源使用的每项配置。
`packagename`	输出 APK 的软件包名称。
`permissions`	输出从 APK 的清单提取的权限。
`strings`	输出 APK 的资源表字符串池的内容。
`styleparents`	输出 APK 中使用的样式的父项。
`resources`	输出 APK 的资源表的内容。
`xmlstrings`	输出 APK 的已编译 xml 中的字符串。
`xmltree`	输出 APK 的已编译 xml 树。

转储选项

您可以将以下选项与 dump 搭配使用：

选项	说明
`--no-values`	禁止在显示资源时输出值。
`--file file`	将文件指定为要从 APK 转储的参数。
`-v`	提高输出的详细程度。

使用 AAPT2 时的行为变化

在 AAPT2 之前，AAPT 是 Android 资源打包工具的默认版本，现在已被弃用。虽然 AAPT2 应该直接就可以处理旧版项目，但本节介绍了一些您应该注意的行为变化。

Android 清单中的元素层次结构

在以前的 AAPT 版本中，嵌套在 Android 清单中的错误节点上的元素会被忽略或引发警告。例如，请参考以下示例：

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

以前的 AAPT 版本直接忽略错误放置的 <action> 标记。但从 AAPT2 开始，会出现以下错误：

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

如需解决该问题，请确保您的清单元素正确嵌套。如需了解详情，请参阅清单文件结构。

资源声明

您无法再从 name 属性中指明资源类型。例如，以下示例未按正确方式声明 attr 资源项目：

<style name="foo" parent="bar">
    <item name="attr/my_attr">@color/pink</item>
</style>

采用这种方式声明资源类型会导致以下构建错误：

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

如需解决此错误，请使用 type="attr" 明确声明资源类型：

<style name="foo" parent="bar">
  <item type="attr" name="my_attr">@color/pink</item>
</style>

此外，在声明 <style> 元素时，其父项也必须为样式资源类型。否则，您将会遇到类似于以下内容的错误：

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

带有 ForegroundLinearLayout 的 Android 命名空间

ForegroundLinearLayout 包含三个属性：foregroundInsidePadding、android:foreground 和 android:foregroundGravity。请注意，与其他两个属性不同，foregroundInsidePadding 未包含在 android 命名空间中。

在以前的 AAPT 版本中，当您使用 android 命名空间定义 foregroundInsidePadding 属性时，编译器会以静默方式忽略该属性。当使用 AAPT2 时，编译器会提前捕获该属性并引发以下编译错误：

Error: (...) resource android:attr/foregroundInsidePadding is private

如需解决此问题，只需将 android:foregroundInsidePadding 替换为 foregroundInsidePadding。

@ 资源引用符号的误用

当您遗漏或错误放置资源引用符号 (@) 时，AAPT2 会抛出构建错误。例如，当您指定样式属性时，请注意是否遗漏了该符号，具体如下所示：

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

在构建模块时，AAPT2 会抛出以下构建错误：

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

此外，当您访问 android 命名空间中的资源时，请注意是否错误地添加了该符号，具体如下所示：

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

在构建模块时，AAPT2 会抛出以下构建错误：

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

库配置不正确

Si votre application dépend de bibliothèques tierces créées avec des versions antérieures des outils de création du SDK Android , votre application peut se bloquer lors de l'exécution sans afficher d'erreurs ni d'avertissements. Ce blocage peut se produire car lors de la création de la bibliothèque, R.java les champs sont déclarés comme tels finalque tous les ID de ressource sont intégrés dans la classe de la bibliothèque.

AAPT2 s'appuie sur la possibilité de réaffecter des ID aux ressources de la bibliothèque lors de la création d'applications. Si la bibliothèque traite ces ID comme final et les intègre dans le dex de la bibliothèque, il y aura une incompatibilité d'exécution.

Pour résoudre cette erreur, veuillez contacter le créateur de la bibliothèque pour reconstruire la bibliothèque avec la dernière version des outils de création du SDK Android et republier la bibliothèque.