Preparazione di un'applicazione per il rilascio

Dopo aver scritto il codice di un'applicazione e averla testata, è necessario preparare il pacchetto per la distribuzione. La prima attività di preparazione del pacchetto è la compilazione dell'applicazione per il rilascio, che essenzialmente comporta l'impostazione di alcuni attributi dell'applicazione.

Usare la procedura seguente per compilare l'app per il rilascio:

• Specificare l'icona dell'applicazione: ogni applicazione Xamarin.Android deve avere un'icona dell'applicazione specificata. Anche se tecnicamente non è necessaria, alcuni mercati, ad esempio Google Play, la richiedono.

• Versione dell'applicazione: questo passaggio comporta l'inizializzazione o l'aggiornamento delle informazioni sul controllo delle versioni. Questo è importante per gli aggiornamenti futuri dell'applicazione e per verificare che gli utenti siano informati riguardo alla versione dell'applicazione installata.

• Compattare l'APK : le dimensioni dell'APK finale possono essere notevolmente ridotte usando il linker Xamarin.Android nel codice gestito e ProGuard nel bytecode Java.

• Proteggere l'applicazione : impedire agli utenti o agli utenti malintenzionati di eseguire debug, manomissioni o reverse engineering dell'applicazione disabilitando il debug, offuscando il codice gestito, aggiungendo anti-debug e antimanomissione e usando la compilazione nativa.

• Imposta proprietà creazione pacchetti : le proprietà di creazione dei pacchetti controllano la creazione del pacchetto dell'applicazione Android (APK). Questo passaggio consente di ottimizzare l'APK, di proteggerne gli asset e personalizzare il pacchetto in base alle esigenze. Inoltre, è possibile fornire agli utenti un bundle di app Android ottimizzato per i propri dispositivi.

• Compilazione : questo passaggio compila il codice e gli asset per verificare che venga compilata in modalità rilascio.

• Archivio per la pubblicazione : questo passaggio compila l'app e la inserisce in un archivio per la firma e la pubblicazione.

Ognuno di questi passaggi è descritto in dettaglio di seguito.

Specificare l'icona dell'applicazione

È consigliabile che ogni applicazione Xamarin.Android specifichi un'icona dell'applicazione. Alcuni marketplace di applicazioni non consentono che un'applicazione Android venga pubblicata senza la relativa icona. La proprietà Icon dell'attributo Application viene usata per specificare l'icona dell'applicazione per un progetto Xamarin.Android.

In questi esempi, @drawable/icon fa riferimento a un file di icona disponibile in Resources/drawable/icon.png (si noti che l'estensione png non è inclusa nel nome di risorsa). L'attributo può anche essere dichiarato nel file Properties\AssemblyInfo.cs, come illustrato nel frammento di esempio seguente:

[assembly: Application(Icon = "@drawable/icon")]

In genere, using Android.App viene dichiarato all'inizio di AssemblyInfo.cs (lo spazio dei nomi dell'attributo Application è Android.App). Tuttavia, potrebbe essere necessario aggiungere l'istruzione using se non è già presente.

Specificare la versione dell'applicazione

Il controllo delle versioni è importante per la distribuzione e la manutenzione delle applicazioni Android. Senza una qualche forma di controllo delle versioni, è difficile determinare se e come un'applicazione debba essere aggiornata. Per facilitare il controllo delle versioni, Android riconosce due tipi diversi di informazioni:

