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 Visual Studio 2017 e versioni successive specificare l'icona dell'applicazione usando la sezione Manifesto Android delle proprietà del progetto, come illustrato nello screenshot seguente:
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.
In Visual Studio questi valori possono essere impostati nella sezione Manifesto Android delle proprietà del progetto, come illustrato nello screenshot seguente:
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.
Impostare le opzioni del linker nella sezione Opzioni Android delle proprietà del progetto:
Il menu a discesa Collegamento include le seguenti opzioni per il controllo del linker:
Nessuno: questo disattiva il linker. Non verrà eseguito alcun collegamento.
Solo assembly SDK: consente di collegare solo gli assembly richiesti da Xamarin.Android. Gli altri assembly non verranno collegati.
Sdk e assembly utente: consente di collegare tutti gli assembly richiesti dall'applicazione e non solo quelli richiesti da Xamarin.Android.
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.
Importante
Disabilitare sempre lo stato di debug in un'applicazione già rilasciata perché, tramite JDWP, è possibile accedere al processo Java ed eseguire codice arbitrario nel contesto dell'applicazione se lo stato di debug non è disabilitato.
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
Anche con il debug disabilitato, è comunque possibile che gli utenti malintenzionati riescano a creare un nuovo pacchetto di un'applicazione, aggiungendo o rimuovendo opzioni di configurazione o autorizzazioni. Ciò consente di decodificare o manomettere l'applicazione o di eseguirne il debug. Dotfuscator Community Edition (CE) consente di nascondere il codice gestito e inserire il codice di rilevamento dello stato di sicurezza del runtime in un'app Xamarin.Android in fase di compilazione, per rilevare e rispondere nel caso in cui l'app venga eseguita in un dispositivo rooted.
Dotfuscator CE è incluso in Visual Studio 2017. Per usare Dotfuscator, fare clic su Strumenti > PreEmptive Protection - Dotfuscator.
Per configurare Dotfuscator CE, vedere le istruzioni relative all'uso di Dotfuscator Community Edition con Xamarin. Dopo la configurazione, Dotfuscator CE proteggerà automaticamente ogni build creata.
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.
Nota
L'opzione Compilatore ottimizzatore LLVM richiede una licenza Enterprise.
Impostare le proprietà per la creazione di pacchetti
Le proprietà per la creazione di pacchetti possono essere impostate nella sezione Opzioni Android delle proprietà del progetto, come illustrato nello screenshot seguente:
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
Al termine di tutti i passaggi precedenti, l'app è pronta per la compilazione. Selezionare Compila ricompila > soluzione per verificare che la compilazione venga compilata correttamente in modalità rilascio. Si noti che questo passaggio non genera ancora un file APK.
L'articolo sulla firma del pacchetto dell'app descrive le procedure di creazione del pacchetto e di firma più in dettaglio.
Archiviare per la pubblicazione
Per iniziare il processo di pubblicazione, fare clic con il pulsante destro del mouse sul progetto nel riquadro della soluzione e selezionare Archivio... dal menu di scelta rapida:
Archivio... avvia Gestione archivi e inizia il processo di archiviazione del bundle dell'app, come illustrato in questo screenshot:
Un altro modo per creare un archivio è fare clic con il pulsante destro del mouse sulla soluzione nel riquadro della soluzione e selezionare Archivia tutti... per compilare la soluzione e archiviare tutti i progetti Xamarin in grado di generare un archivio:
Sia Archivio che Archivia tutti avviano automaticamente Gestione archivi. Per avviare direttamente Gestione archivi, fare clic sulla voce di menu Strumenti > gestione archivi...
Per visualizzare gli archivi della soluzione, fare clic con il pulsante destro del mouse sul nodo Soluzione e selezionare Visualizza archivi:
Gestione archivi
La funzionalità Gestione archivi è costituita da un elenco di soluzioni, un elenco di archivi e un riquadro dei dettagli:
L'elenco di soluzioni visualizza tutte le soluzioni con almeno un progetto archiviato. L'elenco di soluzioni comprende le seguenti sezioni:
- Soluzione corrente: visualizza la soluzione corrente. Si noti che quest'area può essere vuota se per la soluzione corrente non esiste un archivio.
- Tutti gli archivi : visualizza tutte le soluzioni che dispongono di un archivio.
- Casella di testo di ricerca (nella parte superiore): filtra le soluzioni elencate nell'elenco Tutti gli archivi in base alla stringa di ricerca immessa nella casella di testo.
L'elenco di archivi visualizza l'elenco di tutti gli archivi per la soluzione selezionata. L'elenco di archivi comprende le seguenti sezioni:
- Nome della soluzione selezionata: visualizza il nome della soluzione selezionata nell'elenco soluzioni. Tutte le informazioni visualizzate nell'elenco di archivi fa riferimento a questa soluzione selezionata.
- Filtro piattaforme: questo campo consente di filtrare gli archivi in base al tipo di piattaforma (ad esempio iOS o Android).
- Archivi: elenco di archivi per la soluzione selezionata. Ogni voce di questo elenco include il nome del progetto, la data di creazione e la piattaforma. Può anche visualizzare informazioni aggiuntive, ad esempio lo stato di avanzamento quando una voce viene archiviata o pubblicata.
Il riquadro dei dettagli visualizza informazioni aggiuntive su ogni archivio. Consente inoltre all'utente di avviare il flusso di lavoro di distribuzione o aprire la cartella in cui è stata creata la distribuzione. La sezione Commenti per la build consente di includere commenti sulla compilazione nell'archivio.
Distribuzione
Quando una versione archiviata dell'applicazione è pronta per la pubblicazione, selezionare l'archivio in Gestione archivi e fare clic sul pulsante Distribuisci...:
La finestra di dialogo Canale di distribuzione visualizza informazioni sull'app, un'indicazione dell'avanzamento del flusso di lavoro di distribuzione e una selezione di canali di distribuzione. Alla prima esecuzione vengono visualizzate due opzioni:
È possibile scegliere uno dei seguenti canali di distribuzione:
Ad hoc : salva un APK firmato su disco che può essere trasferita localmente nei dispositivi Android. Passare alla sezione relativa alla firma del pacchetto dell'app per sapere come creare un'identità di firma di Android, creare un nuovo certificato di firma per le applicazioni Android e pubblicare una versione ad hoc nel disco. Questo è un buon metodo per creare un file APK per il test.
Google Play : pubblica un APK firmato in Google Play. Vedere la sezione relativa alla pubblicazione in Google Play per informazioni su come firmare e pubblicare un file APK in Google Play Store.
