Compilare, testare e distribuire app Android

  • Articolo

Servizi di Azure DevOps

Questa guida introduttiva illustra come configurare una pipeline YAML in Azure Pipelines per compilare, testare e distribuire automaticamente un'app Android.

Prerequisiti

  • Un'organizzazione e un progetto di Azure DevOps in cui si dispone dell'autorizzazione per creare pipeline e distribuire app. Per creare un progetto, vedere Creare un progetto in Azure DevOps.

  • Un account GitHub.

    Importante

    Durante le procedure di GitHub, potrebbe essere richiesto di creare una connessione al servizio GitHub o di essere reindirizzati a GitHub per accedere, installare Azure Pipelines, autorizzare Azure Pipelines o eseguire l'autenticazione alle organizzazioni GitHub. Seguire le istruzioni visualizzate per completare il processo. Per altre informazioni, vedere Accedere ai repository GitHub.

Creare ed eseguire la pipeline

Eseguire le attività seguenti per configurare una pipeline per una semplice applicazione Android.

  1. Per ottenere il codice per l'app di esempio, creare una copia tramite fork del repository dell'app di esempio Android nell'account GitHub.

  2. Nel progetto Azure DevOps selezionare Pipeline>nuova pipeline o Crea pipeline se la pipeline è la prima nel progetto.

  3. Selezionare GitHub come percorso del codice sorgente.

  4. Nella schermata Selezionare un repository selezionare il repository di esempio Android con fork.

  5. Nella schermata Configura la pipeline selezionare Android.

  6. Azure Pipelines offre una pipeline iniziale basata sul modello Android . Esaminare il codice della pipeline.

  7. Seleziona Salva ed Esegui.

    Screenshot del pulsante Salva ed esegui in una nuova pipeline YAML android.

  8. Facoltativamente, modificare il messaggio Commit e fornire una descrizione. Selezionare quindi Salva ed esegui di nuovo per eseguire il commit del file azure-pipelines.yml nel repository e avviare una compilazione.

La pagina di esecuzione della compilazione mostra i dettagli e lo stato di avanzamento della compilazione. Se si vuole controllare la pipeline in azione, selezionare Processo nella parte inferiore della pagina.

È ora disponibile una pipeline YAML android funzionante, azure-pipelines.yml, nel repository pronto per la personalizzazione.

Personalizzare la pipeline

Per apportare modifiche alla pipeline, selezionare Modifica nella pagina della pipeline. Le sezioni seguenti descrivono alcuni modi comuni per personalizzare la pipeline Android.

Configurare Gradle

La pipeline YAML iniziale usa Gradle, uno strumento di compilazione open source comune per i progetti Android. Per altre informazioni, vedere l'attività Gradle.

Nell'attività di esempio il tasks parametro compila il assembleDebug tipo di compilazione. È possibile modificare il tasks valore per le varianti di compilazione desiderate, ad esempio build, teste assembleRelease.

L'attività di esempio presuppone anche che il gradlew file si trova nella radice del repository. In caso contrario, modificare i workingDirectory valori e gradleWrapperFile di conseguenza.

Deve workingDirectory essere simile alla radice del repository, ad esempio AndroidApps/MyApp o $(system.defaultWorkingDirectory)/AndroidApps/MyApp. Il gradleWrapperFile percorso deve essere simile alla radice del repository, ad esempio AndroidApps/MyApp/gradlew o $(system.defaultWorkingDirectory)/AndroidApps/MyApp/gradlew.

- task: Gradle@2
  inputs:
    workingDirectory: ''
    gradleWrapperFile: 'gradlew'
    gradleOptions: '-Xmx3072m'
    publishJUnitResults: false
    testResultsFiles: '**/TEST-*.xml'
    tasks: 'assembleDebug'

Per altre informazioni sull'uso delle attività Gradle, vedere Uso delle attività nella documentazione di Gradle. Per altre informazioni sulle attività di compilazione, vedere Creare un APK di debug e Configurare le varianti di compilazione nella documentazione sullo sviluppo di Google Android.

Firmare e allineare il pacchetto Android (APK)

