Partilhar via

Compilar, testar e implementar aplicações Android

  • Artigo

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.

Criar e executar o 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 seu pipeline em ação, selecione Trabalho 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.

Personalizar o pipeline

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 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 e gradleWrapperFile em workingDirectory 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 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 um aplicativo móvel.

Por segurança, armazene as jarsignerKeystorePassword variáveis e jarsignerKeyPassword em segredo 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

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.

#!/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"

Teste em dispositivos hospedados pelo 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 para obter 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ê 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 artefatos com o registro de compilação

Para armazenar seu arquivo APK com o registro de compilação ou teste e implantá-lo em pipelines subsequentes, adicione as tarefas Copiar arquivos e Publicar artefatos de compilação 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

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 Distribuição do App Center. 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.

Versão

Para lançar uma nova versão do aplicativo Android na Google Play Store, adicione a tarefa Liberar do Google Play 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 do 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 um aplicativo que foi lançado anteriormente na rollout faixa, adicione a tarefa 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 status de distribuição de um aplicativo que foi lançado anteriormente na rollout faixa, 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.