Condividi tramite

Processo di compilazione

  • Articolo

Il processo di compilazione di Xamarin.Android è responsabile della gestione delle diverse operazioni: generazione di Resource.designer.cs, supporto di @(AndroidAsset), @(AndroidResource) e altre azioni di compilazione, generazione di wrapper disponibili per la chiamata tramite Android e generazione di un file .apk da eseguire sui dispositivi Android.

Pacchetti dell'applicazione

In senso lato, esistono due tipi di pacchetti dell'applicazione Android (file .apk) che possono essere generati dal sistema di compilazione di Xamarin.Android:

  • Build di versione , che sono completamente autonome e non richiedono pacchetti aggiuntivi da eseguire. Questi sono i pacchetti forniti a un App Store.

  • Build di debug, che sono l'esatto contrario.

Questi tipi di pacchetto corrispondono a MSBuild Configuration che produce il pacchetto.

Runtime condiviso

Prima di Xamarin.Android 11.2, il runtime condiviso era una coppia di pacchetti Android aggiuntivi che forniscono la libreria di classi di base (mscorlib.dlle così via) e la libreria di binding Android (Mono.Android.dlle così via). Le build di debug si basano sul runtime condiviso invece di includere gli assembly di librerie di classi base e gli assembly di binding nel pacchetto dell'applicazione Android, consentendo di ridurre le dimensioni del pacchetto di debug.

Il runtime condiviso può essere disabilitato nelle compilazioni di debug impostando $(AndroidUseSharedRuntime) da a False.

Il supporto per il runtime condiviso è stato rimosso in Xamarin.Android 11.2.

Fast Deployment

La distribuzione rapida funziona riducendo ulteriormente le dimensioni del pacchetto dell'applicazione Android. Questa operazione viene eseguita escludendo gli assembly dell'app dal pacchetto e distribuendo invece gli assembly dell'app direttamente nella directory interna files dell'applicazione, in genere situata in /data/data/com.some.package. La directory interna files non è una cartella scrivibile a livello globale, quindi lo run-as strumento viene usato per eseguire tutti i comandi per copiare i file in tale directory.

Questo processo accelera il ciclo di compilazione/distribuzione/debug perché il pacchetto non viene reinstallato quando vengono modificati solo gli assembly. Solo gli assembly aggiornati vengono risincronizzati nel dispositivo di destinazione.

Avviso

La distribuzione rapida è nota per avere esito negativo nei dispositivi che bloccano run-as, che spesso include dispositivi precedenti ad Android 5.0.

Fast Deployment è abilitato per impostazione predefinita e può essere disabilitato nelle build di debug impostando la proprietà $(EmbedAssembliesIntoApk) su True.

La modalità di distribuzione rapida avanzata può essere usata insieme a questa funzionalità per velocizzare ulteriormente le distribuzioni. Verranno distribuiti entrambi gli assembly, le librerie native, le mappe dei tipi e gli indici nella files directory. Tuttavia, è necessario abilitare questa funzionalità solo se si modificano librerie native, associazioni o codice Java.

Progetti MSBuild

Il processo di compilazione di Xamarin.Android si basa su MSBuild, che è anche il formato del file di progetto usato da Visual Studio per Mac e Visual Studio. In genere, gli utenti non dovranno modificare manualmente i file di MSBuild. L'IDE crea progetti completamente funzionali e li aggiorna con eventuali modifiche apportate e richiama automaticamente le destinazioni di compilazione in base alle esigenze.

Gli utenti avanzati potrebbero voler eseguire operazioni non supportate dall'interfaccia utente grafica dell'IDE, quindi il processo di compilazione si può personalizzare modificando direttamente il file di progetto. Questa pagina documenta solo le funzionalità e le personalizzazioni specifiche di Xamarin.Android. Molte altre cose sono possibili con gli elementi, le proprietà e le destinazioni MSBuild normali.

Binding di progetti

Le proprietà MSBuild seguenti vengono usate con i progetti di binding:

