Tutorial do Bazel: criar um app para iOS

Neste tutorial, mostramos como criar um app iOS simples usando o Bazel.

Conteúdo

Neste tutorial, você aprenderá a realizar as seguintes tarefas:

• Configurar o ambiente instalando o Bazel e o Xcode e fazendo o download do projeto de amostra
• Configure um espaço de trabalho do Bazel que continha o código-fonte do app e um arquivo WORKSPACE que identifica o nível superior do diretório do espaço de trabalho.
• Atualize o arquivo WORKSPACE para conter referências às dependências externas necessárias.
• Criar um arquivo BUILD
• Executar o Bazel para criar o app para o simulador e um dispositivo iOS
• Executar o app no simulador e em um dispositivo iOS

configure seu ambiente

Para começar, instale o Bazel e o Xcode e acesse o projeto de exemplo.

Instalar o Bazel

Siga as instruções de instalação para instalar o Bazel e as dependências dele.

Instalar o Xcode

Faça o download e instale o Xcode. O Xcode contém os compiladores, os SDKs e outras ferramentas exigidas pelo Bazel para criar aplicativos da Apple.

Acessar o projeto de exemplo

Você também precisa fazer o download do projeto de amostra para o tutorial no GitHub. O repositório do GitHub tem duas ramificações: source-only e main. A ramificação source-only contém os arquivos de origem apenas do projeto. Você usará os arquivos desta ramificação neste tutorial. A ramificação main contém os arquivos de origem e os arquivos WORKSPACE e BUILD completos do Bazel. Use os arquivos nessa ramificação para verificar seu trabalho depois de concluir as etapas do tutorial.

Digite o seguinte na linha de comando para receber os arquivos na ramificação source-only:

cd $HOME
git clone -b source-only https://github.com/bazelbuild/examples

O comando git clone cria um diretório chamado $HOME/examples/. Ele contém vários projetos de amostra para o Bazel. Os arquivos de projeto deste tutorial estão em $HOME/examples/tutorial/ios-app.

Configurar um espaço de trabalho

Um workspace é um diretório que contém os arquivos de origem de um ou mais projetos de software, além de um arquivo WORKSPACE e BUILD que contêm as instruções que o Bazel usa para criar o software. O espaço de trabalho também pode conter links simbólicos para diretórios de saída.

Um diretório de espaço de trabalho pode estar localizado em qualquer lugar no sistema de arquivos e é indicado pela presença do arquivo WORKSPACE na raiz. Neste tutorial, o diretório do espaço de trabalho é $HOME/examples/tutorial/, que contém os arquivos de projeto de amostra que você clonou do repositório do GitHub na etapa anterior.

Observação :o próprio Bazel não impõe requisitos para organizar arquivos de origem no seu espaço de trabalho. Os arquivos de origem de amostra neste tutorial estão organizados de acordo com as convenções da plataforma de destino.

Para sua conveniência, defina a variável de ambiente $WORKSPACE agora para se referir ao diretório do espaço de trabalho. Na linha de comando, digite:

export WORKSPACE=$HOME/examples/tutorial

Criar um arquivo do ESPAÇO DE TRABALHO

Cada espaço de trabalho precisa ter um arquivo de texto chamado WORKSPACE, localizado no diretório de nível superior do espaço de trabalho. Esse arquivo pode estar vazio ou conter referências a dependências externas necessárias para criar o software.

Por enquanto, você vai criar um arquivo WORKSPACE vazio, que serve apenas para identificar o diretório do espaço de trabalho. Nas próximas etapas, você atualizará o arquivo para adicionar informações de dependência externa.

Digite o seguinte na linha de comando:

touch $WORKSPACE/WORKSPACE
open -a Xcode $WORKSPACE/WORKSPACE

Isso cria e abre o arquivo WORKSPACE vazio.

Atualizar o arquivo WORKSPACE

Para criar aplicativos para dispositivos Apple, o Bazel precisa extrair as regras de build da Apple mais recentes do repositório do GitHub. Para ativar esse recurso, adicione as regras git_repository abaixo ao seu arquivo WORKSPACE:

