Lançar uma compilação

Carregue seu pacote binário de aplicativo para o App Center para distribuí-lo. O App Center suporta a distribuição de pacotes para Android, iOS, macOS, Windows e aplicações personalizadas do sistema operativo. Você pode distribuir liberações para testadores individuais ou grupos de testadores. Para aplicativos iOS e Android, você também pode liberar para as lojas como o Google Play, a App Store e o Intune. Consulte Publicar em lojas de consumidores e empresas.

Nesta página, você pode aprender como gerar o binário para liberação e como carregá-lo e liberá-lo para grupos usando o portal, a interface de linha de comando (CLI) e a interface de programação de aplicativos (API).

Você também pode usar o Azure DevOps ou Jenkins:

• O Azure DevOps usa a Tarefa de Distribuição do App Center (versão 3+)
• Jenkins Plugin (versão 0.11.0+).

Gerando um pacote binário de aplicativo

Primeiro você deve empacotar seu aplicativo em um arquivo binário para liberação. Você pode criar esse arquivo manualmente.

As seções a seguir explicam como criar os arquivos para todos os tipos de aplicativos que o App Center suporta para distribuição.

Android

Para Android, você deve produzir um pacote de aplicativo assinado ou arquivo APK. Para obter todos os detalhes desse processo, consulte a documentação oficial do Google sobre como preparar um aplicativo para lançamento.

1. Certifique-se de ter atualizado o manifesto e ter uma compilação do Gradle configurada corretamente.
2. No Android Studio, escolha Build>Generate Signed Bundle / APK e siga as etapas no assistente para criar o pacote de aplicativos ou APK.

O Android Studio coloca pacotes de aplicativos construídos em nome do projeto/module-name/build/outputs/bundle/ e APKs em project-name/module-name/build/outputs/apk/.

iOS

Para iOS, você deve produzir um pacote IPA para seu aplicativo. Para obter todos os detalhes deste processo, consulte a documentação oficial da Apple.

1. Registre UDIDs para todos os dispositivos de hardware em seu perfil de provisionamento.
2. No Xcode, vá para Arquivo de produtos> para arquivar seu aplicativo.
3. Exporte o arquivo usando o perfil de provisionamento adequado.

macOS

Para macOS, você deve produzir um pacote de aplicativo. O App Center suporta a liberação de pacotes de aplicativos do tipo .app.zip, .pkg ou .dmg. Para obter todos os detalhes deste processo, consulte a documentação oficial do Apple macOS.

1. Registe um único dispositivo ou registe vários dispositivos na sua conta de programador Apple.
2. No Xcode, vá para Arquivo de produtos> para arquivar seu aplicativo.
3. Exporte o arquivo usando o perfil de provisionamento adequado.

Windows

O App Center oferece suporte ao lançamento de pacotes de aplicativos do Windows do tipo .appx, .appxbundle, .appxupload, .msi, .msix.msixbundle, .msixupload, ou .zip. Para obter detalhes completos sobre como empacotar seu aplicativo nos formatos AppX ou MSIX, consulte a documentação oficial da Microsoft UWP.

Sistema operacional personalizado

Arquive sua compilação para aplicativos com um sistema operacional personalizado em formato .zip.

Distribuição do pacote

Para distribuir um pacote com o App Center, vá para o App Center, vá para o seu aplicativo, depois vá para Distribuir>Grupos e selecione Nova versão. Siga as etapas no assistente de configuração.

Na primeira etapa, escolha a área Liberar para procurar o arquivo que deseja carregar ou arraste e solte o arquivo na área. Dependendo do sistema operacional do seu aplicativo e da extensão do arquivo, o App Center pode solicitar que você insira uma versão e um número de compilação para sua versão. Insira as informações e escolha Avançar.

Você pode incluir notas de versão como parte de sua versão, tanto em texto sem formatação quanto no formato Markdown. Escolha Próximo.

Você pode direcionar sua versão para vários grupos de distribuição ou testadores. O App Center disponibiliza esta versão para os testadores e os usuários que fazem parte dos grupos selecionados. Escolha Próximo.

Ao lançar um aplicativo iOS, você pode provisionar automaticamente os dispositivos dos testadores. Escolha Próximo.

Reveja o lançamento. Se seu aplicativo usa o SDK de distribuição, você pode configurar o App Center para tornar a versão obrigatória. Quando o App Center distribui uma versão, ele envia uma notificação por e-mail da nova versão para todos os testadores definidos nos destinos. Você pode optar por não notificar os testadores na guia Revisão. Por fim, escolha Distribuir para liberar o arquivo para seus testadores.

