Compartilhar via

Compilar, testar e implantar aplicativos Android

  • Artigo

Azure DevOps Services

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 em que você tem permissão para criar pipelines e implantar aplicativos. Para criar um projeto, consulte Criar um projeto no Azure DevOps.

  • Uma conta do 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 ou autenticar as organizações do GitHub. Siga as instruções na tela para efetuar o processo. Para obter mais informações, confira Acesso ao repositórios do GitHub.

Criar e executar o pipeline

Execute as tarefas a seguir para configurar um pipeline para um aplicativo Android simples.

  1. Para obter o código do aplicativo de exemplo, transfira o repositório de aplicativos de exemplo do Android para sua conta do GitHub.
  2. Em seu projeto do Azure DevOps, selecione Pipelines>Novo pipeline ou Criar pipeline se esse pipeline for o primeiro no projeto.
  3. Selecione GitHub como o local do código-fonte.
  4. Na tela Selecionar um repositório, selecione o seu repositório de amostra Android bifurcado.
  5. Na tela Configurar seu pipeline, selecione Android.
  6. O Azure Pipelines fornece um pipeline inicial baseado no modelo do Android. Revisar o código do pipeline.
  7. Selecione Salvar 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 de compilação mostra detalhes e progresso da compilação. Se quiser ver o seu pipeline em ação, selecione Trabalho na parte inferior da página.

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

Personalizar o pipeline

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

Configurar o Gradle

O pipeline YAML inicial usa o Gradle, uma ferramenta de compilação de código fonte aberto comum para projetos Android. Para obter mais informações, confira o Tarefa Gradle.

Na tarefa de exemplo, o tasks parâmetro cria o assembleDebug tipo de build. Você pode ajustar o tasks valor das 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 de forma adequada.

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 mais informações sobre como usar tarefas do Gradle, consulte Como usar tarefas na documentação do Gradle. Para 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.

Entrar e alinhar o pacote Android (APK)

Para ser executado em um dispositivo em vez de um emulador, o APK (Pacote de Aplicativos Android) deve estar conectado. O zipaligning reduz a RAM que o aplicativo consome. Se a compilação ainda não conectar e zipalinhar o APK, adicione a tarefa Assinatura do Android ao pipeline. Para obter mais informações, consulte acessar um aplicativo móvel.

Por segurança, armazene as variáveis jarsignerKeystorePassword e jarsignerKeyPassword em variáveis secretas e use essas variáveis em seu pipeline.

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

Testar no emulador de Android

Para instalar e executar o emulador do Android, adicione a tarefa Bash ao 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 adequar ao seu ambiente de teste.

#!/usr/bin/env bash

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

# Create emulator
echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-30;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 -no-window -no-audio -no-boot-anim -accel off > /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"

Testar em dispositivos hospedados no Azure

Para testar seu aplicativo em um laboratório hospedado de dispositivos Android no Visual Studio App Center, adicione a tarefa Teste do App Center 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 em uma conta do App Center antes de usar esta tarefa.

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

Para obter a sintaxe e a referência completas da tarefa, consulte Tarefa de teste do App Center. Para saber informações, consulte Usando o Azure DevOps para testes de IU.

- 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 artefatos com o registro de build

Para armazenar seu arquivo APK (Pacote da AppStore) com o registro de compilação ou teste e implantá-lo em pipelines subsequentes, adicione as tarefas Copiar Arquivos e Publicar Artefatos de Build ao seu pipeline. 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

Adicione a tarefa Distribuição do App Center para distribuir um aplicativo para um grupo de testadores ou usuários beta, ou promova o aplicativo para Intune ou Google Play. A tarefa requer uma conta gratuita do App Center que permaneça 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 builds 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ê deverá configurar.

Versão

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 Google Play Promote ao seu pipeline.

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

Aumentar a distribuição

Para aumentar a porcentagem de lançamento de um aplicativo que foi lançado anteriormente na rollout faixa, adicione a tarefa Aumentar lançamento do Google Play ao pipeline.

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

Atualizar status

Para atualizar o status de lançamento de um aplicativo que foi lançado anteriormente na rollout faixa, adicione a tarefa Atualização de status do Google Play ao pipeline.

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

Criar um lote de aplicativo

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

  1. Baixe seu repositório de chaves e armazene-o como um arquivo seguro na biblioteca do Azure Pipelines.

  2. Crie variáveis para keystore.password, key.alias e 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 acessar 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 Build ou usar a extensão do Google Play para publicar o pacote de aplicativos.