Resource.designer.cs Generazione

Per controllare la generazione del Resource.designer.cs file vengono usate le proprietà MSBuild seguenti:

Proprietà di firma

Le proprietà di firma controllano come viene firmato il pacchetto dell'applicazione in modo che possa essere installato in un dispositivo Android. Per consentire un'iterazione della compilazione più rapida, le attività di Xamarin.Android non firmano i pacchetti durante il processo di compilazione perché la firma è piuttosto lenta. Vengono invece firmate (se necessario) prima dell'installazione o durante l'esportazione dall'IDE o dalla destinazione di compilazione Install. La chiamata alla destinazione SignAndroidPackage genererà un pacchetto con il suffisso -Signed.apk nella directory di output.

Per impostazione predefinita, la destinazione di firma genera una nuova chiave di firma di debug, se necessario. Se si vuole usare una chiave specifica, ad esempio in un server di compilazione, vengono usate le proprietà MSBuild seguenti:

keytool Mapping delle opzioni

Si consideri la chiamata seguente keytool :

$ keytool -genkey -v -keystore filename.keystore -alias keystore.alias -keyalg RSA -keysize 2048 -validity 10000
Enter keystore password: keystore.filename password
Re-enter new password: keystore.filename password
...
Is CN=... correct?
  [no]:  yes

Generating 2,048 bit RSA key pair and self-signed certificate (SHA1withRSA) with a validity of 10,000 days
        for: ...
Enter key password for keystore.alias
        (RETURN if same as keystore password): keystore.alias password
[Storing filename.keystore]

Per usare il file dell'archivio chiavi generato sopra, usare il gruppo di proprietà:

<PropertyGroup>
    <AndroidKeyStore>True</AndroidKeyStore>
    <AndroidSigningKeyStore>filename.keystore</AndroidSigningKeyStore>
    <AndroidSigningStorePass>keystore.filename password</AndroidSigningStorePass>
    <AndroidSigningKeyAlias>keystore.alias</AndroidSigningKeyAlias>
    <AndroidSigningKeyPass>keystore.alias password</AndroidSigningKeyPass>
</PropertyGroup>

Punti di estensione di compilazione

Il sistema di compilazione Xamarin.Android espone alcuni punti di estensione pubblici per gli utenti che desiderano eseguire l'hook nel processo di compilazione. Per usare uno di questi punti di estensione, sarà necessario aggiungere la destinazione personalizzata alla proprietà MSBuild appropriata in un PropertyGroup. Ad esempio:

<PropertyGroup>
   <AfterGenerateAndroidManifest>
      $(AfterGenerateAndroidManifest);
      YourTarget;
   </AfterGenerateAndroidManifest>
</PropertyGroup>

I punti di estensione includono:

Una parola di cautela sull'estensione del processo di compilazione: se non sono scritte correttamente, le estensioni di compilazione possono influire sulle prestazioni di compilazione, soprattutto se vengono eseguite in ogni compilazione. È consigliabile leggere la documentazione di MSBuild prima di implementare tali estensioni.

Definizioni delle destinazioni

Le parti del processo di compilazione specifiche di Xamarin.Android vengono definite in $(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets, ma sono necessarie anche le destinazioni specifiche dei normali linguaggi, ad esempio Microsoft.CSharp.targets, per compilare l'assembly.

Prima di importare le destinazioni dei linguaggi, è necessario impostare le proprietà di compilazione seguenti:

<PropertyGroup>
  <TargetFrameworkIdentifier>MonoDroid</TargetFrameworkIdentifier>
  <MonoDroidVersion>v1.0</MonoDroidVersion>
  <TargetFrameworkVersion>v2.2</TargetFrameworkVersion>
</PropertyGroup>

Tutte queste destinazioni e proprietà possono essere incluse per C# importando Xamarin.Android.CSharp.targets:

<Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />

Questo file può essere facilmente adattato per altri linguaggi.