• Numero di versione: valore intero (usato internamente da Android e dall'applicazione) che rappresenta la versione dell'applicazione. La maggior parte delle applicazioni all'inizio hanno questo valore impostato su 1, che si incrementa a ogni compilazione. Tale valore non ha alcuna relazione o affinità con l'attributo del nome di versione (vedere sotto). Applicazioni e servizi di pubblicazione non devono rendere visualizzabile il valore agli utenti. Questo valore viene archiviato nel file AndroidManifest.xml come android:versionCode.

• Nome versione: stringa usata solo per comunicare informazioni all'utente sulla versione dell'applicazione (come installato in un dispositivo specifico). Il nome della versione deve essere visualizzato agli utenti o in Google Play. Questa stringa non viene usata internamente da Android. Il nome della versione può essere qualsiasi valore stringa che consenta a un utente di identificare la build installata nel dispositivo. Questo valore viene archiviato nel file AndroidManifest.xml come android:versionName.

Compattare il file APK

Le dimensioni dei file APK di Xamarin.Android possono essere ridotte usando una combinazione del linker di Xamarin.Android, che rimuove il codice gestito non necessario, con lo strumento ProGuard dell'SDK di Android, che rimuove il bytecode Java non in uso. Il processo di compilazione usa in primo luogo il linker di Xamarin.Android per ottimizzare l'app a livello di codice gestito (C#) e in un secondo momento usa ProGuard, se è abilitato, per ottimizzare l'APK a livello di bytecode Java.

Configurare il linker

La modalità di rilascio disattiva il runtime condiviso e attiva il collegamento in modo che l'applicazione usi solo le parti di Xamarin.Android necessarie in fase di runtime. Il linker in Xamarin.Android usa l'analisi statica per determinare quali assembly, tipi e membri di tipo vengono usati o a cui viene fatto riferimento da un'applicazione Xamarin.Android. Il linker elimina quindi tutti gli assembly, i tipi e i membri inutilizzati o a cui non si fa riferimento. Ciò può comportare una riduzione significativa delle dimensioni del pacchetto. Si consideri l'esempio HelloWorld per cui si verifica una riduzione dell'83% delle dimensioni finali dell'APK:

• Configurazione: Nessuno : Xamarin.Android 4.2.5 Size = 17,4 MB.

• Configurazione: solo assembly SDK - Dimensioni Xamarin.Android 4.2.5 = 3,0 MB.

Il collegamento può produrre alcuni effetti collaterali imprevisti, quindi è importante che un'applicazione venga di nuovo testata in modalità di rilascio in un dispositivo fisico.

ProGuard

ProGuard è uno strumento Android SDK che si collega al codice Java e consente di offuscarlo. ProGuard viene in genere usato per creare applicazioni più piccole, riducendo la superficie delle raccolte di grandi dimensioni incluse, come ad esempio Google Play Services, nell'APK. ProGuard rimuove i bytecode Java inutilizzati, riducendo le dimensioni dell'app risultante. Ad esempio, l'uso di ProGuard in app Xamarin.Android di piccole dimensioni raggiunge in genere circa il 24% di riduzione delle dimensioni, usando ProGuard in app di dimensioni maggiori con più dipendenze della libreria in genere ottiene una riduzione delle dimensioni ancora maggiore.

ProGuard non è un'alternativa al linker di Xamarin.Android. Il linker di Xamarin.Android collega il codice gestito, mentre ProGuard collega il bytecode Java. Il processo di compilazione usa in primo luogo il linker di Xamarin.Android per ottimizzare il codice (C#) gestito nell'app e in un secondo momento usa ProGuard, se è abilitato, per ottimizzare l'APK a livello di bytecode Java.

Quando l'opzione Abilita ProGuard è selezionata, Xamarin.Android esegue lo strumento ProGuard sull'APK risultante. Viene generato un file di configurazione ProGuard che ProGuard usa in fase di compilazione. Xamarin.Android supporta anche azioni di compilazione ProguardConfiguration personalizzate. È possibile aggiungere un file di configurazione ProGuard personalizzato al progetto, fare clic con il pulsante destro del mouse sul file e selezionarlo come un'azione di compilazione come illustrato nell'esempio seguente:

ProGuard è disabilitato per impostazione predefinita. L'opzione Abilita ProGuard è disponibile solo quando il progetto è impostato sulla modalità Release (Rilascio). Tutte le azioni di compilazione ProGuard vengono ignorate a meno che l'opzione Abilita ProGuard non sia selezionata. La configurazione ProGuard di Xamarin.Android non offusca l'APK e non è possibile abilitare l'offuscamento, neanche con i file di configurazione personalizzati. Se si vuole usare l'offuscamento, vedere Protezione dell'applicazione con Dotfuscator.

Per informazioni più dettagliate sull'uso dello strumento ProGuard, vedere ProGuard.

Proteggere l'applicazione

Disabilitare il debug

Durante lo sviluppo di un'applicazione Android, il debug viene eseguito con Java Debug Wire Protocol (JDWP). Si tratta di una tecnologia che consente agli strumenti come adb di comunicare con JVM a fini di debug. JDWP è attivato per impostazione predefinita per le compilazioni di debug delle applicazioni Xamarin.Android. JDWP è importante durante lo sviluppo, ma può rappresentare un problema per la sicurezza per le applicazioni già rilasciate.

Il Manifesto Android contiene l'attributo android:debuggable, che controlla se l'applicazione può essere sottoposta a debug. È opportuno impostare l'attributo android:debuggable su false. Il modo più semplice per eseguire questa operazione è aggiungere un'istruzione di compilazione condizionale in AssemblyInfo.cs:

#if DEBUG
[assembly: Application(Debuggable=true)]
#else
[assembly: Application(Debuggable=false)]
#endif

Si noti che le compilazioni di debug impostano automaticamente alcune autorizzazioni per semplificare l'esecuzione del debug, ad esempio Internet e ReadExternalStorage. Le compilazioni di rilascio, tuttavia, usano solo le autorizzazioni configurate in modo esplicito. Se si ritiene che il passaggio a una compilazione di rilascio comporti la perdita nell'app di un'autorizzazione che era disponibile nella compilazione di debug, verificare che tale autorizzazione sia stata attivata in modo esplicito nell'elenco Autorizzazioni necessarie come descritto in Permissions (Autorizzazioni).

Protezione dell'applicazione con Dotfuscator

Crea un bundle di assembly nel codice nativo

Quando questa opzione è abilitata, gli assembly vengono aggregati in una raccolta condivisa nativa. In questo modo gli assembly possono essere compressi, consentendo file più piccoli .apk . La compressione dell'assembly conferisce anche una forma minima di offuscamento; tale offuscamento non deve essere considerato attendibile.

Questa opzione richiede una licenza Enterprise ed è disponibile solo quando l'opzione Usa Fast Deployment è disabilitata. L'opzione Crea un bundle di assembly nel codice nativo è disabilitata per impostazione predefinita.

Si noti che l'opzione Crea un bundle di assembly nel codice nativonon significa che gli assembly vengono compilati in codice nativo. Non è possibile usare la compilazione AOT per compilare assembly in codice nativo.

Compilazione AOT

L'opzione Compilazione AOT nella pagina Proprietà per creazione pacchetto consente la compilazione di assembly AOT (Ahead Of Time). Quando questa opzione è abilitata, viene ridotto il sovraccarico all'avvio di JIT mediante la precompilazione degli assembly prima del runtime. Il codice nativo risultante e gli assembly non compilati vengono inclusi nell'APK. Questo consente tempi di avvio dell'applicazione ridotti ma a scapito di dimensioni dell'APK leggermente superiori.

L'opzione Compilazione AOT richiede una licenza Enterprise o superiore. L'opzione Compilazione AOT è disponibile solo quando il progetto è configurato per la modalità di rilascio, ed è disabilitata per impostazione predefinita. Per altre informazioni sulla compilazione AOT, vedere AOT.

Compilatore ottimizzatore LLVM

Il Compilatore ottimizzatore LLVM crea codice compilato più rapido e di dimensioni minori e converte gli assembly compilati con AOT in codice nativo, ma a scapito di tempi di compilazione più lunghi. Il compilatore LLVM è disabilitato per impostazione predefinita. Per usare il compilatore LLVM, è necessario per prima cosa abilitare l'opzione Compilazione AOT nella pagina Proprietà per creazione pacchetto.

Impostare le proprietà per la creazione di pacchetti

Molte di queste proprietà, ad esempio Usa runtime condiviso e Usa Fast Deployment sono destinate alla modalità di debug. Tuttavia, quando l'applicazione è configurata per la modalità di rilascio, esistono altre impostazioni che determinano il modo in cui l'app viene ottimizzata in termini di dimensioni e velocità di esecuzione, è protetta da eventuali manomissioni e può essere inserita in un pacchetto per supportare diverse architetture e limitazioni di dimensione.

Specificare le architetture supportate

Quando si prepara un'app Xamarin.Android per il rilascio, è necessario specificare le architetture della CPU supportate. Un singolo APK può contenere codice macchina per supportare più architetture diverse. Vedere Architetture CPU per informazioni dettagliate sul supporto di più architetture della CPU.

Generare un pacchetto (file APK) per ogni ABI selezionato

Quando questa opzione è abilitata, viene creato un APK per ogni ABI supportato, selezionato nella scheda Avanzate, come descritto in Architetture CPU, anziché un singolo APK di grandi dimensioni per tutti gli ABI supportati. L'opzione è disponibile solo quando il progetto è configurato per la modalità di rilascio, ed è disabilitata per impostazione predefinita.

Multidex

Quando l'opzione Abilita multidex è abilitata, vengono usati gli strumenti Android SDK per ignorare il limite dei 65.000 metodi presente nel formato di file DEX. La limitazione del metodo 65K si basa sul numero di metodi Java a cui fa riferimento un'app (incluse quelle in tutte le librerie da cui dipende l'app) e non si basa sul numero di metodi scritti nel codice sorgente. Se un'applicazione definisce solo pochi metodi ma ne usa molti, o usa raccolte di grandi dimensioni, è possibile che il limite di 65.000 venga superato.

È possibile che un'app non usi tutti i metodi in tutte le raccolte cui fa riferimento, quindi è possibile che uno strumento come ProGuard (vedere sopra) possa rimuovere i metodi non usati dal codice. La procedura consigliata consiste nell'abilitare Abilita multidex solo se assolutamente necessario, ovvero se l'app fa riferimento a più di 65.000 metodi Java anche dopo l'uso di ProGuard.

Per altre informazioni su multidex, vedere Configurare le app con più di 64.000 metodi.

Bundle di app Android

I bundle di app differiscono dalle API perché non possono essere distribuiti direttamente in un dispositivo. È invece un formato che deve essere caricato con tutto il codice e le risorse compilati. Dopo aver caricato il bundle dell'app firmato, Google Play avrà tutto il necessario per compilare e firmare gli SDK dell'applicazione e usarli per gli utenti usando il recapito dinamico.

Per abilitare il supporto per i bundle di app Android, è necessario acconsentire esplicitamente al bundle valore della proprietà Formato pacchetto Android all'interno delle opzioni del progetto Android. Prima di eseguire questa operazione, assicurarsi di modificare il progetto in una Release configurazione perché i bundle di app sono destinati solo ai pacchetti di versione.

È ora possibile generare un bundle di app seguendo il flusso di archiviazione. Verrà generato un bundle di app per l'applicazione.

Per altre informazioni sui bundle di app Android, vedere Bundle di app Android.

Compile

Archiviare per la pubblicazione

Collegamenti correlati

• Dispositivi multi-core e Xamarin.Android
• Architetture CPU
• AOT
• Compattare il codice e le risorse
• Configurare le app con più di 64.000 metodi