Compilazione di APK specifici di ABI

Questo documento illustra come compilare un file APK destinato a un singolo ABI usando Xamarin.Android.

Panoramica

In alcune situazioni può risultare utile per un'applicazione avere più APK. Ogni APK è firmato con lo stesso archivio chiavi e condivide lo stesso nome di pacchetto, ma viene compilato per una configurazione di Android o un dispositivo specifico. Questo non è l'approccio consigliato: è molto più semplice avere un solo file APK che può supportare più dispositivi e configurazioni. Esistono alcune situazioni in cui la creazione di più APK può essere utile, ad esempio:

• Ridurre le dimensioni dell'APK: Google Play impone un limite di 100 MB per le dimensioni dei file APK. Creando APK specifici dei dispositivi, è possibile ridurre le dimensioni del file APK perché è necessario specificare solo un subset di asset e risorse per l'applicazione.

• Supportare architetture CPU diverse: se l'applicazione ha librerie condivise per CPU specifiche, è possibile distribuire solo le librerie condivise per tali CPU.

Più APK possono complicare la distribuzione, ma questo problema viene risolto da Google Play. Google Play verificherà che a un dispositivo venga distribuito l'APK corretto in base al codice della versione dell'applicazione e ad altri metadati contenuti in AndroidManifest.XML. Per informazioni dettagliate specifiche e per conoscere le restrizioni al supporto di più APK per un'applicazione in Google Play, vedere la documentazione di Google sul supporto di più APK.

Questa guida illustra come creare lo script di compilazione di più APK per un'applicazione Xamarin.Android e come fare in modo che ogni APK specifichi come destinazione un determinato ABI. Verranno illustrati gli argomenti seguenti:

1. Creare un codice versione univoco per l'APK.
2. Creare una versione temporanea di AndroidManifest.XML che verrà usata per questo APK.
3. Compilare l'applicazione usando il file AndroidManifest.XML del passaggio precedente.
4. Preparare l'APK per il rilascio firmandolo e allineandolo con zipalign.

Alla fine di questa guida è disponibile una procedura dettagliata che illustra come creare lo script di questi passaggi usando Rake.

Creazione del codice versione per l'APK

Google consiglia un particolare algoritmo che usa un codice versione a sette cifre. Vedere la sezione Using a version code scheme (Uso di uno schema di codice versione) nel documento Multiple APK support (Supporto di più APK). Espandendo a otto cifre questo schema del codice versione, è possibile includere nel codice versione alcune informazioni sull'ABI che garantiranno che Google Play distribuisca il file APK corretto in un dispositivo. L'elenco seguente illustra questo formato del codice versione a otto cifre (indicizzato da sinistra a destra):

• Indice 0 (rosso nel diagramma seguente): numero intero per l'ABI:

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

• Indice 1-2 (arancione nel diagramma seguente): livello API minimo supportato dall'applicazione.

• Indice 3-4 (blu nel diagramma seguente): dimensioni dello schermo supportate:

  • 1 – piccolo
  • 2 – normale
  • 3 – grande
  • 4 – xlarge

• Indice 5-7 (verde nel diagramma seguente): numero univoco per il codice della versione. È impostato dallo sviluppatore. Deve aumentare per ogni versione pubblica dell'applicazione.

Il diagramma seguente illustra la posizione di ogni codice descritto nell'elenco precedente:

Google Play verificherà che al dispositivo venga distribuito l'APK corretto in base a versionCode e alla configurazione dell'APK. Il file APK con il codice versione più alto verrà distribuito al dispositivo. Ad esempio, un'applicazione può includere tre APK con i codici versione seguenti:

• 11413456 - L'interfaccia ABI è , la destinazione è armeabi il livello API 14, schermi piccoli e grandi, con un numero di versione pari a 456.
• 21423456 - L'ABI è armeabi-v7a ; destinazione del livello API 14; schermi normali e grandi; con un numero di versione pari a 456.
• 61423456 - L'ABI è x86 ; destinazione api livello 14; schermi normali e grandi; con un numero di versione pari a 456.

Per continuare con questo esempio, si supponga che sia stato corretto un bug specifico di armeabi-v7a. La versione dell'app aumenta a 457 e viene compilato un nuovo APK con android:versionCode impostato su 21423457. I codici per le versioni armeabi e x86 rimarranno gli stessi.

Si supponga ora che la versione x86 riceva alcuni aggiornamenti o correzioni destinate a un'API più recente (API livello 19) e che quindi la versione dell'app sia 500. Il nuovo versionCode diventerà 61923500 mentre armeabi/armeabi-v7a rimangono invariati. A questo punto, i codici versione saranno:

• 11413456 - L'interfaccia ABI è , la destinazione è armeabi il livello API 14; schermi di piccole e grandi dimensioni, con un nome di versione 456.
• 21423457 - L'ABI è armeabi-v7a ; destinazione del livello API 14; schermi normali e grandi; con un nome di versione 457.
• 61923500 - L'ABI è x86 ; destinazione del livello API 19; schermi normali e grandi; con un nome di versione 500.

