Tutorial do Bazel: criar um app Android

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

Observação:há limitações conhecidas no uso do Bazel para a criação de apps Android. Acesse a lista de hotlist da equipe do Android no GitHub para conferir os problemas conhecidos. Embora a equipe do Bazel e os colaboradores de software de código aberto (OSS, na sigla em inglês) trabalhem ativamente para resolver problemas conhecidos, os usuários precisam estar cientes de que o Android Studio não oferece suporte oficial a projetos do Bazel.

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

O Bazel permite a criação de apps Android usando a Regras do Android.

Este tutorial é destinado a usuários de Windows, macOS e Linux e não é necessária experiência com desenvolvimento de apps Android ou Bazel. Você não precisa escrever códigos Android neste tutorial.

O que você vai aprender

Neste tutorial, você vai aprender a:

  • Configurar o ambiente instalando o Bazel e o Android Studio. fazer o download do projeto de amostra.
  • configure um espaço de trabalho do Bazel que contenha o código-fonte. do app e um arquivo WORKSPACE que identifica o nível superior do espaço de trabalho.
  • Atualize o arquivo WORKSPACE para conter referências ao arquivo dependências externas, como o SDK do Android.
  • Crie um arquivo BUILD.
  • Crie o app com o Bazel.
  • Implante e execute o app em um emulador Android ou dispositivo físico.

Antes de começar

Instalar o Bazel

Antes de começar o tutorial, instale os seguintes softwares:

Acessar o projeto de amostra

Para o projeto de exemplo, use um projeto básico de app Android em Repositório de exemplos do Bazel.

Este app tem um único botão que mostra uma saudação quando clicado:

Saudação do botão

Figura 1. Saudação do botão do app Android.

Clone o repositório com git (ou faça o download do arquivo ZIP diretamente):

git clone https://github.com/bazelbuild/examples

O projeto de exemplo para este tutorial está em examples/android/tutorial. Para o restante do tutorial, você executará comandos nesse diretório.

Analisar os arquivos de origem

Dê uma olhada nos arquivos de origem do app.

.
├── README.md
└── src
    └── main
        ├── AndroidManifest.xml
        └── java
            └── com
                └── example
                    └── bazel
                        ├── AndroidManifest.xml
                        ├── Greeter.java
                        ├── MainActivity.java
                        └── res
                            ├── layout
                            │   └── activity_main.xml
                            └── values
                                ├── colors.xml
                                └── strings.xml

Os principais arquivos e diretórios são:

Nome Local
Arquivos de manifesto do Android src/main/AndroidManifest.xml e src/main/java/com/example/bazel/AndroidManifest.xml
Arquivos de origem do Android src/main/java/com/example/bazel/MainActivity.java e Greeter.java
Diretório de arquivos de recurso src/main/java/com/example/bazel/res/

Criação com o Bazel

Configurar o espaço de trabalho

Um espaço de trabalho é um diretório que contém o arquivos de origem para um ou mais projetos de software e tem um arquivo WORKSPACE em a raiz dele.

O arquivo WORKSPACE pode estar vazio ou conter referências a dependências necessárias para criar o projeto.

Primeiro, execute o seguinte comando para criar um arquivo WORKSPACE vazio:

SO Comando
Linux e macOS touch WORKSPACE
Windows (prompt de comando) type nul > WORKSPACE
Windows (PowerShell) New-Item WORKSPACE -ItemType file

Como executar o Bazel

Agora você pode verificar se o Bazel está sendo executado corretamente com o comando:

bazel info workspace

Se o Bazel imprimir o caminho do diretório atual, está tudo pronto. Se o WORKSPACE não existe, talvez você veja uma mensagem de erro como:

ERROR: The 'info' command is only supported from within a workspace.

Integrar com o SDK do Android

O Bazel precisa executar o SDK do Android ferramentas de build para criar o app. Isso significa que você precisa adicionar algumas informações WORKSPACE para que o Bazel saiba onde encontrá-los.

Adicione a linha a seguir ao arquivo WORKSPACE:

android_sdk_repository(name = "androidsdk")

Isso vai usar o SDK do Android no caminho referenciado pelo ANDROID_HOME. variável de ambiente e detectam automaticamente o nível mais alto da API e o versão mais recente das ferramentas de build instaladas nesse local.

Você pode definir a variável ANDROID_HOME como o local do SDK do Android. Localizar o caminho para o SDK instalado usando o SDK do Android Studio de usuário. Supondo que o SDK esteja instalado em locais padrão, você pode usar o seguinte para definir a variável ANDROID_HOME:

