Nota: Existen limitaciones conocidas sobre el uso de Bazel para compilar apps para Android. Visita la lista de tareas importantes del equipo de Android de GitHub para ver la lista de problemas conocidos. Si bien el equipo de Bazel y los colaboradores de software de código abierto (OSS) trabajan activamente para abordar los problemas conocidos, los usuarios deben tener en cuenta que Android Studio no admite oficialmente proyectos de Bazel.
En este instructivo, se explica cómo compilar una app para Android simple con Bazel.
Bazel admite la compilación de apps para Android con las reglas de Android.
Este instructivo está dirigido a usuarios de Windows, macOS y Linux, y no requiere experiencia en el desarrollo de apps para Android o Bazel. No es necesario que escribas código de Android en este instructivo.
Qué aprenderás
En este instructivo, aprenderás a hacer lo siguiente:
- Para configurar tu entorno, instala Bazel y Android Studio, y descarga el proyecto de ejemplo.
- Configura un lugar de trabajo de Bazel que contenga el código fuente
para la app y un archivo
MODULE.bazel
que identifique el nivel superior del directorio del lugar de trabajo. - Actualiza el archivo
MODULE.bazel
para que contenga referencias a las dependencias externas requeridas, como el SDK de Android. - Crea un archivo
BUILD
. - Compila la app con Bazel.
- Implementa y ejecuta la app en un emulador de Android o dispositivo físico.
Antes de comenzar
Instala Bazel
Antes de comenzar el instructivo, instala el siguiente software:
- Bazel. Para instalarlo, sigue las instrucciones de instalación.
- Android Studio. Para instalarlo, sigue los pasos para descargar Android Studio. Ejecuta el asistente de configuración para descargar el SDK y configurar tu entorno.
- Git (opcional) Usa
git
para descargar el proyecto de la app para Android.
Obtén el proyecto de ejemplo
Para el proyecto de muestra, usa una app básica para Android en el repositorio de ejemplos de Bazel.
Esta app tiene un solo botón que imprime un saludo cuando se hace clic en él:
Figura 1: Saludo del botón de la app para Android.
Clona el repositorio con git
(o descarga el archivo ZIP directamente):
git clone https://github.com/bazelbuild/examples
El proyecto de muestra para este instructivo está en examples/android/tutorial
. Durante el resto del instructivo, ejecutarás comandos en este directorio.
Revisa los archivos fuente
Consulta los archivos de origen de la 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
Los archivos y directorios clave son los siguientes:
Nombre | Ubicación |
---|---|
Archivos de manifiesto de Android | src/main/AndroidManifest.xml y src/main/java/com/example/bazel/AndroidManifest.xml |
Archivos fuente de Android | src/main/java/com/example/bazel/MainActivity.java y Greeter.java |
Directorio de archivos de recursos | src/main/java/com/example/bazel/res/ |
Compila con Bazel
Configura el lugar de trabajo
Un lugar de trabajo es un directorio que contiene los archivos fuente de uno o más proyectos de software y tiene un archivo MODULE.bazel
en su raíz.
Es posible que el archivo MODULE.bazel
esté vacío o contenga referencias a dependencias externas necesarias para compilar tu proyecto.
Primero, ejecuta el siguiente comando para crear un archivo MODULE.bazel
vacío:
SO | Comando |
---|---|
Linux y macOS | touch MODULE.bazel |
Windows (Símbolo del sistema) | type nul > MODULE.bazel |
Windows (PowerShell) | New-Item MODULE.bazel -ItemType file |
Ejecuta Bazel
Ahora puedes verificar si Bazel se ejecuta correctamente con el comando:
bazel info workspace
Si Bazel imprime la ruta de acceso del directorio actual, puedes continuar. Si el archivo MODULE.bazel
no existe, es posible que veas un mensaje de error como el siguiente:
ERROR: The 'info' command is only supported from within a workspace.
Cómo realizar la integración con el SDK de Android
Bazel necesita ejecutar las herramientas de compilación del SDK de Android para compilar la app. Esto significa que debes agregar información a tu archivo MODULE.bazel
para que Bazel sepa dónde encontrarlas.
Agrega la siguiente línea a tu archivo MODULE.bazel
:
bazel_dep(name = "rules_android", version = "0.5.1")
Esto usará el SDK de Android en la ruta de acceso a la que hace referencia la variable de entorno ANDROID_HOME
y detectará automáticamente el nivel de API más alto y la versión más reciente de las herramientas de compilación instaladas en esa ubicación.
Puedes establecer la variable ANDROID_HOME
en la ubicación del SDK de Android. Encuentra la ruta al SDK instalado con SDK Manager de Android Studio.
Si suponemos que el SDK está instalado en ubicaciones predeterminadas, puedes usar los siguientes
comandos para configurar la variable ANDROID_HOME
:
SO | Comando |
---|---|
Linux | export ANDROID_HOME=$HOME/Android/Sdk/ |
macOS | export ANDROID_HOME=$HOME/Library/Android/sdk |
Windows (Símbolo del sistema) | set ANDROID_HOME=%LOCALAPPDATA%\Android\Sdk |
Windows (PowerShell) | $env:ANDROID_HOME="$env:LOCALAPPDATA\Android\Sdk" |
Los comandos anteriores configuran la variable solo para la sesión de shell actual. Para hacerlos permanentes, ejecuta los siguientes comandos:
SO | Comando |
---|---|
Linux | echo "export ANDROID_HOME=$HOME/Android/Sdk/" >> ~/.bashrc |
macOS | echo "export ANDROID_HOME=$HOME/Library/Android/Sdk/" >> ~/.bashrc |
Windows (Símbolo del sistema) | setx ANDROID_HOME "%LOCALAPPDATA%\Android\Sdk" |
Windows (PowerShell) | [System.Environment]::SetEnvironmentVariable('ANDROID_HOME', "$env:LOCALAPPDATA\Android\Sdk", [System.EnvironmentVariableTarget]::User) |
Opcional: Si deseas compilar código nativo en tu app para Android, también debes descargar el NDK de Android y usar rules_android_ndk
. Para ello, agrega la siguiente línea a tu archivo MODULE.bazel
:
bazel_dep(name = "rules_android_ndk", version = "0.1.2")
Para obtener más información, consulta Cómo usar el kit de desarrollo nativo de Android con Bazel.
No es necesario configurar los niveles de API con el mismo valor para el SDK y el NDK. En esta página, se incluye un mapa de las versiones de Android a los niveles de API compatibles con el NDK.
Crea un archivo BUILD
Un archivo BUILD
describe la relación entre un conjunto de resultados de compilación, como los recursos de Android compilados de aapt
o los archivos de clase de javac
, y sus dependencias. Estas dependencias pueden ser archivos fuente (Java, C++) en tu espacio de trabajo o en otros resultados de compilación. Los archivos BUILD
se escriben en un lenguaje llamado Starlark.
Los archivos BUILD
forman parte de un concepto en Bazel conocido como jerarquía de paquetes.
La jerarquía de paquetes es una estructura lógica que se superpone a la estructura de directorios de tu espacio de trabajo. Cada paquete es un directorio (y sus subdirectorios) que contiene un conjunto relacionado de archivos fuente y un archivo BUILD
. El paquete también incluye todos los subdirectorios, excepto aquellos que contienen su propio archivo BUILD
. El nombre del paquete es la ruta de acceso al archivo BUILD
en relación con el archivo MODULE.bazel
.
Ten en cuenta que la jerarquía de paquetes de Bazel es conceptualmente diferente de la jerarquía de paquetes de Java de tu directorio de apps para Android, en el que se encuentra el archivo BUILD
, aunque los directorios se pueden organizar de manera idéntica.
En la app para Android simple de este instructivo, los archivos de origen en src/main/
componen un solo paquete de Bazel. Un proyecto más complejo puede tener muchos paquetes anidados.
Agrega una regla android_library
Un archivo BUILD
contiene varios tipos diferentes de declaraciones para Bazel. El tipo más importante es la regla de compilación, que le indica a Bazel cómo compilar un resultado de software intermedio o final a partir de un conjunto de archivos fuente o de otras dependencias. Bazel proporciona dos reglas de compilación, android_library
y android_binary
, que puedes usar para compilar una app para Android.
En este instructivo, primero usarás la
regla android_library
para indicarle a Bazel que compile un módulo de biblioteca de Android
a partir del código fuente y los archivos de recursos de la app. Luego, usarás la
regla android_binary
para indicarle a Bazel cómo compilar el paquete de aplicaciones para Android.
Crea un archivo BUILD
nuevo en el directorio src/main/java/com/example/bazel
y declara un nuevo 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/**"]),
)
La regla de compilación android_library
contiene un conjunto de atributos que especifican la información que Bazel necesita para compilar un módulo de biblioteca a partir de los archivos fuente.
También ten en cuenta que el nombre de la regla es greeter_activity
. Harás referencia a la
regla con este nombre como dependencia en la regla android_binary
.
Agrega una regla android_binary
La regla android_binary
compila el paquete de aplicación para Android (archivo .apk
) de tu app.
Crea un archivo BUILD
nuevo en el directorio src/main/
y declara un nuevo destino android_binary
:
src/main/BUILD
:
android_binary(
name = "app",
manifest = "AndroidManifest.xml",
deps = ["//src/main/java/com/example/bazel:greeter_activity"],
)
Aquí, el atributo deps
hace referencia al resultado de la regla greeter_activity
que agregaste al archivo BUILD
anterior. Esto significa que, cuando Bazel compila el resultado de esta regla, primero verifica si el resultado de la regla de la biblioteca greeter_activity
se compiló y está actualizado. De lo contrario, Bazel
lo compila y, luego, usa ese resultado para compilar el archivo de paquete de la aplicación.
Ahora, guarda y cierra el archivo.
Compila la app
Intenta compilar la app. Ejecuta el siguiente comando para compilar el destino android_binary
:
bazel build //src/main:app
El subcomando build
le indica a Bazel que compile el objetivo que sigue. El destino se especifica como el nombre de una regla de compilación dentro de un archivo BUILD
, junto con la ruta de acceso del paquete en relación con el directorio de tu espacio de trabajo. Para este ejemplo, el destino es app
y la ruta del paquete es //src/main/
.
Ten en cuenta que, a veces, puedes omitir la ruta de acceso del paquete o el nombre de destino, según tu directorio de trabajo actual en la línea de comandos y el nombre del destino. Para obtener más detalles sobre las etiquetas y las rutas de destino, consulta Etiquetas.
Bazel comenzará a compilar la app de ejemplo. Durante el proceso de compilación, su resultado será similar al siguiente:
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
Cómo ubicar los resultados de la compilación
Bazel coloca los resultados de las operaciones de compilación intermedias y finales en un conjunto
de directorios de salida por usuario y por espacio de trabajo. Estos directorios tienen symlinks desde las siguientes ubicaciones en el nivel superior del directorio del proyecto, donde se encuentra el archivo MODULE.bazel
:
bazel-bin
almacena archivos ejecutables binarios y otros resultados de compilación ejecutablesbazel-genfiles
almacena archivos de origen intermediarios generados por reglas de Bazelbazel-out
almacena otros tipos de resultados de compilación.
Bazel almacena el archivo .apk
de Android generado con la regla android_binary
en el directorio bazel-bin/src/main
, en el que el nombre del subdirectorio src/main
deriva
del nombre del paquete de Bazel.
En el símbolo del sistema, enumera el contenido de este directorio y busca el archivo app.apk
:
SO | Comando |
---|---|
Linux y macOS | ls bazel-bin/src/main |
Windows (Símbolo del sistema) | dir bazel-bin\src\main |
Windows (PowerShell) | ls bazel-bin\src\main |
Ejecuta la app
Ahora, puedes implementar la app en un emulador o dispositivo Android conectado desde la línea de comandos con el comando bazel
mobile-install
. Este comando usa Android Debug Bridge (adb
) para comunicarse con el dispositivo. Antes de la implementación, debes configurar tu dispositivo para usar adb
según las instrucciones que se indican en Android Debug Bridge antes de la implementación. También puedes instalar la app en el emulador de Android incluido en Android Studio. Asegúrate de que el emulador esté en ejecución antes de ejecutar el siguiente comando.
Ingresa lo siguiente:
bazel mobile-install //src/main:app
A continuación, busca y, luego, inicia la "app de instructivo de Bazel":
Figura 2: App de instructivo de Bazel.
¡Felicitaciones! Acabas de instalar tu primera app para Android compilada con Bazel.
Ten en cuenta que el subcomando mobile-install
también admite la marca --incremental
, que se puede usar para implementar solo las partes de la app que cambiaron desde la última implementación.
También admite la marca --start_app
para iniciar la app de inmediato cuando se instala.
Lecturas adicionales
Para obtener más detalles, consulta las siguientes páginas:
- Abre problemas en GitHub
- Más información sobre la instalación móvil
- Integra dependencias externas, como AppCompat, Guava y JUnit, desde los repositorios de Maven con rules_jvm_external.
- Ejecuta las pruebas de Robolectric con la integración de robolectric-bazel.
- Cómo probar tu app con pruebas de instrumentación de Android
- Integra código C y C++ en tu app para Android con el NDK
- Consulta más proyectos de ejemplo de Bazel sobre lo siguiente:
¡Buena compilación!