Instructivo de Bazel: Compila una app para Android

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á destinado a usuarios de Windows, macOS y Linux, y no requiere experiencia con Bazel ni con el desarrollo de apps para Android. No es necesario que escribas ningún código de Android en este instructivo.

Qué aprenderás

En este instructivo, aprenderás a hacer lo siguiente:

• Configurar tu entorno mediante la instalación de Bazel y Android Studio, y la descarga del proyecto de muestra
• Configurar un espacio 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 espacio de trabajo.
• Actualizar el archivo MODULE.bazel para que contenga referencias a las dependencias externas requeridas, como el SDK de Android.
• Crear un archivo BUILD
• Compilar la app con Bazel
• Implementar y ejecutar la app en un emulador de Android o un 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.
• (Opcional) Git. Usa git para descargar el proyecto de app para Android.

Obtén el proyecto de muestra

Para el proyecto de muestra, usa un proyecto básico de app 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 se encuentra en examples/android/tutorial. Durante el resto del instructivo, ejecutarás comandos en este directorio.

Revisa los archivos fuente

Echa un vistazo a los archivos fuente 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:

Compila con Bazel

Configura el espacio de trabajo

Un espacio 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.

El archivo MODULE.bazel puede estar vacío o contener referencias a dependencias externas necesarias para compilar tu proyecto.

Primero, ejecuta el siguiente comando para crear un archivo MODULE.bazel vacío:

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, todo está listo. 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.

Realiza 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 MODULE.bazel archivo 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 ANDROID_HOME variable de entorno 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. Busca la ruta de acceso al SDK instalado con el SDK Manager de Android Studio. Si se supone que el SDK está instalado en las ubicaciones predeterminadas, puedes usar los siguientes comandos para establecer la ANDROID_HOME variable:

Los comandos anteriores establecen la variable solo para la sesión de shell actual. Para que sean permanentes, ejecuta los siguientes comandos:

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 establecer los niveles de API en el mismo valor para el SDK y el NDK. Esta página contiene 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 la jerarquía de paquetes. La jerarquía de paquetes es una estructura lógica que superpone la estructura de directorios en tu espacio de trabajo. Cada paquete es un directorio (y sus subdirectorios) que contiene un conjunto relacionado de archivos fuente y un BUILD archivo. El paquete también incluye cualquier subdirectorio, excluyendo aquellos que contienen su propio archivo BUILD. El nombre del paquete es la ruta de acceso al BUILD archivo en relación con el MODULE.bazel archivo.

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 BUILDaunque los directorios pueden organizarse de forma idéntica.

En el caso de la app para Android simple de este instructivo, los archivos fuente de src/main/ comprenden 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 android_library regla para indicarle a Bazel que compile un módulo de biblioteca de Android a partir del código fuente de la app y los archivos de recursos. Luego, usarás la android_binary regla para indicarle a Bazel cómo compilar el paquete de aplicación para Android.

Crea un archivo BUILD nuevo en el directorio src/main/java/com/example/bazel, y declara un destino android_library nuevo:

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. Ten en cuenta también que el nombre de la regla es greeter_activity. Harás referencia a la regla con este nombre como una dependencia en la android_binary regla.

Agrega una regla android_binary

La android_binary regla compila el paquete de aplicación para Android (archivo .apk) para tu app.

Crea un archivo BUILD nuevo en el directorio src/main/, y declara un destino android_binary nuevo:

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 greeter_activity regla de biblioteca se compiló y está actualizado. Si no es así, Bazel lo compila y, luego, usa ese resultado para compilar el archivo de paquete de aplicación.

Ahora, guarda y cierra el archivo.

Compila la app

Intenta compilar la app. Ejecuta el siguiente comando para compilar el android_binary destino:

bazel build //src/main:app

El build subcomando le indica a Bazel que compile el destino que sigue. El destino se especifica como el nombre de una regla de compilación dentro de un BUILD archivo, 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 de acceso del paquete es //src/main/.

Ten en cuenta que, a veces, puedes omitir la ruta de acceso del paquete o el nombre del destino, según el 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 acceso de destino, consulta Etiquetas.

Bazel comenzará a compilar la app de muestra. 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

Ubica los resultados de 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 están vinculados de forma simbólica 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 ejecutables.
• bazel-genfiles almacena archivos fuente intermediarios que generan las reglas de Bazel.
• bazel-out almacena otros tipos de resultados de compilación.

Bazel almacena el archivo de Android .apk generado con la regla android_binary en el directorio bazel-bin/src/main, en el que el nombre del subdirectorio src/main se deriva del nombre del paquete de Bazel.

En un símbolo del sistema, muestra el contenido de este directorio y busca el app.apk archivo:

Ejecuta la app

Ahora puedes implementar la app en un dispositivo Android o emulador conectado desde la línea de comandos con el bazel mobile-install comando. Este comando usa Android Debug Bridge (adb) para comunicarse con el dispositivo. Debes configurar tu dispositivo para usar adb siguiendo las instrucciones de 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 ejecuta la "Bazel Tutorial App":

Figura 2: App del 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 --incremental marca 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 inmediatamente después de instalarla.

Lecturas adicionales

Para obtener más detalles, consulta las siguientes páginas:

• Problemas abiertos en GitHub
• Más información sobre mobile-install
• Integra dependencias externas como AppCompat, Guava y JUnit desde repositorios de Maven con rules_jvm_external
• Ejecuta pruebas de Robolectric con la integración de robolectric-bazel.
• Prueba 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 de lo siguiente:
  • una app de Kotlin
  • pruebas de Robolectric
  • pruebas de Espresso

¡Suerte en el proceso de compilación!