Distribuindo usando a interface de linha de comando do App Center

Distribua sua versão usando o appcenter distribute release comando na CLI do App Center. O comando de exemplo a seguir distribui um arquivo chamado ~/releases/my_app-23.ipa para o grupo Beta testers do aplicativo My-App de propriedade de David.

appcenter distribute release --app David/My-App --file ~/releases/my_app-23.ipa --group "Beta testers"

Distribuindo usando a API

Você pode chamar a API do App Center para distribuir uma versão. A abordagem abaixo destina-se a descrever uma abordagem de trabalho mínima, muitas das tarefas podem ser ainda mais personalizadas ou automatizadas.

Um exemplo de implementação pode ser visto aqui: https://github.com/microsoft/appcenter-Xamarin.UITest-Demo/blob/main/ac-distribute.sh

Pré-requisitos

• O pacote do aplicativo para carregar e distribuir.
• Obtenha um token de API. Um token de API é usado para autenticação para todas as chamadas de API do App Center.
• O Nome do Grupo de Distribuição (opcional, se faltar ou for inválido, o carregamento ainda será concluído)
• Identifique o {owner_name} e {app_name} para a aplicação para a qual pretende distribuir uma versão. Esses identificadores são usados na URL para as chamadas de API. Para um aplicativo de propriedade de um usuário, a URL no App Center pode ter a seguinte aparência: https://appcenter.ms/users/Example-User/apps/Example-App. Aqui, o {owner_name} é Example-User e o {app_name} é Example-App. Para um aplicativo de propriedade de uma organização, a URL pode ser https://appcenter.ms/orgs/Example-Org/apps/Example-App e o {owner_name} seria Example-Org.

Carregar Nova Versão

Carregue uma nova versão usando estas chamadas de API sequenciais:

1. Criar um novo envio de versão: O endereço da API a ser chamado é POST /v0.1/apps/{owner_name}/{app_name}/uploads/releases

       OWNER_NAME="Example-Org"
       APP_NAME="Example-App"
       API_TOKEN="Example-Token"
   
       curl -X POST "https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases" -H  "accept: application/json" -H  "X-API-Token: $API_TOKEN" -H  "Content-Type: application/json" -H "Content-Length: 0"
   

   A resposta será algo assim, com o {VARIABLE_NAME} a substituir dados exclusivos para cada uso.

        {
            "id": "{ID}",
            "package_asset_id": "{PACKAGE_ASSET_ID}",
            "upload_domain": "https://file-aks.appcenter.ms",
            "token": "{TOKEN}",
            "url_encoded_token": "{URL_ENCODED_TOKEN}"
        }
   

2. Copie os parâmetros da resposta na etapa anterior, pois a maioria deles é usada na próxima etapa, incluindo o package_asset_id, upload_domain & url_encoded_token.

   Determine o tamanho do pacote do aplicativo em bytes. Recomenda-se o uso de um comando como wc -c ExampleApp.ipa para obter uma contagem precisa de bytes.

   Defina o MIME Type para o content_type com base no seu aplicativo:

   • O Android .apk usa o tipo de fornecedor application/vnd.android.package-archive
   • Android .aab usa o tipo de fornecedor application/x-authorware-bin
   • iOS usa o tipo geral application/octet-stream

   O comando final deve ter a seguinte aparência:

   FILE_NAME="ExampleApp.apk"
   FILE_SIZE_BYTES=$(wc -c $RELEASE_FILE_LOCATION | awk '{print $1}')
   APP_TYPE='application/vnd.android.package-archive' # iOS uses `application/octet-stream` instead.
   
   METADATA_URL="https://file-aks.appcenter.ms/upload/set_metadata/$PACKAGE_ASSET_ID?file_name=$FILE_NAME&file_size=$FILE_SIZE_BYTES&token=$URL_ENCODED_TOKEN&content_type=$APP_TYPE"
   
    curl -s -d POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" "$METADATA_URL"
   

   A saída retornada deve ter esta aparência:

    {
        "error":false,
        "id":"{PACKAGE_ASSET_ID}",
        "chunk_size":4194304,
        "resume_restart":false,
        "chunk_list":[1,2,3,4,5],
        "blob_partitions":1,
        "status_code":"Success"
    }
   

3. Usando o valor que não pode ser personalizado, você pode dividir o carregamento do chunk_size aplicativo em partes sequenciais para upload no Distribute. Por exemplo, você pode usar o split utilitário assim:

   split -b $CHUNK_SIZE $RELEASE_FILE_LOCATION temp/split
   

   Este comando gera arquivos sequenciais no temp diretório chamado splitaa, splitabe assim por diante. Cada ficheiro é dividido dentro do chunk_size limite.