load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")

git_repository(
    name = "build_bazel_rules_apple",
    remote = "https://github.com/bazelbuild/rules_apple.git",
    tag = "0.19.0",
)

git_repository(
    name = "build_bazel_rules_swift",
    remote = "https://github.com/bazelbuild/rules_swift.git",
    tag = "0.13.0",
)

git_repository(
    name = "build_bazel_apple_support",
    remote = "https://github.com/bazelbuild/apple_support.git",
    tag = "0.7.2",
)

git_repository(
    name = "bazel_skylib",
    remote = "https://github.com/bazelbuild/bazel-skylib.git",
    tag = "0.9.0",
)

Observação: "sempre use a versão mais recente das regras build_apple no atributo tag. Verifique as dependências mais recentes necessárias no projeto de rules_apple."

Observação: você precisa definir o valor do atributo name na regra git_repository como build_bazel_rules_apple. Caso contrário, o build vai falhar.

Revisar os arquivos de origem

Observe os arquivos de origem do app localizados em $WORKSPACE/ios-app/UrlGet. Novamente, você está apenas observando esses arquivos para se familiarizar com a estrutura do app. Não é necessário editar nenhum dos arquivos de origem para concluir este tutorial.

Criar um arquivo BUILD

Em um prompt de linha de comando, abra um novo arquivo BUILD para edição:

touch $WORKSPACE/ios-app/BUILD
open -a Xcode $WORKSPACE/ios-app/BUILD

Adicionar a instrução de carregamento da regra

Para criar destinos iOS, o Bazel precisa carregar regras de build do repositório do GitHub sempre que o build é executado. Para disponibilizar essas regras no seu projeto, adicione a seguinte instrução de carregamento ao início do arquivo BUILD:

load("@build_bazel_rules_apple//apple:ios.bzl", "ios_application")

Você só precisa carregar a regra ios_application porque a regra objc_library está integrada ao pacote do Bazel.

Adicionar uma regra objc_library

Ele fornece várias regras de compilação que podem ser usadas para criar um aplicativo para a plataforma iOS. Neste tutorial, primeiro você usará a regra objc_library para informar ao Bazel como criar uma biblioteca estática com o código-fonte do app e os arquivos Xib. Em seguida, use a regra ios_application para informar como criar o binário do aplicativo e o pacote .ipa.

Observação: este tutorial apresenta um caso de uso mínimo das regras do Objective-C no Bazel. Por exemplo, você precisa usar a regra ios_application para criar apps iOS de multiarquitetura.

Adicione a instrução a seguir ao seu arquivo BUILD:

objc_library(
    name = "UrlGetClasses",
    srcs = [
         "UrlGet/AppDelegate.m",
         "UrlGet/UrlGetViewController.m",
         "UrlGet/main.m",
    ],
    hdrs = glob(["UrlGet/*.h"]),
    data = ["UrlGet/UrlGetViewController.xib"],
)

Anote o nome da regra, UrlGetClasses.

Adicionar uma regra ios_application

A regra ios_application cria o binário do aplicativo e o arquivo de pacote .ipa.

Adicione a instrução a seguir ao seu arquivo BUILD:

ios_application(
    name = "ios-app",
    bundle_id = "Google.UrlGet",
    families = [
        "iphone",
        "ipad",
    ],
    minimum_os_version = "9.0",
    infoplists = [":UrlGet/UrlGet-Info.plist"],
    visibility = ["//visibility:public"],
    deps = [":UrlGetClasses"],
)

Observação :atualize o atributo minimum_os_version para a versão mínima do iOS que você pretende oferecer.

Observe como o atributo deps faz referência à saída da regra UrlGetClasses que você adicionou ao arquivo BUILD acima.

Agora salve e feche o arquivo. Compare o arquivo BUILD com o exemplo completo na ramificação main do repositório do GitHub.

Criar e implantar o app

Agora está tudo pronto para criar e implantar o app em um simulador e em um dispositivo iOS.

