Para obtener documentación sobre versiones estables, usa el menú desplegable "Documentos con versiones". La vista predeterminada refleja la versión más reciente en el encabezado.

Se usó la API de Cloud Translation para traducir esta página.

Reglas de Android

Informar un problema Ver el código fuente

objeto binario_android

Ver fuente de la regla

android_binary(name, deps, srcs, assets, assets_dir, compatible_with, crunch_png, custom_package, debug_key, debug_signing_keys, debug_signing_lineage_file, densities, deprecation, dex_shards, dexopts, distribs, enable_data_binding, exec_compatible_with, exec_properties, features, incremental_dexing, instruments, javacopts, key_rotation_min_sdk, licenses, main_dex_list, main_dex_list_opts, main_dex_proguard_specs, manifest, manifest_values, multidex, nocompress_extensions, package_id, plugins, proguard_apply_dictionary, proguard_apply_mapping, proguard_generate_mapping, proguard_specs, resource_configuration_filters, resource_files, restricted_to, shrink_resources, tags, target_compatible_with, testonly, visibility)

Produce archivos de paquetes de aplicaciones para Android (.apk).

Destinos de salida implícitos

name.apk: Es un archivo de paquete de aplicación para Android firmado con claves de depuración y zipalign, que se puede usar para desarrollar y depurar tu aplicación. No puedes liberar tu aplicación cuando se firma con las claves de depuración.
name_unsigned.apk: Una versión sin firma del archivo anterior que se podría firmar con las claves de lanzamiento antes del lanzamiento para el público.
name_deploy.jar: Es un archivo Java que contiene el cierre transitivo de este destino.
El archivo jar de implementación contiene todas las clases que puede encontrar un cargador de clases que buscó en la ruta de clase de tiempo de ejecución de este destino de principio a fin.
name_proguard.jar: Es un archivo Java que contiene el resultado de la ejecución de ProGuard en name_deploy.jar. Este resultado solo se produce si se especifica el atributo proguard_specs.
name_proguard.map: Es el resultado de la ejecución de ProGuard en un archivo de asignación en el name_deploy.jar. Este resultado solo se produce si se especifica el atributo proguard_specs y se configura proguard_generate_mapping o shrink_resources.

Ejemplos

