Distribua suas compilações de iOS de pré-lançamento mais rapidamente com App Distribution e fastlane

1. Antes de começar

Neste codelab, você aprenderá a usar o Firebase App Distribution e seu plug-in fastlane para distribuir um aplicativo iOS para testadores, coletar UDIDs de dispositivos de teste e registrá-los no perfil de provisionamento do seu aplicativo, para que você possa obter compilações Ad Hoc rapidamente nos testadores ' mãos.

O que você vai aprender

• Como fazer upload e distribuir um aplicativo iOS de pré-lançamento (Ad Hoc) para testadores usando Firebase App Distribution e fastlane .
• Como se inscrever como testador e baixar o aplicativo distribuído em um dispositivo de teste.
• Como registrar rapidamente dispositivos de teste exportando UDIDs de dispositivos de teste com o plug-in fastlane do App Distribution.
• Como atualizar o perfil de provisionamento do seu aplicativo e recarregá-lo para distribuição.

O que você precisará

• Uma conta do Google
• Uma máquina Apple com o XCode 11.7+ instalado
• Um aplicativo iOS de pré-lançamento Ad Hoc integrado ao Xcode
• Uma conta de desenvolvedor Apple paga
• Um dispositivo iOS físico para teste.

O aplicativo do simulador para iOS funcionará para a maior parte do codelab, mas os simuladores não podem baixar versões.

Você ainda pode verificar se a configuração funcionou verificando se o botão "Download" aparece no aplicativo Web do testador do App Distribution.

2. Comece

Configurar via rápida

O App Distribution se integra ao fastlane para permitir que você automatize a distribuição de compilações de pré-lançamento do seu aplicativo. O App Distribution se integra à sua configuração fastlane .

1. Instale e configure o fastlane .
2. Execute fastlane init no diretório raiz do seu projeto durante a instalação e escolha "Configuração manual". Você verá um subdiretório chamado fastlane que contém um Fastfile , Appfile e Pluginfile , que você usará para configurar fastlane .

3. Crie seu aplicativo com fastlane

Crie seu aplicativo

1. Defina algumas variáveis ​​globais para fastlane em seu ./fastlane/Appfile. Inclua o ID do seu aplicativo e seu ID Apple:

app_identifier("<your app's bundle identifier>")
apple_id("<your Apple id>")

2. Crie sua primeira pista e use a ação build_app do build_app (também conhecida como gym ) para construir seu aplicativo adicionando o seguinte ao seu ./fastlane/Fastfile :

default_platform(:ios)

lane :build do
    build_app(export_method: "ad-hoc")
end

3. Assine seu aplicativo para distribuição.

Para este codelab, você gerenciará sua própria certificação e perfil usando get_certificates (também conhecido como cert ), que gera certificados de assinatura localmente e armazena tudo no seu macOS Keychain. Normalmente, no entanto, você desejará usar a sync_code_signing action fastlane sync_code_signing (também conhecida como match ) para gerenciar com segurança os certificados e perfis de assinatura de código de sua equipe.

lane :build do
    get_certificates()
    build_app(export_method: "ad-hoc")
end

4. Configure um perfil de provisionamento para seu aplicativo usando a ação get_provisioning_profile (também conhecida como sigh ). Isso permite que você compartilhe seu aplicativo com testadores.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

5. [Opcional] Se você nunca executou seu aplicativo antes, execute o seguinte comando para criar seu aplicativo no console do desenvolvedor da Apple:

$ fastlane produce --skip_itc

6. Por fim, crie seu aplicativo executando a pista.

Você será solicitado a fornecer seu ID Apple, senha (que está armazenada em seu Keychain) e o ID do pacote do seu aplicativo.

$ fastlane build

Se você encontrar algum problema, consulte o guia de solução de problemas do fastlane .

4. Faça upload do seu aplicativo para o Firebase

Agora que você criou seu aplicativo, está pronto para carregá-lo no App Distribution.

Criar e configurar um projeto do Firebase

