Partilhar via

Compilar, testar e implementar aplicações Android

Serviços de DevOps do Azure

Este guia de início rápido mostra como configurar um pipeline YAML no Azure Pipelines para criar, testar e implantar automaticamente um aplicativo Android.

Pré-requisitos

  • Uma organização e um projeto do Azure DevOps onde você tem permissão para criar pipelines e implantar aplicativos. Para criar um projeto, consulte Criar um projeto no Azure DevOps.

  • Uma conta GitHub.

    Importante

    Durante os procedimentos do GitHub, você pode ser solicitado a criar uma conexão de serviço do GitHub ou ser redirecionado para o GitHub para entrar, instalar o Azure Pipelines, autorizar o Azure Pipelines ou autenticar em organizações do GitHub. Siga as instruções na tela para concluir o processo. Para obter mais informações, consulte Acesso a repositórios do GitHub.

Criação e execução do pipeline

Faça as seguintes tarefas para configurar um pipeline para um aplicativo Android simples.

  1. Para obter o código do aplicativo de exemplo, bifurque o repositório do aplicativo de exemplo do Android para sua conta do GitHub.
  2. Em seu projeto de DevOps do Azure, selecione Pipelines>New pipeline ou Create pipeline se esse pipeline for o primeiro do projeto.
  3. Selecione GitHub como o local do seu código-fonte.
  4. Na tela Selecione um repositório, selecione seu repositório de exemplo Android bifurcado.
  5. Na tela Configurar seu pipeline, selecione Android.
  6. O Azure Pipelines fornece um pipeline inicial com base no modelo Android . Analise o código do pipeline.
  7. Selecione Guardar e executar.
  8. Opcionalmente, edite a mensagem de confirmação e forneça uma descrição. Em seguida, selecione Salvar e executar novamente para confirmar o arquivo azure-pipelines.yml no repositório e iniciar uma compilação.

A página de execução da compilação mostra os detalhes e o progresso da compilação. Se quiser ver o seu pipeline em ação, selecione Job na parte inferior da página.

Agora você tem um pipeline YAML Android funcionando, azure-pipelines.yml, em seu repositório que está pronto para personalizar.

Personalize o seu processo

Para fazer alterações no pipeline, selecione Editar na página do pipeline. As seções a seguir descrevem algumas maneiras comuns de personalizar seu pipeline do Android.

Configurar o Gradle

O pipeline inicial do YAML usa o Gradle, uma ferramenta de construção de código aberto comum para projetos Android. Para obter mais informações, consulte a tarefa do Gradle.

Na tarefa de exemplo, o tasks parâmetro cria o assembleDebug tipo de compilação. Você pode ajustar o tasks valor para as variantes de compilação desejadas, como build, teste assembleRelease.

A tarefa de exemplo também pressupõe que seu gradlew arquivo esteja na raiz do repositório. Caso contrário, ajuste os valores workingDirectory e gradleWrapperFile em conformidade.

O workingDirectory deve ser semelhante à raiz do repositório, como AndroidApps/MyApp ou $(system.defaultWorkingDirectory)/AndroidApps/MyApp. O gradleWrapperFile caminho deve ser semelhante à raiz do repositório, como AndroidApps/MyApp/gradlew ou $(system.defaultWorkingDirectory)/AndroidApps/MyApp/gradlew.

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

Para obter mais informações sobre como usar tarefas do Gradle, consulte Usando tarefas na documentação do Gradle. Para obter mais informações sobre tarefas de compilação, consulte Criar um APK de depuração e Configurar variantes de compilação na documentação de desenvolvimento do Google Android.

Assine e alinhe o pacote Android (APK)

Para ser executado em um dispositivo em vez de um emulador, o Android Application Package (APK) deve ser assinado. O zipaligning reduz a RAM que o aplicativo consome. Se a sua compilação ainda não assinar e zipalinhar o APK, adicione a tarefa Assinatura do Android ao Pipeline. Para obter mais informações, consulte Assinar uma aplicação móvel.

Por segurança, armazene o apksignerKeystorePassword e o apksignerKeyPassword em variáveis secretas e use essas variáveis no seu pipeline.

- task: AndroidSigning@3
  inputs:
    apkFiles: '**/*.apk' # Specify the APK files to sign
    apksignerKeystoreFile: 'pathToYourKeystoreFile' # Path to the keystore file
    apksignerKeystorePassword: '$(apksignerKeystorePassword)' # Use a secret variable for security
    apksignerKeystoreAlias: 'yourKeystoreAlias' # Alias for the keystore
    apksignerKeyPassword: '$(apksignerKeyPassword)' # Use a secret variable for security
    apksignerVersion: 'latest' # Use the latest version of apksigner
    apksignerArguments: '--verbose' # Optional: Additional arguments for apksigner
    zipalign: true # Enable zipalign to optimize APK
    zipalignVersion: 'latest' # Use the latest version of zipalign

