Création de fichiers APK propres à une interface ABI

  • Article

Ce document explique comment générer un fichier APK qui ciblera une interface ABI unique à l’aide de Xamarin.Android.

Vue d’ensemble

Dans certaines situations, il peut être avantageux pour une application d’avoir plusieurs fichiers APK. Chaque fichier APK est signé avec le même magasin de clés et porte le même nom de package, mais est compilé pour une configuration d’appareil ou Android spécifique. Ce n’est pas l’approche recommandée. Il est beaucoup plus simple d’avoir un fichier APK pouvant prendre en charge plusieurs appareils et configurations. Dans certaines situations, la création de plusieurs fichiers APK peut être utile, par exemple :

  • Réduire la taille du fichier APK : Google Play impose une limite de taille de 100 Mo pour les fichiers APK. La création de fichiers APK spécifiques peut réduire la taille du fichier APK, puisqu’il vous suffit d’indiquer un sous-ensemble des ressources et des ressources pour l’application.

  • Prendre en charge différentes architectures de processeur : Si votre application a partagé des bibliothèques pour des processeurs spécifiques, vous ne pouvez distribuer que les bibliothèques partagées pour ce processeur.

Plusieurs fichiers APK peuvent compliquer la distribution – un problème résolu par Google Play. Google Play garantit que le fichier APK correct est remis à un appareil basé sur le code de la version de l’application et sur d’autres métadonnées contenues dans AndroidManifest.XML. Pour des détails et restrictions spécifiques sur la façon dont Google Play prend en charge plusieurs fichiers APK pour une application, consultez la documentation de Google sur la prise en charge de plusieurs fichiers APK.

Ce guide explique comment générer un script pour générer plusieurs fichiers APK pour une application Xamarin.Android, chaque fichier APK ciblant une interface ABI spécifique. Il traitera les thèmes suivants :

  1. Créer un code de version unique pour le fichier APK.
  2. Créer une version temporaire d’AndroidManifest.XML qui sera utilisée pour ce fichier APK.
  3. Générer l’application à l’aide d’AndroidManifest.XML à partir de l’étape précédente.
  4. Préparer le fichier APK à la mise en production en le signant en effectuant un alignement zip.

À la fin de ce guide, vous trouverez une procédure pas à pas qui illustre comment générer un script pour ces étapes à l’aide de Rake.

Création du code de version pour le fichier APK