1. Faça login no Firebase.
2. No console do Firebase, crie ou adicione um novo projeto e nomeie-o como "UDID Export Codelab".

Você não precisa ativar o Google Analytics para este projeto.

3. Clique em Criar projeto .

Adicione seu aplicativo iOS ao projeto

1. Clique no ícone do iOS para criar um novo aplicativo Firebase para iOS e insira o ID do pacote do seu aplicativo.

2. Pule as próximas etapas e clique em Continuar no console . Você adicionará SDKs ao seu aplicativo posteriormente.

Seu projeto e aplicativo agora estão disponíveis na página Visão geral do projeto .

Ativar distribuição de aplicativos

1. Na seção Release & Monitor, clique em App Distribution .
2. Depois de aceitar os termos, clique em "Começar" para habilitar o App Distribution para seu aplicativo.

Configurar uma distribuição no fastlane

1. Execute o seguinte comando na raiz do seu projeto iOS para adicionar o App Distribution à sua configuração de via rápida .

Se o comando solicitar uma opção, selecione a Opção 3: RubyGems.org :

$ fastlane add_plugin firebase_app_distribution

2. Confirme se o plug-in está instalado:

$ fastlane

A saída deve mostrar fastlane-plugin-firebase_app_distribution na lista de plugins instalados.

3. Após confirmar que o plugin está instalado, escolha a opção 0 para cancelar.

Autenticar seu projeto do Firebase

Para usar o plug-in fastlane , você primeiro autenticará seu projeto do Firebase.

1. Execute o seguinte comando:

$ fastlane run firebase_app_distribution_login

2. Quando o comando imprimir um link de autenticação, abra o link em um navegador.
3. Quando solicitado, faça login na sua Conta do Google e conceda permissão para acessar seu projeto do Firebase.

Copie o código resultante do navegador de login e cole-o na linha de comando.

4. A ação de login imprime um token de atualização, que o plug-in App Distribution usa para autenticar com o Firebase:

5. Passe o token definindo a variável de ambiente FIREBASE_TOKEN :

$ export FIREBASE_TOKEN= <token>

Distribua seu aplicativo

Agora você está pronto para distribuir seu aplicativo.

1. Na parte superior de seu ./fastlane/Fastfile , defina uma variável chamada firebase_app_id . Substitua <your_app_id> pelo ID do aplicativo do Firebase para o aplicativo que você criou (isso pode ser encontrado na página de configurações do projeto ).

O Fastfile é escrito em Ruby, então use a sintaxe Ruby para definir variáveis.

firebase_app_id = "<your_app_id>"

2. Adicione uma nova via chamada distribute que chama a via de construção e, em seguida, distribua seu aplicativo usando a ação firebase_app_distribution .

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

3. Execute a nova rota para criar seu aplicativo e criar uma distribuição.

$ fastlane distribute

Neste ponto, seu Fastfile deve se parecer com o seguinte:

firebase_app_id = "<your Firebase app ID>"

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
    )
end

Depois de atualizar o console do Firebase, você verá a nova versão do seu app.

5. Convide testadores para baixar seu aplicativo

Quando um testador aceita um convite para testar uma compilação Ad Hoc, é solicitada permissão para compartilhar seu UDID. Se eles concordarem, o App Distribution coletará as informações do dispositivo e o notificará por e-mail. Nesta seção, você se adicionará como testador para baixar e testar o aplicativo distribuído.

Adicione-se como um testador à versão

1. Em firebase_app_id na parte superior do Fastfile, crie uma variável para armazenar testadores e inclua seu próprio endereço de e-mail, bem como outros endereços de e-mail opcionais que você gostaria de experimentar.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

2. Aplique o método Array#join do Ruby para transformar o array app_testers em uma string separada por vírgula, que o parâmetro testers espera. Em seguida, passe o resultado para o parâmetro testers de firebase_app_distribution.

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!"
        testers: app_testers.join(","),
    )
end

Neste ponto, seu Fastfile deve ficar assim:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
        testers: app_testers.join(","),
    )
end

3. Execute a pista novamente.

