Fastlane para iOS

Como otimizar seu tempo automatizando

Chegou a grande hora! Finalmente você vai colocar seu app em produção e subir pra loja. Aí você abre o portal do App Store Connect, clica em criar um novo app e… Pois é, além de passar algumas horas tendo que criar e validar os certificados e provisioning profiles (tópico esse que podemos abordar em outro post), também precisamos tirar várias screenshots da aplicação para não só mostrar como o app funciona, mas também para convencer os usuários em potencial a baixá-lo (ah, ainda sempre se preocupando com que nenhum erro acabe passando batido, porque se não, um novo set de imagens será necessário e com isso mais tempo será perdido).

Então, como é possível otimizar esse tempo? E como manter uma entrega contínua sem a necessidade de fazer todo esse processo na mão? Simples: utilizando o Fastlane.

O que é o Fastlane?

É uma ferramenta open source escrita em Ruby para continuous delivery de aplicações iOS e Android ou, segundo a documentação deles:

“fastlane is the easiest way to automate beta deployments and releases for your iOS and Android apps. It handles all tedious tasks, like generating screenshots, dealing with code signing, and releasing your application”

Como funciona?

A “mágica” toda acontece por meio dos actions, que são comandos do Fastlane que podemos executar no terminal, ou por meio de lanes configuradas no Fastfile (um arquivo de configuração que contém todo o passo-a-passo do que precisa ser executado). Alguns desses actions são:

• scan: roda os testes do projeto;
• gym: compila e gera o pacote da aplicação;
• snapshot: tira localized screenshots de forma automática para cada device necessário;
• frameit: permite inserir informações, personalizar plano de fundo ou gerar mockups com devices dos screenshots batidos;
• cert: cria (se necessário) e gerencia os certificados para code signing;
• sigh: pode criar, renovar, fazer o download e reparar provisioning profiles;
• match: sincroniza certificados e provisioning profiles para o time de desenvolvimento por meio do Git;
• pilot: automatiza o deploy para o TestFlight e gerencia os usuários para testes;
• pem: cria e renova os push notification profiles;
• deliver: realiza o upload dos screenshots, metadata e binários para a App Store Connect;
• produce: cria o aplicativo no Apple Developer Portal e na App Store Connect com as informações mínimas necessárias.

Beleza, mas como se usa?

Primeiro, você precisa de um macOS (o suporte ao Windows e Linux está a caminho) e dependendo da action que você vai utilizar também vai ser necessário uma conta de desenvolvedor.

Mas vamos lá, você também precisa ter certeza que a última versão do Xcode command line tools está instalada no seu mac.

Para isso rode no terminal:

Depois, é necessário instalar o Fastlane, que pode ser por meio do RubyGems ou por Homebrew:

ou

Pronto! Agora você já pode começar a configuração própria para o seu projeto. Para isso execute no terminal dentro do diretório do projeto:

Ah! O Fastlane também permite ser configurado em Swift, basta executar “fastlane init swift”. Mas como ainda está em beta, aqui vamos usar a configuração padrão em Ruby, certo?

Agora, o Fastlane vai detectar automaticamente o seu projeto e você vai precisar escolher uma dentre as quatro opções:

Vamos escolher a opção número “4”, pois vamos apresentar a ferramenta de forma incremental e algumas das actions necessárias para realizar essa automação, focando por enquanto apenas em entender como o fastlane funciona, rodar uma lane de testes e uma lane para gerar os screenshots. Então, depois de pressionar “Enter” mais outras três vezes e tudo ocorrendo conforme o esperado, temos o Fastlane configurado e a seguinte saída no terminal:

Fácil, não é? Se você for visualizar os arquivos criados no diretório do seu projeto, vai perceber que foram criados na raiz do projeto um Gemfile e um Gemfile.lock (é recomendável usar um gerenciador de Gems, como o Bundler), além de uma nova pasta chamada fastlane, com mais outros dois arquivos dentro, o Fastfile e o Appfile.

Fastfile: arquivo que armazena as configurações de automação que são executadas pelo fastlane.

Appfile: arquivo que armazena informações úteis e necessárias como o Apple ID ou o Bundle Identifier da aplicação, dentre outras informações necessárias para realizar o deploy de forma rápida e adaptadas às necessidades do projeto.

No fastfile vamos utilizar lanes para definir os processos que o fastlane deve rodar. Aqui está a estrutura base de uma lane:

Para acioná-la, basta rodar no terminal dentro do diretório do seu projeto:

ou

E aí o fastlane vai executar as actions descritas na lane (ou até mesmo métodos do Ruby), que no exemplo acima são: action1, action2 e my_own_action.

Mas agora vamos realmente montar uma lane para execução de testes e rodá-la. Começaremos abrindo o fastfile, que originalmente tem essa cara:

Vamos agora adicionar a action “scan” (que é um alias para a action “run_tests”), passando alguns parâmetros a serem seguidos. Assim, toda vez que acionarmos a lane “custom_lane” o fastlane vai rodar os testes do projeto conforme especificado.

Dessa maneira, nosso fastfile deve ficar:

E ao acionarmos essa lane via terminal:

Todos os testes executados serão do scheme “MyAppTests” e rodados no simulador do iPhone 8. Ocorrendo tudo conforme o esperado, teremos um output com o log da operação e a seguinte mensagem de sucesso:

Legal, né? Da mesma forma que utilizamos a action “scan” para rodar os testes também podemos utilizar diversas outras actions que sejam necessárias para otimizar o nosso tempo. E como nosso foco é exatamente otimizar o tempo e minimizar possíveis falhas, automatizar os snapshots da aplicação é uma task relevante e a action “snapshot” serve exatamente para isso! Para começar a usar, execute no terminal (no diretório do seu projeto) o seguinte comando:

Você deverá ver o seguinte output:

E agora é só seguir os passos informados:

1. Adicione um novo target de teste de UI ao seu projeto;
2. Na pasta do fastlane do seu projeto existe agora um arquivo chamado “SnapshotHelper.swift”, esse arquivo precisa ser adicionado ao target de teste de UI e pode ficar localizado onde você achar melhor;
3. Chame o método `setupSnapshot(app)` no launch do seu app, e adicione o comando “snapshot(“ScreenName”)” sempre que quiser registrar a tela exibida no teste;
4. Crie um novo scheme para o target de teste criado;
5. Marque a opção de “Shared” nos ajustes do scheme criado.

Pronto, você também pode passar parâmetros de configuração específicos das imagens a serem registradas na action “snapshot”, ou utilizar o arquivo Snapfile gerado para definir essas configurações.

Por exemplo, vamos limitar a lista de devices dos screenshots para apenas o iPhone 8, assim como também vamos ativar a flag clear_previous_screenshots para sempre que rodarmos a action, snapshots previamente existentes serão apagadas e novos serão gerados. Dessa forma, se fossemos gerar uma lane de screenshots, ela ficaria parecida com essa:

Agora basta acionar via terminal:

Ou, como dito antes, poderíamos passar essas configurações por meio do Snapfile e, fazendo assim, ele vai ficar com a seguinte configuração:

Agora, com o Snapfile atualizado, você pode acioná-lo a partir de uma lane qualquer, ou chamar a action direto do terminal

E após a task ser finalizada, um relatório será exibido com todas as imagens obtidas de todos os devices selecionados. Bem bacana, não é?

É isso, se ficou alguma dúvida ou se você tem alguma sugestão e contribuição, só deixar um comentário. Valeu, e até a próxima!