Teste no emulador Android

Para instalar e executar o emulador Android, adicione a tarefa Bash ao seu pipeline e cole o código a seguir. O emulador começa como um processo em segundo plano e está disponível em tarefas posteriores. Organize os parâmetros do emulador para se adequarem ao seu ambiente de teste.

Importante

Se você estiver usando um agente hospedado pela Microsoft, use a imagem do agente do macOS com o emulador Android. Os emuladores Android atuais exigem aceleração de hardware para iniciar. Os agentes do Azure DevOps hospedados no Ubuntu não oferecem suporte à aceleração de hardware.

- task: Bash@3
  inputs:
    targetType: 'inline'
    script: |
      #!/usr/bin/env bash

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

      # Create emulator
      echo "y" | $ANDROID_HOME/cmdline-tools/latest/bin/avdmanager create avd -n xamarin_android_emulator -d "Nexus 10" -k 'system-images;android-35;google_apis;x86_64' --force

      echo "y" | $ANDROID_HOME/emulator/emulator -list-avds

      echo "Starting emulator"

      # Start emulator in background
      nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot -no-window -no-audio -no-boot-anim -accel on > /dev/null 2>&1 &
      # Fixed quoting around "\r"
      $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"

Teste em dispositivos hospedados pelo Azure

Para testar a sua aplicação num laboratório de dispositivos Android hospedado no Visual Studio App Center, adicione a tarefa App Center Test ao seu pipeline.

Essa tarefa requer uma conta de avaliação gratuita do App Center , que deve ser convertida em paga após 30 dias para continuar a usar o laboratório de teste. Inscreva-se para obter uma conta do App Center antes de usar esta tarefa.

Advertência

O Visual Studio App Center está programado para ser desativado em 31 de março de 2025. Saiba mais sobre cronogramas de suporte e alternativas recomendadas.

Inscreva-se no App Center primeiro.

O exemplo a seguir executa um conjunto de testes do App Center. A tarefa usa uma conexão de serviço que você deve configurar.

Para obter a sintaxe e a referência completas da tarefa, consulte Tarefa de teste do App Center. Para obter mais informações, consulte Usando o Azure DevOps para teste de interface do usuário.

- 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'

Manter os artefatos junto com o registo de compilação

Para armazenar o seu ficheiro APK com o registo da build ou testá-lo e implantá-lo em canalizações subsequentes, adicione as tarefas Copiar Arquivos e Publicar Artefatos de Build à sua canalização. Para obter mais informações, consulte Publicar e baixar artefatos de pipeline.

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

Implantar no App Center

Para distribuir uma aplicação a um grupo de testadores ou utilizadores beta ou promover a aplicação para o Intune ou Google Play, adicione a tarefa Distribuir do App Center. A tarefa requer uma conta gratuita do App Center que permanece gratuita.

O exemplo a seguir distribui um aplicativo para os usuários. Para obter a sintaxe e a referência completas da tarefa, consulte App Center Distribute. Para obter mais informações, consulte Implantar compilações do Azure DevOps com o 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'

Instale a extensão do Google Play e implante no Google Play

Para automatizar a interação com o Google Play, instale a extensão do Google Play e use as tarefas a seguir. Por padrão, essas tarefas são autenticadas no Google Play usando uma conexão de serviço que você deve configurar.

Lançamento

Para lançar uma nova versão do aplicativo Android na Google Play Store, adicione a tarefa Google Play Release ao seu pipeline.

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

Promover

Para promover uma atualização de aplicativo Android lançada anteriormente de uma faixa para outra, como alpha → beta, adicione a tarefa Promover Google Play ao seu pipeline.

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

Aumentar a implementação

Para aumentar a porcentagem de distribuição de uma aplicação que foi lançada anteriormente na rollout pista, adicione a tarefa de Aumentar Distribuição do Google Play ao seu pipeline.

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

Estado da atualização

Para atualizar o estado de distribuição de uma aplicação que foi lançada anteriormente no canal rollout, adicione a tarefa Atualização de Status do Google Play ao seu pipeline.

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

Criar um pacote de aplicativos

Você pode criar e assinar um pacote de aplicativos com um script embutido e um arquivo seguro.

  1. Baixe seu keystore e armazene-o como um arquivo seguro na biblioteca do Azure Pipelines.

  2. Crie variáveis para keystore.password, key.aliase key.password em um grupo de variáveis.

No seu pipeline YAML:

  1. Adicione a tarefa Baixar Arquivo Seguro para baixar o arquivo seguro app.keystore.

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

  2. Use a tarefa Bash com um script Bash para criar e assinar o pacote de aplicativos.

    - 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. Use a tarefa Copiar arquivos para copiar o pacote de aplicativos.

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

A partir daqui, você pode criar e salvar um artefato com a tarefa Publicar artefato de compilação ou usar a extensão do Google Play para publicar o pacote de aplicativos.