$ fastlane distribute

Depois de executar a pista, os testadores que você adicionou receberão um e-mail de convite do App Distribution notificando-os sobre a nova versão disponível. No console do Firebase, agora você pode ver os testadores adicionados na versão do seu app.

Como você incluiu seu endereço de e-mail, receberá um e-mail do Firebase App Distribution convidando-o a testar o aplicativo. Você agora é o primeiro testador! Continue a seção abaixo para configurar como testador em seu dispositivo de teste.

Registre seu dispositivo de teste

Como testador, você precisará fazer login no Google em seu dispositivo de teste para acessar as versões do app para as quais foi convidado a testar. Como sua versão de teste é uma versão Ad Hoc, você também precisará registrar seu dispositivo de teste instalando o perfil do Firebase. Depois, as versões que ficam disponíveis para você podem ser acessadas no aplicativo Web do testador do App Distribution, usando o clipe da Web adicionado à tela inicial do seu dispositivo.

1. No dispositivo de teste iOS, abra o e-mail enviado do Firebase App Distribution e toque no link Primeiros passos . Certifique-se de abrir o link no Safari.
2. Agora você está no aplicativo Web do testador do App Distribution. Na página exibida, faça login com sua conta do Google e toque em Aceitar convite.

3. Agora você pode ver os lançamentos para os quais foi convidado. Toque em Registrar dispositivo em uma das versões.

4. Quando solicitado, baixe o perfil do Firebase e instale-o no aplicativo Configurações.

A instalação do perfil concede ao Firebase permissão para:

• Registre o dispositivo de teste coletando o ID exclusivo do dispositivo (UDID).

O Firebase envia a todos os proprietários e editores do projeto Firebase um e-mail que inclui o UDID do dispositivo de teste.

• Instale um web clip na tela inicial do dispositivo de teste. O clipe da Web abre o aplicativo Web do testador do App Distribution, que permite instalar e acessar todos os seus aplicativos de teste.

No aplicativo Web do testador do App Distribution, seu dispositivo de teste agora está registrado para a versão do seu aplicativo.

Observação: se você já adicionou este dispositivo à sua conta de desenvolvedor no passado, ele pode já ter sido incluído no perfil de provisionamento e você já verá um botão "Download" aqui.

Agora que você compartilhou o UDID do seu dispositivo de teste com o Firebase, pode retomar como desenvolvedor. Na guia Testadores do painel do App Distribution , as informações do seu testador agora aparecem na versão do seu aplicativo com o status "Aceito":

Na próxima seção, você adicionará o UDID do dispositivo ao perfil de provisionamento do aplicativo e criará uma versão do aplicativo que funcione com o dispositivo de teste.

Exporte os UDIDs do dispositivo testador

Como desenvolvedor, você receberá um e-mail do Firebase contendo o UDID do dispositivo de teste. Como opção, o App Distribution facilita a coleta de vários UDIDs de dispositivos novos de uma só vez, permitindo exportá-los diretamente do console do Firebase como um arquivo de texto bruto.

1. Para exportar todos os UDIDs, abra a guia Testers & Groups .

2. Clique em Exportar UDIDs da Apple .

O arquivo deve conter o UDID do seu dispositivo de teste.

Device ID            Device Name                            Device Platform
1234567890     [e-mail] - iPhone SE 2nd Gen        ios

Os UDIDs também podem ser exportados da linha de comando usando fastlane , o que você fará na próxima seção.

6. Atualize o perfil de provisionamento do seu aplicativo e reconstrua-o

Agora, você adicionará o UDID do dispositivo de teste ao perfil de provisionamento do aplicativo, reconstruirá uma versão do aplicativo que funcione para o dispositivo e distribuirá a nova versão.

Adicionar linha de exportação UDID

1. Adicione outra variável na parte superior de seu Fastfile e defina-a como um caminho de arquivo onde os UDIDs de dispositivo de seus testadores serão baixados.

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

2. Configure uma nova lane que use a ação de exportação UDID do plug-in App Distribution para baixar os UDIDs do testador, assim como você fez no console.

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

