Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Dopo che un'applicazione è stata codificata e testata, è necessario preparare un pacchetto per la distribuzione. La prima attività nella preparazione di questo pacchetto consiste nel compilare l'applicazione per il rilascio, che comporta principalmente 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. Sebbene non sia tecnicamente necessario, alcuni mercati, ad esempio Google Play, lo richiedono.
Versione dell'applicazione : questo passaggio comporta l'inizializzazione o l'aggiornamento delle informazioni sul controllo delle versioni. Questo aspetto è importante per gli aggiornamenti futuri delle applicazioni e per assicurarsi che gli utenti siano a conoscenza della 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à di impacchettamento – Le proprietà di impacchettamento controllano la creazione del pacchetto dell'applicazione Android (APK). Questo passaggio ottimizza l'APK, protegge gli asset e modularizza i pacchetti 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 vengano compilati in modalità Release.
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 di seguito in modo più dettagliato.
Specificare l'icona dell'applicazione
È consigliabile che ogni applicazione Xamarin.Android specifichi un'icona dell'applicazione. Alcuni marketplace di applicazioni non consentiranno la pubblicazione di un'applicazione Android senza un'applicazione. La Icon proprietà 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 tramite la sezione Manifesto Android delle proprietà del progetto, come illustrato nello screenshot seguente:
In questi esempi si @drawable/icon riferisce a un file di icona che si trova in Resources/drawable/icon.png (si noti che l'estensione .png non è inclusa nel nome della risorsa). Questo attributo può anche essere dichiarato nel file Properties\AssemblyInfo.cs, come illustrato in questo frammento di esempio:
[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 questa using istruzione se non è già presente.
Versione dell'applicazione
Il controllo delle versioni è importante per la manutenzione e la distribuzione delle applicazioni Android. Senza un certo tipo di controllo delle versioni, è difficile determinare se o come deve essere aggiornata un'applicazione. Per facilitare il controllo delle versioni, Android riconosce due diversi tipi 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 inizia con questo valore impostato su 1 e quindi viene incrementata con ogni compilazione. Questo valore non ha alcuna relazione o affinità con l'attributo version name (vedere di seguito). Le applicazioni e i servizi di pubblicazione non devono visualizzare questo 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 compilazione 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 l'APK
Le APK Xamarin.Android possono essere rese più piccole tramite una combinazione del linker Xamarin.Android, che rimuove il codice gestito non necessario, e lo strumento ProGuard dell'SDK di Android, che rimuove il bytecode Java inutilizzato. Il processo di compilazione usa prima il linker Xamarin.Android per ottimizzare l'app a livello di codice gestito (C#) e quindi 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 venga fornita solo dalle parti di Xamarin.Android necessarie in fase di esecuzione. Il linker in Xamarin.Android usa l'analisi statica per determinare quali assembly, tipi e membri di tipo vengono usati o a cui fa riferimento un'applicazione Xamarin.Android. Il linker elimina quindi tutti gli assembly, i tipi e i membri non utilizzati né referenziati. Ciò può comportare una riduzione significativa delle dimensioni del pacchetto. Si consideri ad esempio l'esempio HelloWorld , che presenta una riduzione di 83% nella dimensione finale del file APK:
Configurazione: Nessuno : Xamarin.Android 4.2.5 Size = 17,4 MB.
Configurazione: solo assembly SDK – Xamarin.Android 4.2.5 Dimensioni = 3,0 MB.
Impostare le opzioni del linker tramite la sezione Opzioni Android del progetto Proprietà:
Il menu a discesa Collegamento offre le opzioni seguenti per controllare il linker:
Nessuno : disattiva il linker; non verrà eseguito alcun collegamento.
Solo assembly SDK – questo consente di collegare solo gli assembly richiesti da Xamarin.Android. Gli altri assemblaggi 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 testata nuovamente in modalità rilascio in un dispositivo fisico.
ProGuard
ProGuard è uno strumento Android SDK che collega e offusca il codice Java. ProGuard viene in genere usato per creare applicazioni più piccole riducendo il footprint di librerie incluse di grandi dimensioni (ad esempio Google Play Services) nel file APK. ProGuard rimuove il bytecode Java inutilizzato, che rende l'app risultante più piccola. Ad esempio, l'uso di ProGuard in app Xamarin.Android di piccole dimensioni raggiunge in genere circa 24% 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 Xamarin.Android. Il linker Xamarin.Android collega codice gestito , mentre ProGuard collega il bytecode Java. Il processo di compilazione usa prima il linker Xamarin.Android per ottimizzare il codice gestito (C#) nell'app e quindi usa ProGuard (se abilitato) per ottimizzare l'APK a livello di bytecode Java.
Quando si seleziona Abilita ProGuard , Xamarin.Android esegue lo strumento ProGuard nell'APK risultante. Un file di configurazione ProGuard viene generato e usato da ProGuard 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 e selezionarlo come azione di compilazione, come illustrato in questo esempio:
ProGuard è disabilitato per impostazione predefinita. L'opzione Abilita ProGuard è disponibile solo quando il progetto è impostato su Modalità di rilascio . Tutte le azioni di compilazione proGuard vengono ignorate a meno che non sia selezionata l'opzione Abilita ProGuard . La configurazione di Xamarin.Android ProGuard non offusca l'APK e non è possibile abilitare l'offuscamento, anche con file di configurazione personalizzati. Se si vuole usare l'offuscamento, vedere Protezione delle applicazioni 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 l'uso di Java Debug Wire Protocol (JDWP). Si tratta di una tecnologia che consente a strumenti come adb di comunicare con una JVM ai fini del debug. JDWP è attivato per impostazione predefinita per le build di debug di un'applicazione Xamarin.Android. Anche se JDWP è importante durante lo sviluppo, può rappresentare un problema di sicurezza per le applicazioni rilasciate.
Importante
Disabilitare sempre lo stato di debug in un'applicazione rilasciata perché è possibile (tramite JDWP) ottenere l'accesso completo al processo Java ed eseguire codice arbitrario nel contesto dell'applicazione se questo stato di debug non è disabilitato.
Il manifesto Android contiene l'attributo android:debuggable , che controlla se è possibile eseguire il debug dell'applicazione. È consigliabile impostare l'attributo android:debuggable su false. Il modo più semplice per eseguire questa operazione consiste nell'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 il debug, ad esempio Internet e ReadExternalStorage. Le build di versione, tuttavia, usano solo le autorizzazioni configurate in modo esplicito. Se si scopre che il passaggio alla build di rilascio causa la perdita di un'autorizzazione disponibile nella build di debug, verificare di aver abilitato in modo esplicito questa autorizzazione nell'elenco Autorizzazioni necessarie , come descritto in Autorizzazioni.
Protezione delle applicazioni con Dotfuscator
Anche se il debug è disabilitato, è comunque possibile che gli utenti malintenzionati riconfezionino un'applicazione, aggiungendo o rimuovendo opzioni di configurazione o autorizzazioni. In questo modo è possibile eseguire il reverse engineer, il debug o la manomissione dell'applicazione. Dotfuscator Community Edition (CE) può essere usato per offuscare il codice gestito e inserire il codice di rilevamento dello stato di sicurezza di runtime in un'app Xamarin.Android in fase di compilazione per rilevare e rispondere se l'app è in esecuzione 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 Uso di Dotfuscator Community Edition con Xamarin. Dopo la configurazione, Dotfuscator CE proteggerà automaticamente ogni compilazione creata.
Integrare assembly in codice nativo
Quando questa opzione è abilitata, gli assembly vengono raggruppati in una libreria 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 Use Fast Deployment è disabilitato. L'aggregazione di assembly nel codice nativo è disabilitata per impostazione predefinita.
Si noti che l'opzione Bundle into Native Codenon 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à creazione pacchetti) consente la compilazione anticipata degli assembly (AOT). Quando questa opzione è abilitata, il sovraccarico di avvio del JIT viene ridotto al minimo con la precompilazione degli assembly prima del runtime. Il codice nativo risultante è incluso nell'APK insieme agli assembly non compilati. Questo comporta tempi di avvio dell'applicazione più brevi, ma a scapito di dimensioni APK leggermente più grandi.
L'opzione Compilazione AOT richiede una licenza Enterprise o superiore. La compilazione AOT è disponibile solo quando il progetto è configurato per la modalità Release ed è disabilitato per impostazione predefinita. Per altre informazioni sulla compilazione AOT, vedere AOT.
LLVM Ottimizzazione del compilatore
LlVM Ottimizzazione del compilatore creerà codice compilato più piccolo e più veloce e convertirà gli assembly compilati da AOT in codice nativo, ma a scapito di tempi di compilazione più lenti. Il compilatore LLVM è disabilitato per impostazione predefinita. Per usare il compilatore LLVM, l'opzione Compilazione AOT deve prima essere abilitata (nella pagina Proprietà creazione pacchetti ).
Annotazioni
L'opzione LLVM Ottimizzazione del compilatore richiede una licenza Enterprise.
Impostare le proprietà dei pacchetti
Le proprietà dei 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 distribuzione rapida sono destinate alla modalità di debug. Tuttavia, quando l'applicazione è configurata per la modalità rilascio, esistono altre impostazioni che determinano come l'app è ottimizzata per le dimensioni e la velocità di esecuzione, come è protetta da manomissioni e come può essere inserita in un pacchetto per supportare architetture e restrizioni di dimensioni diverse.
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 computer per supportare più architetture diverse. Per informazioni dettagliate sul supporto di più architetture della CPU, vedere Architetture della CPU.
Generare un pacchetto (. APK) per ABI selezionato
Quando questa opzione è abilitata, verrà 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. Questa opzione è disponibile solo quando il progetto è configurato per la modalità rilascio ed è disabilitato per impostazione predefinita.
Multi-Dex
Quando l'opzione Abilita Multi-Dex è attivata, gli strumenti di Android SDK vengono usati per ignorare il limite di 65K metodi del formato di file con estensione .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 alcuni metodi, ma usa molte librerie (o librerie di grandi dimensioni), è possibile che venga superato il limite di 65.000.
È possibile che un'app non usi ogni metodo in ogni libreria a cui viene fatto riferimento; pertanto, è possibile che uno strumento come ProGuard (vedere sopra) possa rimuovere i metodi inutilizzati dal codice. La procedura consigliata consiste nell'abilitare Enable Multi-Dex solo se assolutamente necessario, ovvero l'app fa ancora riferimento a più di 65K di metodi Java anche dopo aver usato ProGuard.
Per altre informazioni su Multi-Dex, 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 APK dell'applicazione e distribuirli agli utenti con Consegna Dinamica.
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, assicurati di modificare il progetto in una configurazione Release poiché i bundle di app sono destinati solo ai pacchetti di rilascio.
È 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.
Compila
Al termine di tutti i passaggi precedenti, l'app è pronta per la compilazione. Selezionare Compila > Ricompila soluzione per verificare che venga compilata correttamente in modalità Release. Si noti che questo passaggio non produce ancora un APK.
La firma del pacchetto dell'app illustra l'impacchettamento e la firma in modo più dettagliato.
Archivio per la pubblicazione
Per avviare il processo di pubblicazione, fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni e selezionare la voce di menu di scelta rapida Archivia...
Archivio... avvia Gestione archivi e avvia il processo di archiviazione del bundle dell'app, come illustrato in questo screenshot:
Un altro modo per creare un archivio consiste nel fare clic con il pulsante destro del mouse sulla soluzione in Esplora soluzioni e selezionare Archivia tutto, che compila la soluzione e archivia tutti i progetti Xamarin che possono generare un archivio:
Archivia e Archivia tutti avviano automaticamente Gestione archivi. Per avviare direttamente Gestione archivi, fare clic sulla voce di menu Strumenti > gestione archivi...
Gli archivi della soluzione in qualsiasi momento facendo clic con il pulsante destro del mouse sul nodo Soluzione e selezionando Visualizza archivi:
Gestione archivi
Gestione archivi è costituito da un riquadro Elenco soluzioni, da un elenco archivi e da un pannello dettagli:
Nell'elenco soluzioni vengono visualizzate tutte le soluzioni con almeno un progetto archiviato. L'elenco delle soluzioni include le sezioni seguenti:
- Soluzione corrente : visualizza la soluzione corrente. Si noti che questa area può essere vuota se la soluzione corrente non dispone di un archivio esistente.
- 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 Archivi visualizza l'elenco di tutti gli archivi per la soluzione selezionata. L'elenco archivi include le sezioni seguenti:
- Nome della soluzione selezionata : visualizza il nome della soluzione selezionata nell'elenco soluzioni. Tutte le informazioni visualizzate nell'elenco Archivi fanno 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).
- Elementi Archivi – elenco di archivi per la soluzione selezionata. Ogni elemento 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 un elemento viene archiviato o pubblicato.
Nel pannello Dettagli vengono visualizzate informazioni aggiuntive su ogni archivio. Consente inoltre all'utente di avviare il flusso di lavoro distribuzione o di aprire la cartella in cui è stata creata la distribuzione. La sezione Build Comments consente di includere commenti di 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 mostra informazioni sull'app, un'indicazione dello stato del flusso di lavoro di distribuzione e una scelta dei canali di distribuzione. Nella prima esecuzione vengono presentate due opzioni:
È possibile scegliere uno dei canali di distribuzione seguenti:
Ad hoc : salva un APK firmato sul disco che può essere installato manualmente sui dispositivi Android. Continuare a Firmare il pacchetto dell'app per informazioni su come creare un'identità di firma Android, creare un nuovo certificato di firma per le applicazioni Android e pubblicare una versione ad hoc dell'app su disco. Questo è un buon modo per creare un APK per i test.
Google Play : pubblica un APK firmato in Google Play. Continuare a Pubblicare in Google Play per informazioni su come firmare e pubblicare un APK in Google Play Store.