Se pueden encontrar ejemplos de reglas de Android en el directorio examples/android del árbol de fuentes de Bazel.

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`deps`	`List of labels; optional` La lista de otras bibliotecas que se vincularán al destino binario. Los tipos de bibliotecas permitidos son los siguientes: `android_library`, `java_library` con restricción `android` y `cc_library` que unen o producen bibliotecas nativas `.so` para la plataforma de destino de Android.
`srcs`	`List of labels; optional` La lista de archivos de origen que se procesan para crear el destino. Se compilan `srcs` archivos de tipo `.java`. Para facilitar la lectura, no es recomendable colocar el nombre de un archivo de origen `.java` generado en `srcs`. En su lugar, coloca el nombre de la regla de dependencia en el `srcs`, como se describe a continuación. Los archivos `srcs` de tipo `.srcjar` están descomprimidos y compilados. (esto resulta útil si necesitas generar un conjunto de archivos .java con una regla genérica o extensión de compilación).
`assets`	`List of labels; optional` La lista de activos que se empaquetarán. Por lo general, es un `glob` de todos los archivos en el directorio `assets`. También puedes hacer referencia a otras reglas (cualquier regla que produzca archivos) o archivos exportados en los otros paquetes, siempre que todos esos archivos estén en el directorio `assets_dir` en el paquete correspondiente.
`assets_dir`	`String; optional` La string que proporciona la ruta a los archivos en `assets`. En el par `assets` y `assets_dir`, se describen los recursos empaquetados y se deben proporcionar ambos atributos o ninguno de ellos.
`crunch_png`	`Boolean; optional; default is True` Haga cálculos en formato PNG (o no). Esto es independiente del procesamiento de nueve parches, que siempre se realiza. Esta es una solución obsoleta para un error aaapt que se corrigió en aapt2.
`custom_package`	`String; optional` Paquete de Java para el cual se generarán fuentes de Java. De forma predeterminada, el paquete se infiere del directorio en el que se encuentra el archivo BUILD que contiene la regla. Puedes especificar un paquete diferente, pero no se recomienda, ya que puede introducir conflictos de rutas de clase con otras bibliotecas que solo se detectarán en el tiempo de ejecución.
`debug_key`	`Label; optional; default is @bazel_tools//tools/android:debug_keystore` Archivo que contiene el keystore de depuración que se usará para firmar el apk de depuración. Por lo general, no quieres usar una clave que no sea la predeterminada, por lo que debes omitir este atributo. ADVERTENCIA: No uses tus claves de producción, deben estar estrictamente protegidas y no deben conservarse en tu árbol fuente.
`debug_signing_keys`	`List of labels; optional` Lista de archivos y almacenes de claves de depuración que se usarán para firmar el apk de depuración. Por lo general, no quieres usar claves distintas de la predeterminada, por lo que se debe omitir este atributo. ADVERTENCIA: No uses tus claves de producción, deben estar estrictamente protegidas y no deben conservarse en tu árbol fuente.
`debug_signing_lineage_file`	`Label; optional` Archivo que contiene el linaje de firmas para las debug_signing_keys. Por lo general, no quieres usar claves distintas de la predeterminada, por lo que se debe omitir este atributo. ADVERTENCIA: No uses tus claves de producción, deben estar estrictamente protegidas y no deben conservarse en tu árbol fuente.
`densities`	`List of strings; optional` Densidades que se filtrarán cuando se compile el APK. De esta manera, se quitarán los recursos de elementos de diseño de trama que un dispositivo no debería cargar con las densidades de pantalla especificadas para reducir el tamaño del APK. También se agregará la sección compatible con pantallas correspondiente al manifiesto si aún no contiene una lista de superconjuntos.
`dex_shards`	`Integer; optional; default is 1` La dex de los fragmentos se debe descomponer. Esto hace que la conversión a dex sea mucho más rápida, a costa del tiempo de instalación y el tiempo de inicio de la app. Cuanto mayor sea el objeto binario, más fragmentos se deberán usar. 25 es un buen valor para comenzar a experimentar. Ten en cuenta que cada fragmento generará al menos un DEX en la app final. Por esta razón, no se recomienda configurar este valor en más de 1 para los objetos binarios de lanzamiento.
`dexopts`	`List of strings; optional` Marcas de línea de comandos adicionales para la herramienta dx cuando se genera class.dex. Sujeto a la sustitución "Make variable" y la asignación de token de Shell Bourne.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadero, esta regla procesa las expresiones de vinculación de datos en los recursos de diseño incluidos a través del atributo resource_files. Sin esta configuración, las expresiones de vinculación de datos producen fallas de compilación. A fin de compilar una app para Android con vinculación de datos, también debes hacer lo siguiente: Establece este atributo para todas las reglas de Android que dependen de forma transitiva de esta. Esto se debe a que las dependencias heredan las expresiones de vinculación de datos de la regla mediante la combinación de recursos. Por lo tanto, también deben realizar compilaciones con la vinculación de datos para analizar esas expresiones. Agrega una entrada `deps =` para la biblioteca del entorno de ejecución de vinculación de datos a todos los destinos que establecen este atributo. La ubicación de esta biblioteca depende de la configuración de tu depósito.
`incremental_dexing`	`Integer; optional; nonconfigurable; default is -1` Fuerza la compilación del destino con dex incremental o sin él, lo que anula los valores predeterminados y la marca --incremental_dexing.
`instruments`	`Label; optional` El destino `android_binary` para el instrumento Si se configura este atributo, este `android_binary` se tratará como una aplicación de prueba para las pruebas de instrumentación. Un objetivo `android_instrumentation_test` puede especificar este objetivo en su atributo test_app.
`javacopts`	`List of strings; optional` Opciones adicionales del compilador para este destino. Sujeto a la sustitución "Make variable" y la asignación de token de Shell Bourne. Estas opciones del compilador se pasan a javac después de las opciones del compilador global.
`key_rotation_min_sdk`	`String; optional` Establece la versión mínima de la plataforma de Android (nivel de API) para la que se debe usar la clave de firma rotada de un APK a fin de generar la firma del APK. La clave de firma original del APK se usará en todas las versiones anteriores de la plataforma.
`main_dex_list`	`Label; optional` Un archivo de texto contiene una lista de nombres de archivos de clases. Las clases definidas por esos archivos se ubican en las clases class.dex principales, p. ej.: android/support/multidex/MultiDex$V19.class android/support/multidex/MultiDex.class android/support/multidex/MultiDexApplication.class com/google/common/base/Objects.class Se debe usar con `multidex="manual_main_dex"`.
`main_dex_list_opts`	`List of strings; optional` Opciones de línea de comandos para pasar al compilador de listas dex principal. Usa esta opción para modificar las clases incluidas en la lista de dex principal.
`main_dex_proguard_specs`	`List of labels; optional` Archivos que se usarán como especificaciones de Proguard para determinar las clases que se deben conservar en el DEX principal. Solo se permite si el atributo `multidex` se establece en `legacy`.
`manifest`	`Label; required` Nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Debe definirse si se definen los archivos resource_files o de recursos.
`manifest_values`	`Dictionary: String -> String; optional` Un diccionario de valores que se anularán en el manifiesto. Cualquier instancia de ${name} en el manifiesto se reemplazará por el valor correspondiente al nombre en este diccionario. applicationId, versionCode, versionName, minSdkVersion, targetSdkVersion y maxSdkVersion también anularán los atributos correspondientes del manifiesto y las etiquetas uses-sdk. packageName se ignorará y se establecerá desde applicationId si se especifica o el paquete en manifiesto. Cuando el manifest_merger está configurado como heredado, solo los applicationId, versionCode y versionName tendrán efecto.
`multidex`	`String; optional; default is "native"` Indica si se debe dividir el código en varios archivos dex. Valores posibles: `native`: divide el código en varios archivos dex cuando se supere el límite de índice dex 64K. Se supone que la plataforma nativa admite la carga de clases multidex durante el tiempo de ejecución. Funciona solo con Android L y versiones posteriores. `legacy`: divide el código en varios archivos dex cuando se supere el límite de índice dex 64K. Supone que las clases multidex se cargan a través del código de la aplicación (es decir, sin compatibilidad con plataformas nativas). `manual_main_dex`: divide el código en varios archivos dex cuando se supere el límite de índice dex 64K. Se debe especificar el contenido del archivo dex principal proporcionando una lista de clases en un archivo de texto con el atributo main_dex_list. `off`: Compila todo el código en un solo archivo dex, incluso si excede el límite del índice.
`nocompress_extensions`	`List of strings; optional` Una lista de extensiones de archivo para no comprimir en el apk.
`package_id`	`Integer; optional; default is 0` El ID de paquete que se asignará a los recursos de este objeto binario. Consulta el argumento `--package-id` de AAPT2 para obtener más información. Por lo general, se puede (y se debe) dejar sin configurar, lo que da como resultado el valor predeterminado de 127 (`0x7F`).
`plugins`	`List of labels; optional` Complementos del compilador de Java para ejecutar en el tiempo de compilación Cada `java_plugin` especificado en el atributo de complementos se ejecutará cada vez que se compile este destino. Los recursos generados por el complemento se incluirán en el archivo jar del resultado del destino.
`proguard_apply_dictionary`	`Label; optional` Archivo que se usará como mapeo para ProGuard Un archivo de “palabras” separado de una línea para extraer cuando se cambia el nombre de las clases y los miembros durante la ofuscación.
`proguard_apply_mapping`	`Label; optional` Archivo que se usará como mapeo para ProGuard Un archivo de asignación generado por `proguard_generate_mapping` que se volverá a usar para aplicar la misma asignación a una compilación nueva.
`proguard_generate_mapping`	`Boolean; optional; nonconfigurable; default is False` Si se debe generar el archivo de asignación de ProGuard. El archivo de asignación se generará solo si se especifica `proguard_specs`. Este archivo mostrará una lista de la clase, el método y los nombres de campos ofuscados y originales. ADVERTENCIA: Si se usa este atributo, la especificación de Proguard no debe contener `-dontobfuscate` ni `-printmapping`.
`proguard_specs`	`List of labels; optional` Archivos que se usarán como especificación de Proguard. Este archivo describirá el conjunto de especificaciones que usará Proguard.
`resource_configuration_filters`	`List of strings; optional` Una lista de filtros de configuración de recursos, como "en" que limitará los recursos en el APK a solo los de la configuración "en". Para habilitar la pseudolocalización, incluye las pseudo configuraciones regionales `en_XA` o `ar_XB`.
`resource_files`	`List of labels; optional` La lista de recursos que se empaquetarán. Por lo general, es un `glob` de todos los archivos en el directorio `res`. También se puede hacer referencia a los archivos generados (de genrules) mediante Etiqueta. La única restricción es que los resultados generados deben estar en el mismo directorio "`res`" que cualquier otro archivo de recursos incluido.
`shrink_resources`	`Integer; optional; default is -1` Establece si se realizará la reducción de recursos. Los recursos que no use el objeto binario se quitarán del APK. Esto solo es compatible con reglas que usan recursos locales (es decir, los atributos `manifest` y `resource_files`) y requiere ProGuard. Funciona principalmente de la misma manera que el reductor de recursos de Gradle (https://developer.android.com/studio/build/shrink-code.html#shrink-resources). Diferencias destacadas: Se quitarán los recursos de `values/`, así como los recursos basados en archivos usa `strict mode` de forma predeterminada La eliminación de recursos de ID que no se usan solo es compatible con aapt2 Si se habilita la reducción de recursos, también se generará `name_files/resource_shrinker.log` en el que se detallará el análisis y las eliminaciones realizadas. Valores posibles: `shrink_resources = 1`: activa la reducción de recursos de Android `shrink_resources = 0`: Desactiva la reducción de recursos de Android `shrink_resources = -1`: La reducción se controla con la marca --android_resource_shrinking.

importar_aar

Ver fuente de la regla

aar_import(name, deps, data, aar, compatible_with, deprecation, distribs, exec_compatible_with, exec_properties, exports, features, licenses, restricted_to, srcjar, tags, target_compatible_with, testonly, visibility)

Esta regla permite el uso de archivos .aar como bibliotecas para las reglas android_library y android_binary.

Ejemplos

    aar_import(
        name = "google-vr-sdk",
        aar = "gvr-android-sdk/libraries/sdk-common-1.10.0.aar",
    )

    android_binary(
        name = "app",
        manifest = "AndroidManifest.xml",
        srcs = glob(["**.java"]),
        deps = [":google-vr-sdk"],
    )

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`aar`	`Label; required` Es el archivo `.aar` que se debe proporcionar a los destinos de Android que dependen de este destino.
`exports`	`List of labels; optional` Destinos para exportar a las reglas que dependen de esta regla. Consulta java_library.exports.
`srcjar`	`Label; optional` Un archivo JAR que contiene código fuente para los archivos JAR compilados en las AAR.

biblioteca_android

Ver fuente de la regla

android_library(name, deps, srcs, data, assets, assets_dir, compatible_with, custom_package, deprecation, distribs, enable_data_binding, exec_compatible_with, exec_properties, exported_plugins, exports, exports_manifest, features, idl_import_root, idl_parcelables, idl_preprocessed, idl_srcs, javacopts, licenses, manifest, neverlink, plugins, proguard_specs, resource_files, restricted_to, tags, target_compatible_with, testonly, visibility)

Esta regla compila y archiva sus fuentes en un archivo .jar. La biblioteca del entorno de ejecución de Android android.jar se coloca de forma implícita en la ruta de acceso de la clase de compilación.

Destinos de salida implícitos

libname.jar: Es un archivo Java.
libname-src.jar: Es un archivo que contiene las fuentes (“fuente jar”).
name.aar: Un paquete "aar" de Android que contiene el archivo Java y los recursos de este destino No contiene el cierre transitivo.

Ejemplos

Se pueden encontrar ejemplos de reglas de Android en el directorio examples/android del árbol de fuentes de Bazel.

En el siguiente ejemplo, se muestra cómo configurar idl_import_root. Permitir que //java/bazel/helloandroid/BUILD contenga lo siguiente:

android_library(
    name = "parcelable",
    srcs = ["MyParcelable.java"], # bazel.helloandroid.MyParcelable

    # MyParcelable.aidl will be used as import for other .aidl
    # files that depend on it, but will not be compiled.
    idl_parcelables = ["MyParcelable.aidl"] # bazel.helloandroid.MyParcelable

    # We don't need to specify idl_import_root since the aidl file
    # which declares bazel.helloandroid.MyParcelable
    # is present at java/bazel/helloandroid/MyParcelable.aidl
    # underneath a java root (java/).
)

android_library(
    name = "foreign_parcelable",
    srcs = ["src/android/helloandroid/OtherParcelable.java"], # android.helloandroid.OtherParcelable
    idl_parcelables = [
        "src/android/helloandroid/OtherParcelable.aidl" # android.helloandroid.OtherParcelable
    ],

    # We need to specify idl_import_root because the aidl file which
    # declares android.helloandroid.OtherParcelable is not positioned
    # at android/helloandroid/OtherParcelable.aidl under a normal java root.
    # Setting idl_import_root to "src" in //java/bazel/helloandroid
    # adds java/bazel/helloandroid/src to the list of roots
    # the aidl compiler will search for imported types.
    idl_import_root = "src",
)

# Here, OtherInterface.aidl has an "import android.helloandroid.CallbackInterface;" statement.
android_library(
    name = "foreign_interface",
    idl_srcs = [
        "src/android/helloandroid/OtherInterface.aidl" # android.helloandroid.OtherInterface
        "src/android/helloandroid/CallbackInterface.aidl" # android.helloandroid.CallbackInterface
    ],

    # As above, idl_srcs which are not correctly positioned under a java root
    # must have idl_import_root set. Otherwise, OtherInterface (or any other
    # interface in a library which depends on this one) will not be able
    # to find CallbackInterface when it is imported.
    idl_import_root = "src",
)

# MyParcelable.aidl is imported by MyInterface.aidl, so the generated
# MyInterface.java requires MyParcelable.class at compile time.
# Depending on :parcelable ensures that aidl compilation of MyInterface.aidl
# specifies the correct import roots and can access MyParcelable.aidl, and
# makes MyParcelable.class available to Java compilation of MyInterface.java
# as usual.
android_library(
    name = "idl",
    idl_srcs = ["MyInterface.aidl"],
    deps = [":parcelable"],
)

# Here, ServiceParcelable uses and thus depends on ParcelableService,
# when it's compiled, but ParcelableService also uses ServiceParcelable,
# which creates a circular dependency.
# As a result, these files must be compiled together, in the same android_library.
android_library(
    name = "circular_dependencies",
    srcs = ["ServiceParcelable.java"],
    idl_srcs = ["ParcelableService.aidl"],
    idl_parcelables = ["ServiceParcelable.aidl"],
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`deps`	`List of labels; optional` La lista de otras bibliotecas con las que se vinculará. Los tipos de bibliotecas permitidos son los siguientes: `android_library`, `java_library` con restricción `android` y `cc_library` que unen o producen bibliotecas nativas `.so` para la plataforma de destino de Android.
`srcs`	`List of labels; optional` La lista de archivos `.java` o `.srcjar` que se procesan para crear el destino. Se compilan `srcs` archivos de tipo `.java`. Para facilitar la lectura, no es recomendable colocar el nombre de un archivo de origen `.java` generado en `srcs`. En su lugar, coloca el nombre de la regla de dependencia en el `srcs`, como se describe a continuación. Los archivos `srcs` de tipo `.srcjar` están descomprimidos y compilados. (esto resulta útil si necesitas generar un conjunto de archivos .java con una regla genérica o extensión de compilación). Si se omite `srcs`, se exporta cualquier dependencia especificada en `deps` de esta regla (consulta Exportaciones de java_library para obtener más información sobre la exportación de dependencias). Sin embargo, este comportamiento dejará de estar disponible pronto; intenta no depender de él.
`assets`	`List of labels; optional` La lista de activos que se empaquetarán. Por lo general, es un `glob` de todos los archivos en el directorio `assets`. También puedes hacer referencia a otras reglas (cualquier regla que produzca archivos) o archivos exportados en los otros paquetes, siempre que todos esos archivos estén en el directorio `assets_dir` en el paquete correspondiente.
`assets_dir`	`String; optional` La string que proporciona la ruta a los archivos en `assets`. En el par `assets` y `assets_dir`, se describen los recursos empaquetados y se deben proporcionar ambos atributos o ninguno de ellos.
`custom_package`	`String; optional` Paquete de Java para el cual se generarán fuentes de Java. De forma predeterminada, el paquete se infiere del directorio en el que se encuentra el archivo BUILD que contiene la regla. Puedes especificar un paquete diferente, pero no se recomienda, ya que puede introducir conflictos de rutas de clase con otras bibliotecas que solo se detectarán en el tiempo de ejecución.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadero, esta regla procesa las expresiones de vinculación de datos en los recursos de diseño incluidos a través del atributo resource_files. Sin esta configuración, las expresiones de vinculación de datos producen fallas de compilación. A fin de compilar una app para Android con vinculación de datos, también debes hacer lo siguiente: Establece este atributo para todas las reglas de Android que dependen de forma transitiva de esta. Esto se debe a que las dependencias heredan las expresiones de vinculación de datos de la regla mediante la combinación de recursos. Por lo tanto, también deben realizar compilaciones con la vinculación de datos para analizar esas expresiones. Agrega una entrada `deps =` para la biblioteca del entorno de ejecución de vinculación de datos a todos los destinos que establecen este atributo. La ubicación de esta biblioteca depende de la configuración de tu depósito.
`exported_plugins`	`List of labels; optional` La lista de `java_plugin` (p.ej., procesadores de anotaciones) para exportar a las bibliotecas que dependen directamente de esta biblioteca. La lista especificada de `java_plugin` se aplicará a cualquier biblioteca que dependa directamente de esta biblioteca, como si esa biblioteca hubiera declarado explícitamente estas etiquetas en `plugins`.
`exports`	`List of labels; optional` El cierre de todas las reglas a las que se llega mediante los atributos `exports` se consideran dependencias directas de cualquier regla que depende directamente del destino con `exports`. Las `exports` no son dependencias directas de la regla a la que pertenecen.
`exports_manifest`	`Integer; optional; default is 1` Indica si se deben exportar entradas de manifiesto a objetivos `android_binary` que dependen de este objetivo. Los atributos `uses-permissions` nunca se exportan.
`idl_import_root`	`String; optional` Es la ruta de acceso relativa a paquetes en la raíz del árbol de paquetes de Java que contiene las fuentes idl incluidas en esta biblioteca. Esta ruta se usará como raíz de importación cuando se procesen fuentes inactivas que dependan de esta biblioteca. Cuando se especifica `idl_import_root`, `idl_parcelables` y `idl_srcs` deben estar en la ruta especificada por el paquete Java del objeto que representan en `idl_import_root`. Cuando no se especifica `idl_import_root`, `idl_parcelables` y `idl_srcs` deben estar en la ruta de acceso especificada por su paquete en una raíz de Java. Consulta los ejemplos.
`idl_parcelables`	`List of labels; optional` Lista de definiciones de IDL de Android que se deben proporcionar como importaciones. Estos archivos estarán disponibles como importaciones para cualquier destino `android_library` que dependa de esta biblioteca, directamente o a través de su cierre transitivo, pero no se traducirá a Java ni se compilará. Solo se deben incluir los archivos `.aidl` que correspondan directamente a las fuentes `.java` en esta biblioteca (p. ej., implementaciones personalizadas de Parcelables). De lo contrario, se debe usar `idl_srcs`. Estos archivos deben estar ubicados correctamente para que el compilador aidl pueda encontrarlos. Consulta la descripción de idl_import_root para obtener información sobre lo que esto significa.
`idl_preprocessed`	`List of labels; optional` Lista de definiciones de IDL de Android procesadas previamente para proporcionar como importaciones. Estos archivos estarán disponibles como importaciones para cualquier destino `android_library` que dependa de esta biblioteca, directamente o a través de su cierre transitivo, pero no se traducirá a Java ni se compilará. Solo se deben incluir los archivos `.aidl` preprocesados que correspondan directamente a las fuentes `.java` en esta biblioteca (p.ej., implementaciones personalizadas de Parcelable); de lo contrario, usa `idl_srcs` para las definiciones de IDL de Android que deben traducirse a interfaces Java y usa `idl_parcelable` para archivos AIDL no procesados.
`idl_srcs`	`List of labels; optional` Lista de definiciones de IDL de Android para traducir a interfaces de Java. Después de que se generen las interfaces de Java, se compilarán junto con el contenido de `srcs`. Estos archivos estarán disponibles como importaciones para cualquier destino `android_library` que dependa de esta biblioteca, directamente o a través de su cierre transitivo. Estos archivos deben estar ubicados correctamente para que el compilador aidl pueda encontrarlos. Consulta la descripción de idl_import_root para obtener información sobre lo que esto significa.
`javacopts`	`List of strings; optional` Opciones adicionales del compilador para este destino. Sujeto a la sustitución "Make variable" y la asignación de token de Shell Bourne. Estas opciones del compilador se pasan a javac después de las opciones del compilador global.
`manifest`	`Label; optional` Nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Debe definirse si se definen los archivos resource_files o de recursos.
`neverlink`	`Boolean; optional; default is False` Usa esta biblioteca solo para la compilación y no durante el tiempo de ejecución. Los resultados de una regla marcada como `neverlink` no se usarán en la creación de `.apk`. Es útil si el entorno de ejecución proporciona la biblioteca durante la ejecución.
`plugins`	`List of labels; optional` Complementos del compilador de Java para ejecutar en el tiempo de compilación Cada `java_plugin` especificado en el atributo de complementos se ejecutará cada vez que se compile este destino. Los recursos generados por el complemento se incluirán en el archivo jar del resultado del destino.
`proguard_specs`	`List of labels; optional` Archivos que se usarán como especificación de Proguard. Estos describirán el conjunto de especificaciones que usará Proguard. Si se especifican, se agregarán a cualquier destino `android_binary` según la biblioteca. Los archivos que se incluyen aquí solo deben tener reglas idempotentes, es decir, -dontnote, -dontwarn, asumenosideeffects y reglas que comienzan con -keep. Otras opciones solo pueden aparecer en las proguard_specs de `android_binary` para garantizar combinaciones no autológicas.
`resource_files`	`List of labels; optional` La lista de recursos que se empaquetarán. Por lo general, es un `glob` de todos los archivos en el directorio `res`. También se puede hacer referencia a los archivos generados (de genrules) mediante Etiqueta. La única restricción es que los resultados generados deben estar en el mismo directorio "`res`" que cualquier otro archivo de recursos incluido.

prueba_instrumentación_android

Ver fuente de la regla

android_instrumentation_test(name, data, args, compatible_with, deprecation, distribs, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, licenses, local, restricted_to, shard_count, size, support_apks, tags, target_compatible_with, target_device, test_app, testonly, timeout, toolchains, visibility)

Una regla android_instrumentation_test ejecuta pruebas de instrumentación de Android. Iniciará un emulador, instalará la aplicación que se está probando, la aplicación de prueba y cualquier otra aplicación necesaria, y ejecutará las pruebas definidas en el paquete de prueba.

El atributo test_app especifica el android_binary que contiene la prueba. Esta android_binary, a su vez, especifica la aplicación android_binary a prueba a través de su atributo instruments.

Ejemplo

# java/com/samples/hello_world/BUILD

android_library(
    name = "hello_world_lib",
    srcs = ["Lib.java"],
    manifest = "LibraryManifest.xml",
    resource_files = glob(["res/**"]),
)

# The app under test
android_binary(
    name = "hello_world_app",
    manifest = "AndroidManifest.xml",
    deps = [":hello_world_lib"],
)

# javatests/com/samples/hello_world/BUILD

android_library(
    name = "hello_world_test_lib",
    srcs = ["Tests.java"],
    deps = [
      "//java/com/samples/hello_world:hello_world_lib",
      ...  # test dependencies such as Espresso and Mockito
    ],
)

# The test app
android_binary(
    name = "hello_world_test_app",
    instruments = "//java/com/samples/hello_world:hello_world_app",
    manifest = "AndroidManifest.xml",
    deps = [":hello_world_test_lib"],
)

android_instrumentation_test(
    name = "hello_world_uiinstrumentation_tests",
    target_device = ":some_target_device",
    test_app = ":hello_world_test_app",
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`support_apks`	`List of labels; optional` Otros APK que se deben instalar en el dispositivo antes de comenzar la prueba de instrumentación
`target_device`	`Label; required` android_device en el que se debe ejecutar la prueba. Para ejecutar la prueba en un emulador que ya esté en ejecución o en un dispositivo físico, usa estos argumentos: `--test_output=streamed --test_arg=--device_broker_type=LOCAL_ADB_SERVER --test_arg=--device_serial_number=$device_identifier`
`test_app`	`Label; required` El objetivo android_binary, que contiene las clases de prueba. El objetivo `android_binary` debe especificar qué objetivo está probando a través del atributo `instruments`.

prueba_local_android

Ver fuente de la regla

android_local_test(name, deps, srcs, data, args, compatible_with, custom_package, densities, deprecation, enable_data_binding, env, env_inherit, exec_compatible_with, exec_properties, features, flaky, javacopts, jvm_flags, licenses, local, manifest, manifest_values, nocompress_extensions, plugins, resource_configuration_filters, resource_jars, resource_strip_prefix, restricted_to, runtime_deps, shard_count, size, stamp, tags, target_compatible_with, test_class, testonly, timeout, toolchains, use_launcher, visibility)

Esta regla es para las pruebas de unidades de reglas android_library de forma local (en lugar de en un dispositivo). Funciona con el framework de prueba de Android Robolectric. Consulta el sitio de Android en Robolectric para obtener información sobre cómo escribir pruebas de Robolectric.

Destinos de salida implícitos

name.jar: Es un archivo Java de la prueba.
name-src.jar: Es un archivo que contiene las fuentes (“fuente jar”).
name_deploy.jar: Es un archivo de implementación de Java adecuado para la implementación (solo compilado si se solicita de manera explícita).

Ejemplos

Para usar Robolectric con android_local_test, agrega el repositorio de Robolectric a tu archivo WORKSPACE:

http_archive(
    name = "robolectric",
    urls = ["https://github.com/robolectric/robolectric-bazel/archive/<COMMIT>.tar.gz"],
    strip_prefix = "robolectric-bazel-<COMMIT>",
    sha256 = "<HASH>",
)
load("@robolectric//bazel:robolectric.bzl", "robolectric_repositories")
robolectric_repositories()

Esto extrae las reglas maven_jar necesarias para Robolectric. Por lo tanto, cada regla android_local_test debe depender de @robolectric//bazel:robolectric. Consulta el siguiente ejemplo.

android_local_test(
    name = "SampleTest",
    srcs = [
        "SampleTest.java",
    ],
    manifest = "LibManifest.xml",
    deps = [
        ":sample_test_lib",
        "@robolectric//bazel:android-all",
    ],
)

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

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`deps`	`List of labels; optional` La lista de las bibliotecas que se probarán y las bibliotecas adicionales que se vincularán al destino. Todos los recursos, los activos y los archivos de manifiesto que se declaran en las reglas de Android para el cierre transitivo de este atributo están disponibles en la prueba. La lista de reglas permitidas en `deps` es `android_library`, `aar_import`, `java_import`, `java_library` y `java_lite_proto_library`.
`srcs`	`List of labels; optional` La lista de archivos de origen que se procesan para crear el destino. Obligatorio, excepto en el caso especial que se describe a continuación. Se compilan `srcs` archivos de tipo `.java`. Para facilitar la lectura, no es recomendable colocar el nombre de un archivo de origen `.java` generado en `srcs`. En su lugar, coloca el nombre de la regla de dependencia en el `srcs`, como se describe a continuación. Los archivos `srcs` de tipo `.srcjar` están descomprimidos y compilados. (esto resulta útil si necesitas generar un conjunto de archivos .java con una regla genérica o extensión de compilación). Se ignoran todos los demás archivos, siempre que haya al menos un archivo de un tipo de archivo descrito anteriormente. De lo contrario, se genera un error. El atributo `srcs` es obligatorio y no puede estar vacío, a menos que se especifique `runtime_deps`.
`custom_package`	`String; optional` Paquete de Java en el que se generará la clase R. De forma predeterminada, el paquete se infiere del directorio en el que se encuentra el archivo BUILD que contiene la regla. Si usas este atributo, es probable que también debas usar `test_class`.
`densities`	`List of strings; optional` Densidades que se filtrarán cuando se compile el APK. También se agregará la sección compatible con pantallas correspondiente al manifiesto si aún no contiene un superconjunto de StarlarkListing.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadero, esta regla procesa las referencias de vinculación de datos que se usan en las dependencias habilitadas para la vinculación de datos que se usan en esta prueba. Sin esta configuración, las dependencias de vinculación de datos no tendrán la generación de código necesaria a nivel binario y pueden generar fallas de compilación.
`javacopts`	`List of strings; optional` Opciones adicionales del compilador para esta biblioteca. Sujeto a la sustitución "Make variable" y la asignación de token de Shell Bourne. Estas opciones del compilador se pasan a javac después de las opciones del compilador global.
`jvm_flags`	`List of strings; optional` Una lista de marcas que se incorporarán en la secuencia de comandos wrapper generada para ejecutar este objeto binario. Sujeto a la sustitución $(location) y "Make variable", y la asignación de token de Bourne shell. La secuencia de comandos wrapper para un objeto binario de Java incluye una definición de CLASSPATH (para encontrar todos los archivos jar dependientes) y, además, invoca el intérprete de Java correcto. La línea de comandos generada por la secuencia de comandos wrapper incluye el nombre de la clase principal seguido de un `"$@"` para que puedas pasar otros argumentos después del nombre de la clase. Sin embargo, los argumentos destinados a analizarla por JVM deben especificarse antes del nombre de clase en la línea de comandos. El contenido de `jvm_flags` se agrega a la secuencia de comandos wrapper antes de que aparezca el nombre de la clase. Ten en cuenta que este atributo no tiene efecto en los resultados de `*_deploy.jar`.
`manifest`	`Label; optional` Nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Se debe definir si los recursos o archivos de recursos están definidos o si alguno de los manifiestos de las bibliotecas en prueba tiene una etiqueta `minSdkVersion`.
`manifest_values`	`Dictionary: String -> String; optional` Un diccionario de valores que se anularán en el manifiesto. Cualquier instancia de ${name} en el manifiesto se reemplazará por el valor correspondiente al nombre en este diccionario. `applicationId`, `versionCode`, `versionName`, `minSdkVersion`, `targetSdkVersion` y `maxSdkVersion` también anularán los atributos correspondientes del manifiesto y de las etiquetas uses-sdk. `packageName` se ignorará y se establecerá desde `applicationId` si se especifica o el paquete en el manifiesto. No es necesario tener un manifiesto en la regla para poder usar los manifiestos.
`nocompress_extensions`	`List of strings; optional` Una lista de extensiones de archivo que no se comprimirán en el APK del recurso.
`plugins`	`List of labels; optional` Complementos del compilador de Java para ejecutar en el tiempo de compilación Cada `java_plugin` especificado en este atributo se ejecutará cada vez que se compile esta regla. Una biblioteca también puede heredar complementos de dependencias que usan `exported_plugins`. Los recursos generados por el complemento se incluirán en el archivo jar resultante de esta regla.
`resource_configuration_filters`	`List of strings; optional` Una lista de filtros de configuración de recursos, como "en" que limitará los recursos en el APK a solo los de la configuración "en".
`resource_jars`	`List of labels; optional` Este campo es obsoleto: usa java_import y deps o runtime_deps.
`resource_strip_prefix`	`String; optional` El prefijo de la ruta de acceso que se debe quitar de los recursos de Java. Si se especifica, se quita este prefijo de ruta de acceso de todos los archivos del atributo `resources`. Es un error que un archivo de recursos no esté en este directorio. Si no se especifica (predeterminado), la ruta de acceso del archivo de recursos se determina de acuerdo con la misma lógica que el paquete Java de archivos de origen. Por ejemplo, un archivo de origen en `stuff/java/foo/bar/a.txt` se ubicará en `foo/bar/a.txt`.
`runtime_deps`	`List of labels; optional` Bibliotecas que están disponibles para el objeto binario final o la prueba solo en el entorno de ejecución. Al igual que el `deps` común, estos aparecerán en la ruta de clase del tiempo de ejecución, pero, a diferencia de ellos, no en la ruta de clase en el tiempo de compilación. Aquí se deben mostrar las dependencias que solo se necesitan durante el tiempo de ejecución. Las herramientas de análisis de dependencia deben ignorar los objetivos que aparecen en `runtime_deps` y `deps`.
`stamp`	`Integer; optional; default is 0` Indica si se debe codificar la información de compilación en el objeto binario. Valores posibles: `stamp = 1`: Sella siempre la información de compilación en el objeto binario, incluso en compilaciones de `--nostamp`. Se debe evitar esta configuración, ya que podría terminar el almacenamiento en caché remoto para el objeto binario y cualquier acción descendente que dependa de él. `stamp = 0`: Siempre reemplaza la información de compilación por valores constantes. Esto brinda un buen almacenamiento en caché de resultados de compilación. `stamp = -1`: La marca `--[no]stamp` controla la incorporación de la información de compilación. Los objetos binarios sellados no se vuelven a compilar, a menos que cambien sus dependencias.
`test_class`	`String; optional` La clase Java que cargará el ejecutor de pruebas. Este atributo especifica el nombre de una clase Java que ejecutará esta prueba. No es común establecer esto. Si se omite este argumento, se usará la clase Java cuyo nombre corresponde al `name` de esta regla `android_local_test`. La clase de prueba debe tener la anotación `org.junit.runner.RunWith`.
`use_launcher`	`Boolean; optional; default is True` Si el objeto binario debe usar un selector personalizado Si este atributo se configura como falso, el atributo launcher y la marca `--java_launcher` relacionada se ignorarán para este destino.

dispositivo_android

Ver fuente de la regla

android_device(name, cache, compatible_with, default_properties, deprecation, distribs, exec_compatible_with, exec_properties, features, horizontal_resolution, licenses, platform_apks, ram, restricted_to, screen_density, system_image, tags, target_compatible_with, testonly, vertical_resolution, visibility, vm_heap)

Esta regla crea un emulador de Android configurado con las especificaciones determinadas. Este emulador se puede iniciar a través de un comando de ejecución de Bazel o mediante la ejecución directa de la secuencia de comandos generada. Se recomienda depender de las reglas existentes de android_device en lugar de definir las propias.

Esta regla es un destino adecuado para la marca --run_under a la prueba de Bazel y la ejecución Blaze. Inicia un emulador, copia el destino que se prueba o ejecuta en el emulador y lo prueba o lo ejecuta según corresponda.

android_device admite la creación de imágenes de KVM si la system_image subyacente se basa en X86 y está optimizada para la arquitectura de CPU I686 como máximo. Para usar KVM, agrega tags = ['requires-kvm'] a la regla android_device.

Destinos de salida implícitos

name_images/userdata.dat: Contiene instantáneas y archivos de imagen para iniciar el emulador.
name_images/emulator-meta-data.pb: Contiene la información serializada necesaria para pasar al emulador a fin de reiniciarla.

Ejemplos

En el siguiente ejemplo, se muestra cómo usar android_device. //java/android/helloandroid/BUILD contiene

android_device(
    name = "nexus_s",
    cache = 32,
    default_properties = "nexus_s.properties",
    horizontal_resolution = 480,
    ram = 512,
    screen_density = 233,
    system_image = ":emulator_images_android_16_x86",
    vertical_resolution = 800,
    vm_heap = 32,
)

filegroup(
    name = "emulator_images_android_16_x86",
    srcs = glob(["androidsdk/system-images/android-16/**"]),
)

//java/android/helloandroid/nexus_s.properties contiene:

ro.product.brand=google
ro.product.device=crespo
ro.product.manufacturer=samsung
ro.product.model=Nexus S
ro.product.name=soju

Esta regla generará imágenes y una secuencia de comandos de inicio. Para iniciar el emulador de forma local, ejecuta bazel run :nexus_s -- --action=start. La secuencia de comandos expone las siguientes marcas:

--adb_port: El puerto en el que se mostrará adb. Si deseas emitir comandos de ADB al emulador, este es el puerto al que emitirás la conexión de ADB.
--emulator_port: es el puerto en el que se expone la consola de administración de Telnet del emulador.
--enable_display: Inicia el emulador con una pantalla si es verdadero (el valor predeterminado es falso).
--action: Start or kill.
--apks_to_install: una lista de apks para instalar en el emulador.

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`cache`	`Integer; required` Es el tamaño en megabytes de la partición de caché del emulador. El valor mínimo es 16 megabytes.
`default_properties`	`Label; optional` Un único archivo de propiedades para colocar en /default.prop en el emulador De esta manera, el autor de reglas puede configurar más el emulador para que se parezca más a un dispositivo real (en particular, controlando sus strings de UserAgent y otros comportamientos que podrían hacer que una app o un servidor se comporten de manera diferente a un dispositivo específico). Las propiedades de este archivo anularán las propiedades de solo lectura que el emulador suele establecer, como ro.product.model.
`horizontal_resolution`	`Integer; required` Resolución de pantalla horizontal en píxeles que se debe emular. El valor mínimo es 240.
`platform_apks`	`List of labels; optional` Una lista de los APK que se deben instalar en el dispositivo al momento del inicio.
`ram`	`Integer; required` Indica la cantidad de RAM que se debe emular para el dispositivo. Esto se aplica a todo el dispositivo, no solo a una app en particular instalada en el dispositivo. El valor mínimo es 64 megabytes.
`screen_density`	`Integer; required` Es la densidad de la pantalla emulada en píxeles por pulgada. El valor mínimo es 30 ppp.
`system_image`	`Label; required` Un grupo de archivos que contenga los siguientes archivos: system.img: la partición del sistema kernel-qemu: El kernel de Linux que cargará el emulador ramdisk.img: la imagen initrd que se usará en el momento del inicio userdata.img: la partición inicial userdata source.properties: un archivo de propiedades que contiene información sobre las imágenes Estos archivos forman parte del SDK de Android o son proporcionados por terceros (por ejemplo, Intel proporciona imágenes x86).
`vertical_resolution`	`Integer; required` Resolución de pantalla vertical en píxeles que se debe emular. El valor mínimo es 240.
`vm_heap`	`Integer; required` El tamaño en megabytes del montón de máquina virtual que Android usará para cada proceso. El valor mínimo es 16 megabytes.

android_ndk_repository

Ver fuente de la regla

android_ndk_repository(name, api_level, path, repo_mapping)

Configura Bazel para usar un NDK de Android a fin de admitir la compilación de destinos de Android con código nativo.

Ten en cuenta que esta implementación de android_ndk_repository se reemplazará por una implementación en Starlark. La compatibilidad con versiones futuras del NDK, incluida la versión 25 y posteriores, se implementará en la versión de android_ndk_repository de Starlark. Consulta rules_android_ndk para ver la versión de Starlark.

Ten en cuenta que la compilación para Android también requiere una regla android_sdk_repository en tu archivo WORKSPACE.

Para obtener más información, consulta la documentación completa sobre cómo usar el NDK de Android con Bazel.

Ejemplos

android_ndk_repository(
    name = "androidndk",
)

En el ejemplo anterior, se localizará tu NDK de Android de $ANDROID_NDK_HOME y se detectará el nivel de API más alto que admita.

android_ndk_repository(
    name = "androidndk",
    path = "./android-ndk-r20",
    api_level = 24,
)

En el ejemplo anterior, se usará el NDK de Android que se encuentra dentro de tu lugar de trabajo en ./android-ndk-r20. Usará las bibliotecas de nivel de API 24 cuando compiles tu código JNI.

Características de CPU

El NDK de Android contiene la biblioteca de cpufeatures que se puede usar para detectar la CPU de un dispositivo en el tiempo de ejecución. En el siguiente ejemplo, se muestra cómo usar cpufeatures con Bazel.

# jni.cc
#include "ndk/sources/android/cpufeatures/cpu-features.h"
...

# BUILD
cc_library(
    name = "jni",
    srcs = ["jni.cc"],
    deps = ["@androidndk//:cpufeatures"],
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`api_level`	`Integer; optional; nonconfigurable; default is 0` El nivel de API de Android con el que se compilará. Si no se especifica, se usará el nivel de API más alto instalado.
`path`	`String; optional; nonconfigurable` Es una ruta absoluta o relativa a un NDK de Android. Se debe establecer este atributo o la variable de entorno `$ANDROID_NDK_HOME`. El NDK de Android se puede descargar en el sitio para desarrolladores de Android.
`repo_mapping`	`Dictionary: String -> String; optional` Un diccionario del nombre del repositorio local al nombre del repositorio global Esto permite controlar la resolución de dependencias del lugar de trabajo para las dependencias de este repositorio. Por ejemplo, una entrada `"@foo": "@bar"` declara que, en cualquier momento, este repositorio depende de `"@foo"` (como una dependencia en `"@foo//some:target"`), que debe resolver esa dependencia dentro de un `"@bar"` (`"@bar//some:target"`) declarado de manera global.

android_sdk_repository

Ver fuente de la regla

android_sdk_repository(name, api_level, build_tools_version, path, repo_mapping)

Configura Bazel para usar un SDK de Android local a fin de admitir la compilación de objetivos de Android.

Ejemplos

El mínimo para configurar un SDK de Android para Bazel es colocar una regla android_sdk_repository llamada "androidsdk" en el archivo WORKSPACE y establecer la variable de entorno $ANDROID_HOME en la ruta de acceso del SDK de Android. Bazel usará el nivel de API de Android más alto y compilará la versión de las herramientas de compilación en el SDK de Android de forma predeterminada.

android_sdk_repository(
    name = "androidsdk",
)

Para garantizar compilaciones reproducibles, los atributos path, api_level y build_tools_version se pueden establecer en valores específicos. La compilación fallará si el SDK de Android no tiene instalado el nivel de API especificado o la versión de las herramientas de compilación.

android_sdk_repository(
    name = "androidsdk",
    path = "./sdk",
    api_level = 19,
    build_tools_version = "25.0.0",
)

En el ejemplo anterior, también se muestra el uso de una ruta de acceso relativa al espacio de trabajo para el SDK de Android. Esto es útil si el SDK de Android forma parte de tu lugar de trabajo de Bazel (p.ej., si está registrado en el control de versión).

Bibliotecas de compatibilidad

Las bibliotecas de compatibilidad están disponibles en Android SDK Manager como "Android Support Repository". Este es un conjunto de versiones de bibliotecas comunes de Android, como las bibliotecas de compatibilidad y AppCompat, que se empaquetan como un repositorio local de Maven. android_sdk_repository genera destinos de Bazel para cada una de estas bibliotecas que se pueden usar en las dependencias de android_binary y android_library.

Los nombres de los destinos generados provienen de las coordenadas de Maven de las bibliotecas en el repositorio de compatibilidad de Android, con el formato @androidsdk//${group}:${artifact}-${version}. En el siguiente ejemplo, se muestra cómo un android_library puede depender de la versión 25.0.0 de la biblioteca appcompat v7.

android_library(
    name = "lib",
    srcs = glob(["*.java"]),
    manifest = "AndroidManifest.xml",
    resource_files = glob(["res/**"]),
    deps = ["@androidsdk//com.android.support:appcompat-v7-25.0.0"],
)

Argumentos

Atributos
`name`	`Name; required` Un nombre único para esta orientación.
`api_level`	`Integer; optional; nonconfigurable; default is 0` Es el nivel de la API de Android con el que se compilará de forma predeterminada. Si no se especifica, se usará el nivel de API más alto instalado. La marca `android_sdk` puede anular el nivel de API que se usa para una compilación determinada. `android_sdk_repository` crea un destino `android_sdk` para cada nivel de API instalado en el SDK con el nombre `@androidsdk//:sdk-${level}`, sin importar si se especifica este atributo o no. Por ejemplo, para compilar con un nivel de API no predeterminado: `bazel build --android_sdk=@androidsdk//:sdk-19 //java/com/example:app`. Para ver todos los destinos `android_sdk` generados por `android_sdk_repository`, puedes ejecutar `bazel query "kind(android_sdk, @androidsdk//...)"`.
`build_tools_version`	`String; optional; nonconfigurable` Es la versión de las herramientas de compilación de Android que se usarán en el SDK de Android. Si no se especifica, se usará la versión más reciente de las herramientas de compilación. Bazel requiere la versión 30.0.0 de las herramientas de compilación o una posterior.
`path`	`String; optional; nonconfigurable` Es una ruta absoluta o relativa a un SDK de Android. Se debe establecer este atributo o la variable de entorno `$ANDROID_HOME`. El SDK de Android se puede descargar en el sitio para desarrolladores de Android.
`repo_mapping`	`Dictionary: String -> String; optional` Un diccionario del nombre del repositorio local al nombre del repositorio global Esto permite controlar la resolución de dependencias del lugar de trabajo para las dependencias de este repositorio. Por ejemplo, una entrada `"@foo": "@bar"` declara que, en cualquier momento, este repositorio depende de `"@foo"` (como una dependencia en `"@foo//some:target"`), que debe resolver esa dependencia dentro de un `"@bar"` (`"@bar//some:target"`) declarado de manera global.