3. Execute a seguinte pista para baixar os UDIDs.

$ fastlane download_udids

4. Imprima o arquivo baixado, que deve conter os UDIDs do dispositivo de teste.

$ cat tester_udids.txt

Adicionar dispositivos ao console do desenvolvedor da Apple

1. Crie a seguinte via para adicionar os UDIDs à ​​sua lista de dispositivos no console do desenvolvedor da Apple, para que você possa adicioná-los ao seu perfil de provisionamento usando a ação register_devices do fastlane :

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

2. Em seguida, execute a pista:

$ fastlane add_new_devices

Você deverá ver os novos dispositivos na lista de dispositivos do console do desenvolvedor .

Adicionar dispositivos ao seu perfil de provisionamento

1. Adicione o argumento force à etapa do perfil de provisionamento em sua pista de build , para forçá-lo a selecionar novos dispositivos toda vez que você compilar.

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

Execute novamente a pista para construir e carregar

Agora, você atualizará sua faixa de distribute com as novas faixas para adicionar os dispositivos ao perfil de provisionamento, reconstruir o aplicativo e distribuí-lo.

1. Chame as novas pistas de distribute :

lane :distribute do
    download_udids
    add_new_devices
    build
    firebase_app_distribution(
        app: "1:123456789:ios:abcd1234",
        release_notes: "Try out this app!"
        testers: app_testers.join(","),
    )
end

2. Execute a pista de distribute :

$ fastlane distribute

Neste ponto, seu Fastfile deve ficar assim:

firebase_app_id = "<your Firebase app ID>"
app_testers = [
  "[e-mail]",
  "[e-mail]",
]
tester_udids_file = "tester_udids.txt"

default_platform(:ios)

lane :build do
    get_certificates()
    get_provisioning_profile(adhoc: true, force: true)
    build_app(export_method: "ad-hoc")
end

lane :distribute do
    download_udids
    add_new_devices
    build
    firebase_app_distribution(
        app: firebase_app_id,
        release_notes: "Try out this app!",
        testers: app_testers.join(","),
    )
end

lane :download_udids do
    firebase_app_distribution_get_udids(
        app: firebase_app_id,
        output_file: tester_udids_file,
    )
end

lane :add_new_devices do
    register_devices(devices_file: tester_udids_file)
end

Baixe a versão do dispositivo de teste

Agora que seu aplicativo inclui os UDIDs do dispositivo de teste, eles podem ser instalados nos dispositivos de teste.

1. Em seu dispositivo de teste, retorne ao aplicativo Web do testador do App Distribution usando o link no e-mail ou o ícone na tela inicial do dispositivo.

Ao navegar até o aplicativo codelab UDID, você pode ver que a versão está pronta para download.

2. Se você estiver em um dispositivo físico, pressione download, instale e execute o aplicativo!

Observação: os downloads de versão funcionam apenas em dispositivos físicos. Se você estiver em um simulador, o download não funcionará, mas você ainda poderá verificar se a configuração funcionou verificando se o botão "Download" aparece no aplicativo Web do testador do App Distribution.

7. Parabéns

Agora você configurou o App Distribution e o fastlane para automatizar seu processo de teste de pré-lançamento. Agora, quando você quiser convidar testadores adicionais ou adicionar seus UDIDs ao seu aplicativo, você só precisará executar um comando: fastlane distribute .

Portanto, não é mais necessário coletar UDIDs individualmente de testadores ou acessar o console de desenvolvedor da Apple para atualizar listas de dispositivos ou perfis de provisionamento. Você nem precisa abrir o XCode!

Esse fluxo de trabalho é fácil de configurar para ser executado de hora em hora ou diariamente em seu ambiente de integração contínua.

Leitura adicional

• Explore os recursos do Firebase App Distribution , incluindo nosso SDK no aplicativo para iOS
• Saiba mais sobre Fastlane
• Gerencie a assinatura de código da sua equipe com match
• Integre o fastlane ao seu CI