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 Reglas de Android.
Este instructivo está dirigido a usuarios de Windows, macOS y Linux, y no se requieren experiencia en desarrollo de apps para Android o Bazel. No es necesario escribir código de Android en este instructivo.
Qué aprenderás
En este instructivo, aprenderás a hacer lo siguiente:
- Configurar tu entorno instalando Bazel y Android Studio. descargando el proyecto de muestra.
- Configura un lugar de trabajo de Bazel que contenga el código fuente.
para la app y un archivo
WORKSPACE
que identifica el nivel superior de la Workspace. - Actualiza el archivo
WORKSPACE
para que contenga referencias al archivo dependencias externas, 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 en 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 instalarla, 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 de app básica para Android en 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
. Para
en el resto del instructivo, ejecutarás comandos en este directorio.
Revisa los archivos fuente
Revisa 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:
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 espacio de trabajo
Un lugar de trabajo es un directorio que contiene el
archivos de origen para uno o más proyectos de software, y tiene un archivo WORKSPACE
en
su raíz.
Es posible que el archivo WORKSPACE
esté vacío o contenga referencias a referencias externas
las dependencias necesarias para compilar tu proyecto.
Primero, ejecuta el siguiente comando para crear un archivo WORKSPACE
vacío:
SO | Comando |
---|---|
Linux y macOS | touch WORKSPACE |
Windows (Símbolo del sistema) | type nul > WORKSPACE |
Windows (PowerShell) | New-Item WORKSPACE -ItemType file |
Ejecuta Bazel
Ahora puedes verificar si Bazel se ejecuta correctamente con el siguiente comando:
bazel info workspace
Si Bazel imprime la ruta de acceso del directorio actual, puedes continuar. Si el botón
WORKSPACE
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 el SDK de Android.
herramientas de compilación
para compilar la app. Esto significa que debes agregar información a tu
WORKSPACE
para que Bazel sepa dónde encontrarlos.
Agrega la siguiente línea a tu archivo WORKSPACE
:
android_sdk_repository(name = "androidsdk")
Se usará el SDK de Android en la ruta a la que hace referencia ANDROID_HOME
.
variable de entorno y detectar automáticamente el nivel de API más alto y la
la última versión de las herramientas de compilación instalada en esa ubicación.
Puedes establecer la variable ANDROID_HOME
en la ubicación del SDK de Android. Buscar
la ruta de acceso al SDK instalado usando el SDK de Android Studio
Administrador.
Si el SDK está instalado en las ubicaciones predeterminadas, puedes usar lo siguiente
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 hacer 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) |
También puedes especificar explícitamente la ruta de acceso absoluta del SDK de Android,
el nivel de API y la versión de las herramientas de compilación para usar con la inclusión de path
atributos api_level
y build_tools_version
. Si api_level
y
Si no se especifican build_tools_version
, la regla android_sdk_repository
usar la versión respectiva más reciente disponible en el SDK. Puedes especificar cualquier
combinación de estos atributos, siempre que estén presentes en el SDK, por
ejemplo:
android_sdk_repository(
name = "androidsdk",
path = "/path/to/Android/sdk",
api_level = 25,
build_tools_version = "30.0.3"
)
En Windows, ten en cuenta que el atributo path
debe usar la ruta de acceso de estilo mixto, que
es una ruta de Windows con barras diagonales:
android_sdk_repository(
name = "androidsdk",
path = "c:/path/to/Android/sdk",
)
Opcional: Si quieres compilar código nativo en tu app para Android, puedes
también debes descargar la app de Android
NDK
Luego, agrega la siguiente línea a tu archivo WORKSPACE
para indicarle a Bazel dónde encontrarlo.
android_ndk_repository(name = "androidndk")
Al igual que android_sdk_repository
, se infiere la ruta de acceso al NDK de Android.
de la variable de entorno ANDROID_NDK_HOME
de forma predeterminada. La ruta también puede
especificarse de forma explícita con un atributo path
en android_ndk_repository
Para obtener más información, lee Cómo usar el kit de desarrollo nativo de Android con Bazel
api_level
es la versión de la API de Android a la que el SDK y el NDK
objetivo, por ejemplo, 23 para Android 6.0 y 25 para Android 7.1. Si no es así
establecido de forma explícita, api_level
usa, de forma predeterminada, el nivel de API más alto disponible para
android_sdk_repository
y android_ndk_repository
.
No es necesario configurar los niveles de API con 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 admitidos por el NDK.
Cómo crear un archivo BUILD
Un archivo BUILD
describe la relación.
entre un conjunto de resultados de compilación, como recursos compilados de Android desde aapt
o
archivos de clase de javac
y sus dependencias. Estas dependencias pueden ser
archivos de origen (Java, C++) en tu espacio de trabajo o en otros resultados de compilación. BUILD
archivos
están escritos 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 al directorio
en tu lugar de trabajo. Cada paquete es un
directorio (y sus subdirectorios) que contiene un conjunto relacionado de archivos de origen.
y un archivo BUILD
. El paquete también incluye cualquier subdirectorio, excepto
aquellos que contienen su propio archivo BUILD
. El nombre del paquete es la ruta de acceso
BUILD
en relación con el WORKSPACE
.
Ten en cuenta que la jerarquía de paquetes de Bazel es conceptualmente diferente de la de Java
jerarquía de paquetes del directorio de tu app para Android en la que se encuentra el archivo BUILD
ubicados, aunque los directorios pueden estar organizados de forma idéntica.
En el caso de la app para Android simple de este instructivo, los archivos de origen en src/main/
comprenden un único paquete de Bazel. Un proyecto más complejo puede tener muchos
proyectos anidados
paquetes.
Agrega una regla android_library
Un archivo BUILD
contiene varios tipos diferentes de declaraciones para Bazel. El
el tipo más importante es el
regla de compilación, que le indica
Bazel sobre cómo compilar una salida de software intermedia o final a partir de un conjunto de fuentes
archivos u otras dependencias. Bazel proporciona dos reglas de compilación:
android_library
y
android_binary
, que puedes usar para
compilar una app para Android.
Para este instructivo, primero usarás el
Regla android_library
para indicarle a Bazel que compile una biblioteca de Android
módulo
desde el código fuente de la app
y los archivos de recursos. A continuación, usarás
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
que Bazel necesita para compilar un módulo de biblioteca a partir de los archivos fuente.
Además, ten en cuenta que el nombre de la regla es greeter_activity
. Harás referencia al
con este nombre como dependencia en la regla android_binary
.
Agrega una regla android_binary
La regla android_binary
compila
el paquete de aplicaciones de 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 comprueba si el resultado de la
La regla de la biblioteca greeter_activity
se compiló y está actualizada. Si no es así, Bazel
lo compila y, luego, usa ese resultado para compilar el archivo del paquete de la aplicación.
Ahora, guarda y cierra el archivo.
Compila la app
Intenta compilar la app. Ejecuta el siguiente comando para compilar la
android_binary
objetivo:
bazel build //src/main:app
El subcomando build
le indica a Bazel que compile el
objetivo. El destino se especifica como el nombre de una regla de compilación dentro de
Un archivo BUILD
, junto con la ruta del paquete relativa a 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 de destino y las rutas, consulta Etiquetas.
Bazel comenzará a compilar la app de ejemplo. Durante el proceso de compilación, el resultado tendrá un aspecto 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 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 symlink.
desde las siguientes ubicaciones en el nivel superior del directorio del proyecto, donde
WORKSPACE
es:
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
, donde el nombre del subdirectorio src/main
es
se deriva del nombre del paquete de Bazel.
En el símbolo del sistema, muestra el contenido de este directorio y busca app.apk
archivo:
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
la línea de comandos con el comando bazel
mobile-install
. Este comando usa
Android Debug Bridge (adb
) para comunicarse con el dispositivo. Debes configurar
que tu dispositivo use adb
. Para ello, sigue las instrucciones que se indican en Android Debug
establecer conexión antes de la implementación. Tú
También puedes instalar la app en el emulador de Android incluido en Android.
a Looker Studio. Asegúrate de que se esté ejecutando el emulador antes de ejecutar el siguiente comando.
Ingresa lo siguiente:
bazel mobile-install //src/main:app
A continuación, busca e 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
marca --incremental
que se puede usar para
implementar solo aquellas partes de la app que hayan cambiado desde la última implementación.
También admite la marca --start_app
para iniciar la app de inmediato.
instalarlo.
Lecturas adicionales
Para obtener más detalles, consulta estas páginas:
- Problemas abiertos en GitHub
- Más información sobre la instalación móvil
- Integra dependencias externas como AppCompat, Guava y JUnit desde Maven. repositorios con rules_jvm_external
- Ejecuta pruebas de Robolectric con robolectric-bazel y la integración de datos.
- Cómo probar tu app con pruebas de instrumentación de Android
- Cómo integrar código C y C++ en tu app para Android con el NDK
- Consulta más proyectos de ejemplo de Bazel de:
¡Feliz compilación!