SO Comando
Linux export ANDROID_HOME=$HOME/Android/Sdk/
macOS export ANDROID_HOME=$HOME/Library/Android/sdk
Windows (prompt de comando) set ANDROID_HOME=%LOCALAPPDATA%\Android\Sdk
Windows (PowerShell) $env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk"

Os comandos acima definem a variável apenas para a sessão de shell atual. Para fazer eles permanentes, execute os seguintes comandos:

SO Comando
Linux echo "export ANDROID_HOME=$HOME/Android/Sdk/" >> ~/.bashrc
macOS echo "export ANDROID_HOME=$HOME/Library/Android/Sdk/" >> ~/.bashrc
Windows (prompt de comando) setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk"
Windows (PowerShell) [System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User)

Também é possível especificar explicitamente o caminho absoluto do SDK do Android, o nível da API e a versão das ferramentas de build a serem usadas, incluindo os path, api_level e build_tools_version. Se api_level e build_tools_version não forem especificadas, a regra android_sdk_repository use a respectiva versão mais recente disponível no SDK. É possível especificar uma combinação desses atributos, desde que estejam presentes no SDK, para exemplo:

android_sdk_repository(
    name = "androidsdk",
    path = "/path/to/Android/sdk",
    api_level = 25,
    build_tools_version = "30.0.3"
)

No Windows, observe que o atributo path precisa usar o caminho de estilo misto, que é um caminho do Windows com barras:

android_sdk_repository(
    name = "androidsdk",
    path = "c:/path/to/Android/sdk",
)

Opcional:se quiser compilar código nativo no seu app Android, também precisa fazer o download do aplicativo NDK e diga ao Bazel onde encontrá-lo adicionando a seguinte linha ao seu arquivo WORKSPACE:

android_ndk_repository(name = "androidndk")

Semelhante a android_sdk_repository, o caminho para o Android NDK é inferido da variável de ambiente ANDROID_NDK_HOME por padrão. O caminho também pode explicitamente especificado com um atributo path em android_ndk_repository;

Para mais informações, leia Como usar o Kit de desenvolvimento nativo do Android com Bazel.

api_level é a versão da API Android que o SDK e o NDK target, por exemplo, 23 para Android 6.0 e 25 para Android 7.1. Caso contrário definido explicitamente, api_level tem como padrão o nível de API mais alto disponível para android_sdk_repository e android_ndk_repository.

Não é necessário definir os níveis de API com o mesmo valor para o SDK e o NDK. Esta página contém um mapa das versões do Android para níveis de API compatíveis com o NDK.

Criar um arquivo BUILD

Um arquivo BUILD descreve a relação entre um conjunto de saídas de build, como recursos compilados do Android de aapt ou arquivos de classe de javac e as dependências deles. Essas dependências podem ser arquivos de origem (Java, C++) no seu espaço de trabalho ou outras saídas de build. BUILD arquivo são escritos em uma linguagem chamada Starlark.

Os arquivos BUILD fazem parte de um conceito no Bazel conhecido como hierarquia de pacotes. A hierarquia de pacotes é uma estrutura lógica que se sobrepõe ao diretório no seu espaço de trabalho. Cada pacote é um diretório (e seus subdiretórios) que contém um conjunto relacionado de arquivos de origem e um arquivo BUILD. O pacote também inclui todos os subdiretórios, exceto aqueles que contêm o próprio arquivo BUILD. O nome do pacote é o caminho para o Arquivo BUILD relativo ao WORKSPACE.

A hierarquia de pacotes do Bazel é conceitualmente diferente da hierarquia hierarquia de pacotes do diretório do app Android em que o arquivo BUILD está embora os diretórios possam ser organizados de forma idêntica.

Para o app Android simples deste tutorial, os arquivos de origem em src/main/ formam um único pacote do Bazel. Um projeto mais complexo pode ter muitos elementos pacotes.

Adicionar uma regra android_library

Um arquivo BUILD contém vários tipos diferentes de declarações para o Bazel. O o tipo mais importante é Regra de criação, que indica O Bazel mostra como criar uma saída de software intermediária ou final com base em um conjunto de origens. ou outras dependências. O Bazel fornece duas regras de build: android_library e android_binary, que você pode usar para criar um app Android.

Para este tutorial, primeiro você vai usar o Regra android_library para dizer ao Bazel para criar uma biblioteca Android módulo do código-fonte e dos arquivos de recursos do app. Em seguida, você vai usar android_binary para informar ao Bazel como criar o pacote de aplicativos para Android.

Crie um novo arquivo BUILD no diretório src/main/java/com/example/bazel. e declarar um novo destino android_library:

