Tutorial do Bazel: criar um app para iOS

Informar um problema Mostrar fonte Por noite · 7,3 · 7,2 · 7,1 · 7,0 · 6,5

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

O que você vai aprender

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

• Configurar o ambiente instalando o Bazel e o Xcode e fazendo o download do exemplo de projeto
• configurar 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 ao arquivo dependências externas
• 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

Configurar o ambiente

Para começar, instale o Bazel e o Xcode e faça o download do projeto de amostra.

Instalar o Bazel

Siga as instruções de instalação para instalar o Bazel e o 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 amostra

Você também precisa encontrar o projeto de amostra para o tutorial no GitHub. O GitHub O repo tem duas ramificações: source-only e main. A ramificação source-only contém apenas os arquivos de origem do projeto. Você vai usar os arquivos neste neste tutorial. A ramificação main contém os dois arquivos de origem e os arquivos WORKSPACE e BUILD do Bazel foram concluídos. Você pode usar os arquivos neste para verificar seu trabalho quando tiver concluído as etapas do tutorial.

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

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

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

Configurar um espaço de trabalho

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

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

Observação: o Bazel em si não impõe requisitos para organizar a 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 a 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

Todo espaço de trabalho precisa ter um arquivo de texto chamado WORKSPACE localizado no nível superior espaço de trabalho. Este arquivo pode estar vazio ou conter referências às dependências externas necessárias para criar o de software.

Por enquanto, você vai criar um arquivo WORKSPACE vazio, que serve apenas para identifique o diretório do espaço de trabalho. Nas etapas posteriores, 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 do ESPAÇO DE TRABALHO

Para criar aplicativos para dispositivos Apple, o Bazel precisa extrair a versão mais recente Regras de build da Apple do repositório do GitHub. Para ativar isso, adicione o seguinte git_repository ao 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 o versão mais recente das regras build_apple no atributo tag. Verifique as dependências mais recentes necessárias projeto de rules_apple."

Observação: você precisa definir o valor do atributo name no git_repository para build_bazel_rules_apple, ou o build vai falhar.

Analisar os arquivos de origem

Dê uma olhada nos arquivos de origem do app localizados em $WORKSPACE/ios-app/UrlGet: Novamente, você está apenas conferindo esses arquivos agora para a estrutura do app. Não é necessário editar nenhuma 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 para iOS, o Bazel precisa carregar regras de build do próprio repositório do GitHub. sempre que o build é executado. Para disponibilizar essas regras em seu projeto, adicione o a seguir instrução de carregamento no início do seu arquivo BUILD:

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

Você só precisa carregar a regra ios_application, porque objc_library é incorporada no pacote do Bazel.

Adicionar uma regra objc_library

O Bazel inclui várias regras de build que podem ser usadas para criar um app para o plataforma iOS. Para este tutorial, primeiro você vai usar o Regra objc_library para informar ao Bazel como criar uma biblioteca estática usando o código-fonte do app e os arquivos Xib. Depois, você vai usar 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 em o Bazel Por exemplo, é necessário usar a regra ios_application para criar apps iOS 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 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 o mínimo versão do iOS com a qual você planeja oferecer compatibilidade.

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. Você pode comparar seu arquivo BUILD com o exemplo completo na ramificação main do repositório do GitHub.

Criar e implantar o app

Agora você está pronto para criar seu aplicativo e implantá-lo em um simulador e em uma dispositivo iOS.

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

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

Os arquivos WORKSPACE e BUILD concluídos deste tutorial estão localizados no ramificação principal do repositório do GitHub. Você pode comparar seu trabalho com os arquivos concluídos ajuda ou solução de problemas adicionais.

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, digite o seguinte 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 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 do build

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

Executar e depurar o app no simulador

Agora você pode executar o app pelo Xcode usando o iOS Simulator. Primeiro, Gere um projeto Xcode usando o Tulsi.

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

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

Criar o app para um dispositivo

Para criar um app que possa ser instalado e iniciado em um dispositivo iOS, o Bazel precisa o perfil de provisionamento apropriado 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 adequado para o dispositivo. Consulte Documentação da Apple para 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 aplicativo 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 de gordura. Para criar para um dispositivo específico arquitetônica, designe-a nas opções de build.

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

Para especificar a versão mínima necessária do iOS, adicione minimum_os_version para a regra de build ios_application no arquivo BUILD.

Você também pode usar Tulsi para crie 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 aplicativo no dispositivo é iniciar o Xcode e usar o Windows > Devices. Selecione o dispositivo conectado na lista da tela à esquerda, depois adicione o aplicativo clicando no botão Adicionar (sinal de adição) abaixo "Apps instalados" e selecionando o arquivo .ipa que você criou.

Se a instalação do aplicativo falhar, especifique o perfil de provisionamento correto no arquivo BUILD (etapa 4 na ).

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

Leitura adicional

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