Per l'esecuzione in un dispositivo invece di un emulatore, è necessario firmare il pacchetto dell'applicazione Android (APK). Zipaligning riduce la RAM usata dall'applicazione. Se la compilazione non firma e comprime il file APK, aggiungere l'attività Di firma Android alla pipeline. Per altre informazioni, vedere Firmare un'app per dispositivi mobili.

Per la sicurezza, archiviare e jarsignerKeystorePassword jarsignerKeyPassword in variabili segrete e usare tali variabili nella pipeline.

- task: AndroidSigning@2
  inputs:
    apkFiles: '**/*.apk'
    jarsign: true
    jarsignerKeystoreFile: 'pathToYourKeystoreFile'
    jarsignerKeystorePassword: '$(jarsignerKeystorePassword)'
    jarsignerKeystoreAlias: 'yourKeystoreAlias'
    jarsignerKeyPassword: '$(jarsignerKeyPassword)'
    zipalign: true

Eseguire test nell'emulatore Android

Per installare ed eseguire l'emulatore Android, aggiungere l'attività Bash alla pipeline e incollare il codice seguente. L'emulatore viene avviato come processo in background ed è disponibile nelle attività successive. Disporre i parametri dell'emulatore per adattarsi all'ambiente di test.

#!/usr/bin/env bash

# Install AVD files
echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --install 'system-images;android-27;google_apis;x86'

# Create emulator
echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-27;google_apis;x86' --force

$ANDROID_HOME/emulator/emulator -list-avds

echo "Starting emulator"

# Start emulator in background
nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot > /dev/null 2>&1 &
$ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 1; done; input keyevent 82'

$ANDROID_HOME/platform-tools/adb devices

echo "Emulator started"

Testare nei dispositivi ospitati in Azure

Per testare l'app in un lab ospitato di dispositivi Android in Visual Studio App Center, aggiungere l'attività Test di App Center alla pipeline.

Questa attività richiede un account di valutazione gratuito di App Center , che deve essere convertito in a pagamento dopo 30 giorni per continuare a usare il lab di test. Iscriversi per ottenere un account App Center prima di usare questa attività.

L'esempio seguente esegue un gruppo di test di App Center. L'attività usa una connessione al servizio che è necessario configurare.

Per la sintassi completa delle attività e informazioni di riferimento, vedere Attività test di App Center. Per altre informazioni, vedere Uso di Azure DevOps per il test dell'interfaccia utente.

- task: AppCenterTest@1
  inputs:
    appFile: path/myapp.ipa
    artifactsDirectory: '$(Build.ArtifactStagingDirectory)/AppCenterTest'
    frameworkOption: 'appium'
    appiumBuildDirectory: test/upload
    serverEndpoint: 'My App Center service connection'
    appSlug: username/appIdentifier
    devices: 'devicelist'

Mantenere gli artefatti con il record di compilazione

Per archiviare il file APK con il record di compilazione o il test e distribuirlo nelle pipeline successive, aggiungere le attività Copia file e Pubblica artefatti di compilazione alla pipeline. Per altre informazioni, vedere Pubblicare e scaricare gli artefatti della pipeline.

- task: CopyFiles@2
  inputs:
    contents: '**/*.apk'
    targetFolder: '$(build.artifactStagingDirectory)'
- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: $(Build.ArtifactStagingDirectory)
    artifactName: MyBuildOutputs

Distribuire in App Center

Per distribuire un'app a un gruppo di tester o utenti beta o promuovere l'app in Intune o Google Play, aggiungere l'attività Distribuzione di App Center. L'attività richiede un account App Center gratuito che rimane gratuito.

L'esempio seguente distribuisce un'app agli utenti. Per informazioni di riferimento e sintassi completa delle attività, vedere App Center Distribute. Per altre informazioni, vedere Distribuire build di Azure DevOps con App Center.

- task: AppCenterDistribute@3
  inputs:
    serverEndpoint: 'AppCenter'
    appSlug: '$(APP_CENTER_SLUG)'
    appFile: '$(APP_FILE)' # Relative path from the repo root to the APK file you want to publish
    symbolsOption: 'Android'
    releaseNotesOption: 'input'
    releaseNotesInput: 'Here are the release notes for this version.'
    destinationType: 'groups'

