Tutorial do Bazel: criar um app Android

Informar um problemaopen_in_new Acessar fonteopen_in_new

Observação:há limitações conhecidas para usar o Bazel na criação de apps Android. Acesse a lista de problemas conhecidos do Android (link em inglês) do GitHub. Embora a equipe do Bazel e os colaboradores de software de código aberto (OSS) 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.

Este tutorial mostra como criar um app Android simples usando o Bazel.

O Bazel oferece suporte à criação de apps Android usando as regras do Android.

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

Conteúdo

Neste tutorial, você vai aprender a:

• Para configurar o ambiente, instale o Bazel e o Android Studio e faça o download do projeto de exemplo.
• Crie um espaço de trabalho do Bazel que contenha o código-fonte do app e um arquivo WORKSPACE que identifique 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, 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 iniciar o tutorial, instale os seguintes softwares:

• Bazel. Para instalar, siga as instruções de instalação.
• Android Studio. Para instalar, siga as etapas para fazer o download do Android Studio. Execute o assistente de configuração para fazer o download do SDK e configurar o ambiente.
• (Opcional) Git. Use git para fazer o download do projeto de app Android.

Acessar o projeto de amostra

Para o projeto de exemplo, use um projeto básico de app Android no repositório de exemplos do Bazel (link em inglês).

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

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. No restante do tutorial, você executará comandos nesse diretório.

Revise 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 do arquivo de recursos	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 os arquivos de origem de um ou mais projetos de software e tem um arquivo WORKSPACE na raiz.

O arquivo WORKSPACE pode estar vazio ou conter referências a dependências externas necessárias para criar seu 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 é possível verificar se o Bazel está sendo executado corretamente com o comando:

bazel info workspace

Se o Bazel mostrar o caminho do diretório atual, está tudo pronto. Se o arquivo WORKSPACE não existir, 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 as ferramentas de build do SDK do Android para criar o app. Isso significa que você precisa adicionar algumas informações ao arquivo WORKSPACE para que o Bazel saiba onde encontrá-las.

Adicione a linha a seguir ao arquivo WORKSPACE:

android_sdk_repository(name = "androidsdk")

Isso vai usar o SDK do Android no caminho referenciado pela variável de ambiente ANDROID_HOME e detectar automaticamente o nível mais alto da API e a 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. Encontre o caminho para o SDK instalado usando o SDK Manager do Android Studio. Supondo que o SDK esteja instalado nos locais padrão, você pode usar os seguintes comandos 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 torná-los 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)

Você também pode 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 atributos path, api_level e build_tools_version. Se api_level e build_tools_version não forem especificados, a regra android_sdk_repository usará a respectiva versão mais recente disponível no SDK. É possível especificar qualquer combinação desses atributos, desde que estejam presentes no SDK, por 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, ou seja, um caminho do Windows com barras:

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

Opcional:se você quiser compilar código nativo no seu app Android, também será necessário fazer o download do NDK Android e informar ao Bazel onde ele pode ser encontrado adicionando a seguinte linha ao arquivo WORKSPACE:

android_ndk_repository(name = "androidndk")

Assim como 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 ser especificado explicitamente com um atributo path em android_ndk_repository.

Para saber mais, leia Como usar o Kit de desenvolvimento nativo do Android com o Bazel.

api_level é a versão da API do Android que o SDK e o NDK direcionam, por exemplo, 23 para o Android 6.0 e 25 para o Android 7.1. Se não for definido explicitamente, api_level assumirá como padrão o nível mais alto de API 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 aos 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 Android compilados 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 em outras saídas de build. Arquivos BUILD 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 à estrutura de diretórios no espaço de trabalho. Cada pacote é um diretório (e os subdiretórios) dele 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 em relação ao WORKSPACE.

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

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

Adicionar uma regra android_library

Um arquivo BUILD contém vários tipos diferentes de declarações para o Bazel. O tipo mais importante é a regra de build, que informa ao Bazel como criar uma saída de software intermediária ou final de um conjunto de arquivos de origem ou outras dependências. O Bazel oferece duas regras de build, android_library e android_binary, que podem ser usadas para criar um app Android.

Neste tutorial, primeiro você usará a regra android_library para dizer ao Bazel para criar um módulo de biblioteca do Android usando o código-fonte e os arquivos de recursos do app. Em seguida, use a regra android_binary para informar ao Bazel como criar o pacote de apps Android.

Crie um novo arquivo BUILD no diretório src/main/java/com/example/bazel e declare 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 as informações de que o Bazel precisa para criar um módulo de biblioteca com base nos arquivos de origem. O nome da regra também é greeter_activity. Você fará referência à 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 aplicativos Android (arquivo .apk) para o aplicativo.

Crie um novo arquivo BUILD no diretório src/main/ e declare 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 a saída dessa regra, ele verifica primeiro se a saída da regra de biblioteca greeter_activity foi criada e atualizada. Caso contrário, ele é criado pelo Bazel e usado para criar o arquivo de pacote do aplicativo.

Agora salve e feche o arquivo.

Criar o app

Tente criar o app. Execute o seguinte comando para criar o destino android_binary:

bazel build //src/main:app

O subcomando build instrui o Bazel a criar o destino a seguir. O destino é especificado como o nome de uma regra de build dentro de um arquivo BUILD, com o caminho do pacote relativo ao diretório do espaço de trabalho. 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 do diretório de trabalho atual na linha de comando e do nome do destino. Para mais detalhes sobre os rótulos e caminhos de destino, consulte Rótulos.

O Bazel começará a criar o app de amostra. 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 são vinculados aos seguintes locais no nível superior do diretório do projeto, em que WORKSPACE é:

• O bazel-bin armazena executáveis binários e outras saídas de build executáveis
• bazel-genfiles armazena arquivos de origem intermediários gerados pelas 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 arquivo app.apk:

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 na linha de comando usando o comando bazel mobile-install. Esse comando usa o Android Debug Bridge (adb) para se comunicar com o dispositivo. Configure o dispositivo para usar adb seguindo as instruções no Android Debug Bridge antes da implantação. Você também pode instalar o app no Android Emulator incluído no Android Studio. Antes de executar o comando abaixo, verifique se o emulador está em execução.

Digite o seguinte:

bazel mobile-install //src/main:app

Em seguida, encontre e inicie o "App Tutorial do Bazel":

Figura 2. Tutorial do app do Bazel.

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

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

Ele também é compatível com a sinalização --start_app para iniciar o app imediatamente após a instalação.

Leia mais

Para mais detalhes, consulte estas páginas:

• Problemas abertos no GitHub
• Mais informações sobre mobile-install
• Integre dependências externas, como AppCompat, Guava e JUnit, a partir de repositórios do Maven usando rules_jvm_external (link em inglês).
• executar testes Robolectric com a integração do robolectric-bazel;
• Como testar seu app com os testes de instrumentação do Android
• Integrar código C e C++ no seu app Android com o NDK
• Confira mais projetos de exemplo do Bazel em:
  • um app Kotlin.
  • Teste do Robolectric
  • Testes do Espresso

Divirta-se!