4. Em seguida, você precisa carregar cada parte do pacote do aplicativo dividido com o respetivo bloco:

   BLOCK_NUMBER=0
   
   for i in temp/*
   do
       BLOCK_NUMBER=$(($BLOCK_NUMBER + 1))
       CONTENT_LENGTH=$(wc -c "$i" | awk '{print $1}')
   
       UPLOAD_CHUNK_URL="https://file-aks.appcenter.ms/upload/upload_chunk/$PACKAGE_ASSET_ID?token=$URL_ENCODED_TOKEN&block_number=$BLOCK_NUMBER"
   
       curl -X POST $UPLOAD_CHUNK_URL --data-binary "@$i" -H "Content-Length: $CONTENT_LENGTH" -H "Content-Type: $CONTENT_TYPE"
   done
   

5. Depois que o carregamento for feito, atualize o status do recurso de carregamento para uploadFinished.

   FINISHED_URL="https://file-aks.appcenter.ms/upload/finished/$PACKAGE_ASSET_ID?token=$URL_ENCODED_TOKEN"
   curl -d POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" "$FINISHED_URL"
   
   COMMIT_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases/$ID"
   curl -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" \
   --data '{"upload_status": "uploadFinished","id": "$ID"}' \
   -X PATCH \
   $COMMIT_URL
   

6. Uma vez carregado, há um pequeno atraso antes que o upload seja marcado como concluído. Consulte este estado para obter o $RELEASE_ID para a próxima etapa.

   RELEASE_STATUS_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/uploads/releases/$UPLOAD_ID"
   POLL_RESULT=$(curl -s -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" $RELEASE_STATUS_URL)
   RELEASE_ID=$(echo $POLL_RESULT | jq -r '.release_distinct_id')
   
   if [[ $RELEASE_ID == null ]];
   then
      echo "Failed to find release from appcenter"
      exit 1
   fi
   

7. Finalmente, publique a compilação. O ponto de extremidade a ser chamado é PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

   DISTRIBUTE_URL="https://api.appcenter.ms/v0.1/apps/$OWNER_NAME/$APP_NAME/releases/$RELEASE_ID"
   
   curl -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" \
   --data '{"destinations": [{ "name": "'"$DISTRIBUTION_GROUP"'"}] }' \    
   -X PATCH \
   $DISTRIBUTE_URL
   

Distribuir versão

Distribua a versão carregada para testadores, grupos ou lojas para ver a versão no portal do App Center. Os três pontos finais são:

• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/testers
• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/groups
• POST /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}/stores

Um exemplo para grupos:

    curl -X POST -H "Content-Type: application/json" -H "Accept: application/json" -H "X-API-Token: $API_TOKEN" -d "{ \"id\": "$DISTRIBUTION_GROUP_ID", \"mandatory_update\": false, \"notify_testers\": false}" 

Você pode encontrar o ID do grupo de distribuição na página de configurações desse grupo.

A solicitação para distribuir para vários destinos é referenciada aqui para cenários mais complexos: PATCH /v0.1/apps/{owner_name}/{app_name}/releases/{release_id}

Re-Release uma compilação

Para liberar uma compilação para outro grupo de distribuição, de qualquer lugar no App Center, vá para Distribuir > Versões e selecione a versão que deseja distribuir novamente. A página de detalhes da versão é aberta. Selecione o botão Distribuir no canto superior direito da tela e selecione o destino para iniciar o processo de relançamento. Siga as etapas no assistente e, finalmente, selecione Distribuir para enviar a versão para grupos/testadores ou para a loja.

Atualizações obrigatórias

Torne uma versão obrigatória para forçar todos os usuários a executar a mesma versão do seu aplicativo. Quando você fizer isso, o App Center instalará a atualização selecionada em todos os dispositivos de teste.

Você só pode tornar uma versão obrigatória se seu aplicativo usar o SDK de distribuição do App Center. Torne uma versão obrigatória marcando a caixa de seleção Atualização obrigatória na etapa de revisão da distribuição de uma versão, ou você pode usar a API.

Pode ver as versões obrigatórias no App Center abrindo [A sua aplicação] > Distribuir > Grupos > Versões. As libertações obrigatórias são indicadas por um ponto vermelho.

Link para Releases

Depois de lançar com sucesso, seus testadores podem acessar a versão por e-mail, fazendo login no App Center ou por meio de um link direto.

Você pode encontrar links para lançamentos específicos na página de lançamento para destinos privados.

Você pode encontrar links para lançamentos específicos para destinos públicos na guia lançamentos em grupos públicos.