Installare l'estensione Google Play e distribuirla in Google Play

Per automatizzare l'interazione con Google Play, installare l'estensione Google Play e quindi usare le attività seguenti. Per impostazione predefinita, queste attività eseguono l'autenticazione a Google Play usando una connessione al servizio che è necessario configurare.

Rilascio

Per rilasciare una nuova versione dell'app Android in Google Play Store, aggiungere l'attività Versione di Google Play alla pipeline.

- task: GooglePlayRelease@4
  inputs:
    apkFile: '**/*.apk'
    serviceEndpoint: 'yourGooglePlayServiceConnectionName'
    track: 'internal'

Promozione

Per alzare di livello un aggiornamento dell'applicazione Android rilasciato in precedenza da una traccia a un'altra, ad esempio alpha → beta, aggiungere l'attività Promuovere Google Play alla pipeline.

- task: GooglePlayPromote@3
  inputs:
    packageName: 'com.yourCompany.appPackageName'
    serviceEndpoint: 'yourGooglePlayServiceConnectionName'
    sourceTrack: 'internal'
    destinationTrack: 'alpha'

Aumentare l'implementazione

Per aumentare la percentuale di implementazione di un'applicazione rilasciata in precedenza alla rollout traccia, aggiungere l'attività Di aumento dell'implementazione di Google Play alla pipeline.

- task: GooglePlayIncreaseRollout@2
  inputs:
    packageName: 'com.yourCompany.appPackageName'
    serviceEndpoint: 'yourGooglePlayServiceConnectionName'
    userFraction: '0.5' # 0.0 to 1.0 (0% to 100%)

Aggiorna stato

Per aggiornare lo stato di implementazione per un'applicazione rilasciata in precedenza alla rollout traccia, aggiungere l'attività Google Play Status Update alla pipeline.

  - task: GooglePlayStatusUpdate@2
    inputs:
      authType: ServiceEndpoint
      packageName: 'com.yourCompany.appPackageName'
      serviceEndpoint: 'yourGooglePlayServiceConnectionName'
      status: 'inProgress' # draft | inProgress | halted | completed

Creare un bundle di app

È possibile compilare e firmare un bundle di app con uno script inline e un file sicuro.

  1. Scaricare l'archivio chiavi e archiviarlo come file sicuro nella libreria di Azure Pipelines.

  2. Creare variabili per keystore.password, key.aliase key.password in un gruppo di variabili.

Nella pipeline YAML:

  1. Aggiungere l'attività Scarica file sicuro per scaricare il file protetto app.keystore .

    - task: DownloadSecureFile@1
  name: keyStore
  displayName: "Download keystore from secure files"
  inputs:
    secureFile: app.keystore

  2. Usare l'attività Bash con uno script Bash per compilare e firmare il bundle dell'app.

    - task: Bash@3
  displayName: "Build and sign App Bundle"
  inputs:
    targetType: "inline"
    script: |
      msbuild -restore $(Build.SourcesDirectory)/myAndroidApp/*.csproj -t:SignAndroidPackage -p:AndroidPackageFormat=aab -p:Configuration=$(buildConfiguration) -p:AndroidKeyStore=True -p:AndroidSigningKeyStore=$(keyStore.secureFilePath) -p:AndroidSigningStorePass=$(keystore.password) -p:AndroidSigningKeyAlias=$(key.alias) -p:AndroidSigningKeyPass=$(key.password)

  3. Usare l'attività Copia file per copiare il bundle dell'app.

    - task: CopyFiles@2
  displayName: 'Copy deliverables'
  inputs:
    SourceFolder: '$(Build.SourcesDirectory)/myAndroidApp/bin/$(buildConfiguration)'
    Contents: '*.aab'
    TargetFolder: 'drop'

Da qui è possibile creare e salvare un artefatto con l'attività Pubblica artefatto compilazione oppure usare l'estensione Google Play per pubblicare il bundle dell'app.