La gestione manuale di questi codici versione può comportare un carico notevole per lo sviluppatore. Il processo per calcolare l'elemento android:versionCode corretto e quindi compilare gli APK dovrebbe essere automatizzato. Un esempio di come eseguire questa operazione verrà descritto nella procedura dettagliata alla fine di questo documento.

Creare un file AndroidManifest.XML temporaneo

Anche se non strettamente necessaria, la creazione di un file AndroidManifest.XML temporaneo per ogni ABI consente di evitare problemi che potrebbero verificarsi con le informazioni che passano da un APK all'altro. È ad esempio fondamentale che l'attributo android:versionCode sia univoco per ogni APK.

La procedura dipende dal sistema di scripting coinvolto, ma in genere è necessario aprire una copia del manifesto Android usata durante lo sviluppo, modificarla e quindi usare tale manifesto modificato durante il processo di compilazione.

Compilazione dell'APK

Il modo migliore per compilare l'APK per ogni ABI consiste nell'usare xbuild o msbuild, come illustrato nella riga di comando di esempio seguente:

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

L'elenco seguente descrive ogni parametro della riga di comando:

• /t:Package : crea un APK Android firmato usando l'archivio chiavi di debug

• /p:AndroidSupportedAbis=<TARGET_ABI> : questa interfaccia ABI da usare come destinazione. Deve essere armeabi, armeabi-v7a o x86

• /p:IntermediateOutputPath=obj.<TARGET_ABI>/ : si tratta della directory che conterrà i file intermedi creati come parte della compilazione. Se necessario, Xamarin.Android creerà una directory denominata in base all'ABI, ad esempio obj.armeabi-v7a. È consigliabile usare una cartella per ogni ABI, per evitare problemi che causano il passaggio dei file da una compilazione a un'altra. Si noti che questo valore termina con un separatore di directory (/ nel caso di OS X).

• /p:AndroidManifest : questa proprietà specifica il percorso del file AndroidManifest.XML che verrà usato durante la compilazione.

• /p:OutputPath=bin.<TARGET_ABI> : questa è la directory che ospita l'APK finale. Xamarin.Android creerà una directory denominata in base all'ABI, ad esempio bin.armeabi-v7a.

• /p:Configuration=Release : eseguire una build di rilascio dell'APK. Le build Debug potrebbero non essere caricate in Google Play.

• <CS_PROJ FILE> : percorso del .csproj file per il progetto Xamarin.Android.

Firmare ed eseguire Zipalign per il file APK

È necessario firmare il file APK prima che possa essere distribuito tramite Google Play. A questo scopo, è possibile usare l'applicazione jarsigner che fa parte del kit dello sviluppatore Java. La riga di comando seguente illustra come usare jarsigner nella riga di comando:

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>

Tutte le applicazioni Xamarin.Android devono essere allineate con zipaling prima di poter essere eseguite in un dispositivo. Questo è il formato della riga di comando da usare:

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

Automazione della creazione di file APK con Rake

Il progetto di esempio OneABIPerAPK è un semplice progetto Android che illustra come calcolare un numero di versione specifico di un ABI e compilare tre APK distinti per ognuno degli ABI seguenti:

• armeabi
• armeabi-v7a
• x86

Il rakefile nel progetto di esempio esegue ogni passaggio descritto nelle sezioni precedenti:

1. Creare un elemento android:versionCode per l'APK.

2. Scrivere l'elemento android:versionCode in un file AndroidManifest.XML personalizzato per tale APK.

3. Compilare una build di rilascio del progetto Xamarin.Android che specificherà come singola destinazione l'ABI e userà il file AndroidManifest.XML creato nel passaggio precedente.

4. Firmare l'APK con un archivio chiavi di produzione.

5. Eseguire Zipalign per il file APK.

Per compilare tutti gli APK per l'applicazione, eseguire l'attività di Rake build dalla riga di comando:

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

Al termine dell'attività di Rake, saranno disponibili tre cartelle bin con il file xamarin.helloworld.apk. Lo screenshot seguente illustra ognuna di queste cartelle con il relativo contenuto:

Nota

Il processo di compilazione illustrato in questa guida può essere implementato in uno dei numerosi sistemi di compilazione. Anche se non è disponibile un esempio già scritto, dovrebbe essere possibile eseguirlo anche con Powershell / psake o Fake.

Riepilogo

Questa guida ha fornito alcuni suggerimenti su come creare APK Android per un ABI specifico. Ha anche illustrato un possibile schema per la creazione di android:versionCodes che identificheranno l'architettura CPU a cui è destinato l'APK. Nella procedura dettagliata è stato incluso un progetto per la compilazione del quale è stato creato uno script con Rake.

Collegamenti correlati

• Publishing an Application (Pubblicazione di un'applicazione)
• Multiple APK Support for Google Play (Supporto di più APK per Google Play)