src/main/java/com/example/bazel/BUILD:

package(
    default_visibility = ["//src:__subpackages__"],
)

android_library(
    name = "greeter_activity",
    srcs = [
        "Greeter.java",
        "MainActivity.java",
    ],
    manifest = "AndroidManifest.xml",
    resource_files = glob(["res/**"]),
)

A regra de build android_library contém um conjunto de atributos que especificam o informações necessárias para o Bazel criar um módulo de biblioteca a partir dos arquivos de origem. Observe também que o nome da regra é greeter_activity. Você vai consultar regra usando esse nome como uma dependência na regra android_binary.

Adicionar uma regra android_binary

A regra android_binary cria o pacote de app Android (arquivo .apk) para seu app.

Crie um novo arquivo BUILD no diretório src/main/. e declarar um novo destino android_binary:

src/main/BUILD:

android_binary(
    name = "app",
    manifest = "AndroidManifest.xml",
    deps = ["//src/main/java/com/example/bazel:greeter_activity"],
)

Aqui, o atributo deps faz referência à saída da regra greeter_activity que você adicionou ao arquivo BUILD acima. Isso significa que, quando o Bazel cria o saída desta regra, ele verifica primeiro se a saída do greeter_activity regra de biblioteca foi criada e está atualizada. Caso contrário, o Bazel compila e usa essa saída para criar o arquivo de pacote do aplicativo.

Agora, salve e feche o arquivo.

Criar o app

Tente criar o app. Execute o comando a seguir para criar o android_binary meta:

bazel build //src/main:app

O subcomando build instrui o Bazel a criar o a seguir. O destino é especificado como o nome de uma regra de build Um arquivo BUILD com o caminho do pacote relativo ao seu espaço de trabalho diretório. Neste exemplo, o destino é app, e o caminho do pacote é //src/main/.

Às vezes, é possível omitir o caminho do pacote ou o nome do destino, dependendo seu diretório de trabalho atual na linha de comando e o nome do destino. Para mais detalhes sobre rótulos e caminhos de destino, consulte Rótulos.

O Bazel vai começar a criar o app de exemplo. Durante o processo de build, a saída será semelhante a esta:

INFO: Analysed target //src/main:app (0 packages loaded, 0 targets configured).
INFO: Found 1 target...
Target //src/main:app up-to-date:
  bazel-bin/src/main/app_deploy.jar
  bazel-bin/src/main/app_unsigned.apk
  bazel-bin/src/main/app.apk

Localizar as saídas de build

O Bazel coloca as saídas das operações de build intermediárias e finais em um conjunto de diretórios de saída por usuário e por espaço de trabalho. Esses diretórios têm links simbólicos dos seguintes locais no nível superior do diretório do projeto, em que o WORKSPACE é:

  • bazel-bin armazena executáveis binários e outras saídas de build executáveis
  • O bazel-genfiles armazena arquivos de origem intermediários que são gerados Regras do Bazel
  • bazel-out armazena outros tipos de saídas de build

O Bazel armazena o arquivo .apk do Android gerado usando a regra android_binary. no diretório bazel-bin/src/main, em que o nome do subdiretório src/main é derivado do nome do pacote do Bazel.

Em um prompt de comando, liste o conteúdo desse diretório e encontre o app.apk arquivo:

SO Comando
Linux e macOS ls bazel-bin/src/main
Windows (prompt de comando) dir bazel-bin\src\main
Windows (PowerShell) ls bazel-bin\src\main

Executar o app

Agora você pode implantar o app em um dispositivo ou emulador Android conectado pelo linha de comando usando o comando bazel mobile-install. Esse comando usa o Android Debug Bridge (adb) para se comunicar com o dispositivo. Você precisa configurar seu dispositivo para usar o adb seguindo as instruções em Android Debug Ponte antes da implantação. Você você também pode optar por instalar o app no Android Emulator incluído no Android Estúdio. Verifique se o emulador está em execução antes de executar o comando abaixo.

Digite o seguinte:

bazel mobile-install //src/main:app

Em seguida, localize e inicie o "Bazel Tutorial App":

App de tutorial do Bazel

Figura 2. App de tutorial do Bazel.

Parabéns! Você acabou de instalar seu primeiro app Android criado com o Bazel.

O subcomando mobile-install também oferece suporte ao sinalização --incremental que pode ser usada para implantar apenas as partes do aplicativo que foram alteradas desde a última implantação.

Ele também oferece suporte à flag --start_app para iniciar o app imediatamente após para instalá-lo.

Leitura adicional

Para mais detalhes, consulte estas páginas:

Boa construção!