Observação: o app é iniciado de forma independente, mas requer um servidor de back-end para produzir saída. Consulte o arquivo README no diretório do projeto de exemplo para saber como criar o servidor de back-end.

O app criado fica localizado no diretório $WORKSPACE/bazel-bin.

Os arquivos WORKSPACE e BUILD concluídos deste tutorial estão localizados na ramificação principal do repositório do GitHub. Compare seu trabalho com os arquivos concluídos para receber mais ajuda ou solucionar outros problemas.

Criar o app para o simulador

Verifique se o diretório de trabalho atual está dentro do espaço de trabalho do Bazel:

cd $WORKSPACE

Agora, insira o código abaixo para criar o app de exemplo:

bazel build //ios-app:ios-app

O Bazel inicia e cria o app de exemplo. Durante o processo de build, a saída dele será semelhante a esta:

INFO: Found 1 target...
Target //ios-app:ios-app up-to-date:
  bazel-bin/ios-app/ios-app.ipa
INFO: Elapsed time: 0.565s, Critical Path: 0.44s

Encontrar as saídas de build

O arquivo .ipa e outras saídas estão localizados no diretório $WORKSPACE/bazel-bin/ios-app.

Executar e depurar o app no simulador

Agora você pode executar o app no Xcode usando o simulador de iOS. Primeiro, gere um projeto Xcode usando o Tulsi (em inglês).

Em seguida, abra o projeto no Xcode, escolha um simulador de iOS como o esquema de ambiente de execução e clique em Executar.

Observação: se você modificar arquivos de projeto no Xcode (por exemplo, adicionar ou remover um arquivo ou adicionar ou alterar uma dependência), recrie o app usando o Bazel, gere novamente o projeto Xcode no Tulsi e abra o projeto novamente no Xcode.

Criar o app para um dispositivo

Para criar seu app para que ele seja instalado e iniciado em um dispositivo iOS, o Bazel precisa do perfil de provisionamento adequado para esse modelo de dispositivo. Faça o seguinte:

1. Acesse sua conta de desenvolvedor da Apple e faça o download do perfil de provisionamento apropriado para seu dispositivo. Consulte a documentação da Apple para ver mais informações.

2. Mova seu perfil para $WORKSPACE.

3. (Opcional) Adicione seu perfil ao arquivo .gitignore.

4. Adicione a seguinte linha ao destino ios_application no arquivo BUILD:

   provisioning_profile = "<your_profile_name>.mobileprovision",
   

Observação: verifique se o perfil está correto para que o app possa ser instalado em um dispositivo.

Agora, crie o app para seu dispositivo:

bazel build //ios-app:ios-app --ios_multi_cpus=armv7,arm64

Isso cria o app como um binário fat. Para criar uma arquitetura de dispositivo específica, designe-a nas opções de build.

Para criar para uma versão específica do Xcode, use a opção --xcode_version. Para criar para uma versão específica do SDK, use a opção --ios_sdk_version. A opção --xcode_version é suficiente na maioria dos cenários.

Para especificar uma versão mínima necessária do iOS, adicione o parâmetro minimum_os_version à regra de build ios_application no arquivo BUILD.

Você também pode usar o Tulsi para criar seu app usando uma GUI em vez da linha de comando.

Instalar o app em um dispositivo

A maneira mais fácil de instalar o app no dispositivo é iniciar o Xcode e usar o comando Windows > Devices. Selecione o dispositivo conectado na lista à esquerda e adicione o app clicando no botão Adicionar (sinal de adição) em "Apps instalados" e selecionando o arquivo .ipa que você criou.

Se a instalação do app falhar no dispositivo, verifique se você está especificando o perfil de provisionamento correto no arquivo BUILD (etapa 4 na seção anterior).

Se o app não for iniciado, verifique se o dispositivo faz parte do perfil de provisionamento. O botão View Device Logs na tela Devices no Xcode pode fornecer outras informações sobre o que deu errado.

Leia mais

Para saber mais, consulte a ramificação principal do repositório do GitHub.