Pour le code de version, Google recommande un algorithme particulier qui utilise un code de version à sept chiffres (consultez la section Using a version code scheme (en anglais) dans Multiple APK support document (en anglais). L’extension de ce modèle de code de version à huit chiffres permet d’inclure des informations sur l’interface ABI dans le code de version, afin de garantir que Google Play distribuera le fichier APK correct à un appareil. La liste suivante explique ce format de code de version à huit chiffres (indexée de gauche à droite) :

  • Index 0 (rouge dans le diagramme ci-dessous) : entier pour l’ABI :

    • 1 – armeabi
    • 2 – armeabi-v7a
    • 6 – x86

  • Index 1-2 (orange dans le diagramme ci-dessous) : niveau d’API minimal pris en charge par l’application.

  • Index 3-4 (bleu dans le diagramme ci-dessous) : tailles d’écran prises en charge :

    • 1 – petit
    • 2 – normal
    • 3 - grand
    • 4 – xlarge

  • Index 5-7 (vert dans le diagramme ci-dessous) : numéro unique pour le code de version. La version est définie par le développeur. Elle doit augmenter pour chaque version publique de l’application.

Le diagramme suivant illustre la position de chaque code décrit dans la liste ci-dessus :

Diagramme du format de code de version à huit chiffres, codé par couleur

Google Play garantit que le fichier APK correct est remis à l’appareil en fonction du versionCode et de la configuration du fichier APK. Le fichier APK avec le code de version le plus élevé sera remis à l’appareil. Par exemple, une application peut avoir trois fichiers APK avec les codes de version suivants :

  • 11413456 - L’ABI est armeabi ; cibler le niveau d’API 14 ; petit à grand écran ; avec un numéro de version de 456.
  • 21423456 - L’ABI est armeabi-v7a ; cible le niveau d’API 14 ; normal et les grands écrans ; avec un numéro de version de 456.
  • 61423456 - L’ABI est x86 ; cible le niveau d’API 14 ; normal et les grands écrans ; avec un numéro de version de 456.

Pour continuer sur cet exemple, imaginez qu’un bogue spécifique à armeabi-v7a a été résolu. La version de l’application passe à 457, et un nouveau fichier APK est généré avec le android:versionCode défini sur 21423457. Le code de version versionCodes pour les versions armeabi et x86 resterait le même.

Imaginez maintenant que la version x86 reçoive des mises à jour ou des correctifs qui ciblent une interface API plus récente (Niveau d’API 19), menant à la version 500 de l’application. Le nouveau versionCode passerait alors à 61923500, tandis qu’armeabi/armeabi-v7a resterait inchangé. À ce stade, les codes de version seraient les suivants :

  • 11413456 - L’ABI est armeabi ; cible le niveau d’API 14 ; petit à grand écran ; avec un nom de version de 456.
  • 21423457 - L’ABI est armeabi-v7a ; cible le niveau d’API 14 ; normal et les grands écrans ; avec un nom de version de 457.
  • 61923500 - L’ABI est x86 ; cible le niveau d’API 19 ; normal et les grands écrans ; avec un nom de version de 500.

La gestion manuelle de ces codes de version peut être une charge considérable pour le développeur. Le processus de calcul du android:versionCode correct et la génération des fichiers APK devraient être automatisés. Un exemple de procédure à suivre est abordé dans la procédure pas à pas à la fin de ce document.

Créer un fichier AndroidManifest.XML temporaire

Bien que ce ne soit pas impérativement nécessaire, la création d’un fichier AndroidManifest.XML temporaire pour chaque interface ABI peut aider à éviter des problèmes susceptibles de survenir en cas de fuite d’informations d’un fichier APK vers l’autre. Par exemple, il est essentiel que l’attribut android:versionCode soit unique pour chaque fichier APK.

La manière de procéder dépend du système de scripts impliqué, mais implique généralement de prendre une copie du manifeste Android utilisé pendant le développement, de la modifier, puis d’utiliser ce manifeste modifié pendant le processus de génération.

Compilation du fichier APK

La meilleure façon de générer le fichier APK par le biais de l’interface ABI est d’utiliser xbuild ou msbuild, comme indiqué dans l’exemple de ligne de commande suivant :

/Library/Frameworks/Mono.framework/Commands/xbuild /t:Package /p:AndroidSupportedAbis=<TARGET_ABI> /p:IntermediateOutputPath=obj.<TARGET_ABI>/ /p:AndroidManifest=<PATH_TO_ANDROIDMANIFEST.XML> /p:OutputPath=bin.<TARGET_ABI> /p:Configuration=Release <CSPROJ FILE>

la liste suivante explique chaque paramètre de ligne de commande :

  • /t:Package : crée un APK Android signé à l’aide du magasin de clés de débogage

  • /p:AndroidSupportedAbis=<TARGET_ABI> – Il s’agit de l’ABI à cibler. Cela doit être l’une des interfaces armeabi, armeabi-v7a ou x86.

  • /p:IntermediateOutputPath=obj.<TARGET_ABI>/ : il s’agit du répertoire qui contiendra les fichiers intermédiaires créés dans le cadre de la build. Si nécessaire, Xamarin.Android créera un répertoire nommé d’après l’interface ABI, par exemple obj.armeabi-v7a. Il est recommandé d’utiliser un dossier pour chaque interface ABI, car ceci empêchera des problèmes pouvant entraîner la « fuite » d’une version vers une autre. Notez que cette valeur se termine par un séparateur de répertoire (un / dans le cas d’OS X).

  • /p:AndroidManifest : cette propriété spécifie le chemin d’accès au fichier AndroidManifest.XML qui sera utilisé pendant la build.

  • /p:OutputPath=bin.<TARGET_ABI> - Il s’agit du répertoire qui hébergera l’APK final. Xamarin.Android créera un répertoire nommé d’après l’interface ABI, par exemple bin.armeabi-v7a.

  • /p:Configuration=Release : effectuez une build Release de l’APK. Il n’est pas possible de télécharger des versions de débogage vers Google Play.

  • <CS_PROJ FILE> : chemin d’accès au .csproj fichier du projet Xamarin.Android.

Signer le fichier APK et le compresser dans un fichier Zipalign

Le fichier APK doit être signé avant de pouvoir être distribué via Google Play. Ceci peut se faire à l’aide de l’application jarsigner, qui fait partie du Kit du développeur Java. La ligne de commande suivante montre comment utiliser jarsigner dans la ligne de commande :

jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore <PATH/TO/KEYSTORE> -storepass <PASSWORD> -signedjar <PATH/FOR/SIGNED_JAR> <PATH/FOR/JAR/TO/SIGN> <NAME_OF_KEY_IN_KEYSTORE>

toutes les applications Xamarin.Android doivent faire l’objet d’un alignement zip avant de pouvoir être exécutées sur un appareil. Voici le format de ligne de commande à utiliser :

zipalign -f -v 4 <SIGNED_APK_TO_ZIPALIGN> <PATH/TO/ZIP_ALIGNED.APK>

automatisation de la création d’un fichier APK avec Rake

L’exemple de projet OneABIPerAPK est un projet Android simple qui va montrer comment calculer un numéro de version d’ABI spécifique et générer trois fichiers APK distincts pour chacune des ABI suivants :

  • armeabi
  • armeabi-v7a
  • x86

Le fichier rakefile dans l’exemple de projet effectue chacune des étapes décrites dans les sections précédentes :

  1. Créez un code de version android:versionCode pour le fichier APK.

  2. Écrivez le code de version android:versionCode pour un fichier AndroidManifest.XML personnalisé de ce fichier APK.

  3. Compilez une version de mise en production du projet Xamarin.Android qui ciblera uniquement l’interface ABI à l’aide du fichier AndroidManifest.XML créé à l’étape précédente.

  4. Signez le fichier APK avec un magasin de clés de production.

  5. Compressez le fichier APK dans un fichier Zipalign.

Pour générer tous les fichiers APK de l’application, exécutez la tâche Rake build à partir de la ligne de commande :

$ rake build
==> Building an APK for ABI armeabi with ./Properties/AndroidManifest.xml.armeabi, android:versionCode = 10814120.
==> Building an APK for ABI x86 with ./Properties/AndroidManifest.xml.x86, android:versionCode = 60814120.
==> Building an APK for ABI armeabi-v7a with ./Properties/AndroidManifest.xml.armeabi-v7a, android:versionCode = 20814120.

une fois la tâche Rake terminée, il y aura trois dossiers bin avec le fichier xamarin.helloworld.apk. La capture d’écran suivante montre chacun de ces dossiers avec son contenu :

Emplacements des dossiers spécifiques à une plateforme contenant xamarin.helloworld.apk

Remarque

Le processus de génération décrit dans ce guide peut être implémenté dans un des nombreux systèmes de build différents. Bien que nous n’ayons pas d’exemple prédéfini, ceci devrait également être possible avec Powershell / psake ou fictif.

Résumé

Ce guide contient quelques suggestions pour la création de fichiers APK Android qui ciblent une interface ABI spécifique. Il présente également un schéma possible pour la création du android:versionCodes qui identifiera l’architecture de processeur à laquelle le fichier APK est destiné. La procédure pas à pas inclut un exemple de projet dont le script de build est généré avec Rake.