Ya comenzó el registro para BazelCon 2024

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

Reglas de Android

Reglas

android_binary
aar_import
android_library
android_instrumentation_test
android_local_test
android_device
android_ndk_repository
android_sdk_repository

android_binary

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 una aplicación para Android. archivo de paquete firmado con claves de depuración y zipaligned, podría usarse para desarrollar y depurar tu aplicación. No puedes lanzar tu aplicación si la firmaste con las claves de depuración.
name_unsigned.apk: Es una versión sin firmar de la anterior que podría firmarse con las claves de lanzamiento antes del lanzamiento del público.
name_deploy.jar: Es un archivo Java que contiene lo siguiente: cierre transitivo de este objetivo.
El jar de implementación contiene todas las clases que encontraría un archivo classloader que buscó la ruta de clase del tiempo de ejecución de este objetivo de principio a fin.
name_proguard.jar: Es un archivo de Java que contiene lo siguiente: el resultado de ejecutar ProGuard en el name_deploy.jar Este resultado solo se produce si proguard_specs es el especificada.
name_proguard.map: Es un resultado de archivo de asignación de ejecutando ProGuard en name_deploy.jar Este resultado solo se produce si proguard_specs es el especificadas y proguard_generate_mapping o shrink_resources.

Ejemplos

Puedes encontrar ejemplos de reglas de Android en el directorio examples/android de la Árbol de fuentes de Bazel.

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino.
`deps`	`List of labels; optional` Es la lista de otras bibliotecas que se vincularán al objetivo binario. Los tipos de bibliotecas permitidos son los siguientes: `android_library`, `java_library` con la restricción `android` y `cc_library` que une o produce bibliotecas nativas `.so` para el Plataforma de segmentación de Android.
`srcs`	`List of labels; optional` La lista de archivos de origen que se procesan para crear el destino. Se compilaron los archivos `srcs` de tipo `.java`. Para que sea más legible, no es recomendable poner el nombre de un se generó el archivo `.java` de origen en `srcs`. En su lugar, coloca el nombre de la regla dependiente en `srcs`, como que se describe a continuación. Se descomprimen `srcs` archivos de tipo `.srcjar` se compilan. (Esto resulta útil si necesitas generar un conjunto de archivos .java con una extensión de generación o de compilación).
`assets`	`List of labels; optional` La lista de elementos que se empaquetarán. Por lo general, es un `glob` de todos los archivos del `assets`. También puedes hacer referencia a otras reglas (cualquier regla que produzca archivos) o exportados en los otros paquetes, siempre que todos esos archivos estén en el `assets_dir` en el paquete correspondiente.
`assets_dir`	`String; optional` Es la cadena que proporciona la ruta de acceso a los archivos en `assets`. El par `assets` y `assets_dir` describen los paquetes se deben proporcionar los recursos y se deben proporcionar ambos, o ninguno.
`crunch_png`	`Boolean; optional; default is True` Haz procesamiento de PNG (o no). Esto es independiente del procesamiento de nine-patch, que siempre listo. Esta es una solución obsoleta para un aapt bug que tiene se corrigió en aapt2.
`custom_package`	`String; optional` Es el paquete de Java para el que se generarán fuentes de Java. De forma predeterminada, el paquete se infiere del directorio en el que se encuentra el archivo BUILD. en la que se encuentra la regla. Puedes especificar otro paquete, se desaconseja, ya que puede introducir conflictos de ruta de clase con otros 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 almacén de claves de depuración que se usará para firmar el APK de depuración. Por lo general, no si quiere usar una clave que no sea la predeterminada, por lo que se debe omitir este atributo. ADVERTENCIA: No uses las claves de producción, ya que estén estrictamente protegidas y no se guarden en el á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 si quieres usar claves distintas de la predeterminada, por lo que se debe omitir este atributo. ADVERTENCIA: No uses las claves de producción, ya que estén estrictamente protegidas y no se guarden en el árbol fuente.
`debug_signing_lineage_file`	`Label; optional` Archivo que contiene el linaje de firma de debug_signature_keys. Por lo general, no si quieres usar claves distintas de la predeterminada, por lo que se debe omitir este atributo. ADVERTENCIA: No uses las claves de producción, ya que estén estrictamente protegidas y no se guarden en el árbol fuente.
`densities`	`List of strings; optional` Densidades que se deben filtrar cuando se compila el APK Esto eliminará los recursos de elementos de diseño de trama que no podrían cargarse en un dispositivo con las densidades de pantalla especificadas para reducir el tamaño del APK. Una pantalla compatible correspondiente también se agregará al manifiesto si aún no contiene un superconjunto. ficha.
`dex_shards`	`Integer; optional; default is 1` La cantidad de fragmentos para la conversión a DEX. Esto hace que la conversión a DEX sea mucho más rápida a expensas del tiempo de instalación y de inicio de la app. El más grande es el objeto binario, más fragmentos se deberían usar. 25 es un buen valor para empezar con los que estás experimentando. Ten en cuenta que cada fragmento generará al menos un DEX en la app final. Por este motivo, no se recomienda configurar esto 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 al generar classes.dex. Con la sustitución "Make variable" y Asignación de token de shell de Bourne.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadera, esta regla procesa datos vinculante en los recursos de diseño incluidos a través del resource_files. Sin este las expresiones de vinculación de datos producen fallas de compilación. Para 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 dependan de este de forma transitiva. Esto se debe a que las dependencias heredan las expresiones de vinculación de datos de la regla a través de recursos fusionando. Por lo tanto, también deben compilar con 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` Forzar la compilación del destino con o sin la conversión a DEX incremental, anulando los valores predeterminados y la marca --incremental_dexing.
`instruments`	`Label; optional` Es el objetivo `android_binary` que se debe instrumentar. Si se establece este atributo, este `android_binary` se considerará como una prueba. app para pruebas de instrumentación. Un `android_instrumentation_test` objetivo puede especificar este objetivo en su test_app.
`javacopts`	`List of strings; optional` Opciones de compilador adicionales para este destino. Con la sustitución "Make variable" y Asignación de token de shell de Bourne. Estas opciones del compilador se pasan a javac después de las opciones globales del compilador.
`key_rotation_min_sdk`	`String; optional` Establece la versión mínima de la plataforma de Android (nivel de API) para la que se rota la firma de un APK. se debe usar para producir 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 clase. Las clases definidas por esos archivos de clase se colocar en el archivoclass.dex principal. e.g.: 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 principal de DEX.
`main_dex_proguard_specs`	`List of labels; optional` Archivos que se usarán como especificaciones de ProGuard para determinar las clases que se deben mantener el DEX principal. Solo se permite si el atributo `multidex` se establece en `legacy`.
`manifest`	`Label; required` Es el nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Se debe definir si se definen recursos_archivos o recursos.
`manifest_values`	`Dictionary: String -> String; optional` Un diccionario de valores que se anularán en el manifiesto. Cualquier instancia de ${name} en la manifiesto se reemplazará por el valor correspondiente al nombre en este diccionario. applicationId, versionCode, versionName, minSdkVersion, targetSdkVersion y maxSdkVersion también anulará los atributos correspondientes del manifiesto uses-sdk. packageName se ignorará y se establecerá desde applicationId si especificado o el paquete en el manifiesto. Cuando manifest_merger está configurado en legado, solo applicationId, versionCode y versionName tendrán ningú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 el límite de índice dex 64K. se excede. Se supone que la plataforma es compatible con la plataforma nativa para cargar clases de multidex durante el tiempo de ejecución. Solo funciona con Android L y versiones posteriores. `legacy`: Divide el código en varios archivos dex cuando el límite de índice dex 64K. se excede. Se supone que las clases de multidex se cargan a través del código de la aplicación (es decir, sin plataforma nativa). `manual_main_dex`: Divide el código en varios archivos dex cuando el dex 64K. se superó el límite de índice. El contenido del archivo dex principal debe especificarse mediante proporcionando una lista de clases en un archivo de texto con el main_dex_list. `off`: Compila todo el código en un solo archivo dex, incluso si excede el límite de índice.
`nocompress_extensions`	`List of strings; optional` Una lista de extensiones de archivo que se deben dejar sin comprimir en el APK.
`package_id`	`Integer; optional; default is 0` El ID del paquete que se asignará a los recursos en este objeto binario. Para obtener más información, consulta el argumento `--package-id` de AAPT2. Esto puede (y no se deben establecer, lo que da como resultado el valor predeterminado de 127, (`0x7F`).
`plugins`	`List of labels; optional` Complementos de compilador de Java para ejecutarse en el tiempo de compilación. Cada `java_plugin` especificado en el atributo de complementos se ejecutará siempre que se compila este destino. Recursos generados por el complemento se incluirá en el archivo jar de resultados de el objetivo.
`proguard_apply_dictionary`	`Label; optional` Es el archivo que se usará como asignación para ProGuard. Un archivo de "palabras" separado por líneas para extraer cuando se cambia el nombre de las clases y los miembros durante ofuscación.
`proguard_apply_mapping`	`Label; optional` Es el archivo que se usará como asignación para ProGuard. Un archivo de asignación que genera `proguard_generate_mapping` para que se volver a usarse para aplicar la misma asignación a una compilación nueva.
`proguard_generate_mapping`	`Boolean; optional; nonconfigurable; default is False` Indica si se debe generar un archivo de asignación de ProGuard. El archivo de asignación solo se generará si `proguard_specs` es especificada. Este archivo enumerará la asignación entre el original y nombres de clases, métodos y campos ofuscados. ADVERTENCIA: Si se usa este atributo, ProGuard la especificación no debe contener `-dontobfuscate` ni `-printmapping`
`proguard_specs`	`List of labels; optional` Archivos que se usarán como especificación de ProGuard. Ese 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 la apk solo a los que se encuentran en la columna "en" configuración. Para habilitar la pseudolocalización, incluye el elemento Pseudoconfiguraciones 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 del `res`. Se puede hacer referencia a los archivos generados (desde genrules) También puedes etiquetar aquí. La única restricción es que las salidas generadas deben estar bajo el mismo “`res`” como en cualquier otro archivos de recursos que se incluyen.
`shrink_resources`	`Integer; optional; default is -1` Establece si se deben reducir los recursos. Los recursos que el objeto binario no usa se del APK. Esto solo se admite para las reglas que usan recursos locales (es decir, `manifest` y `resource_files`), y requiere ProGuard. Funciona prácticamente 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/` y los archivos recursos usa `strict mode` de forma predeterminada quitar recursos de ID sin usar solo es compatible con aapt2 Si la reducción de recursos está habilitada, `name_files/resource_shrinker.log` de datos, que detalla 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 mediante el --android_resource_shrinking.

aar_import

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 android_library y android_binary reglas.

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 este destino.
`aar`	`Label; required` El archivo `.aar` que se debe proporcionar a los destinos de Android que dependen de este.
`exports`	`List of labels; optional` Destinos para exportar a reglas que dependen de esta regla. Consulta java_library.exports.
`srcjar`	`Label; optional` Un archivo JAR que contiene el código fuente para los archivos JAR compilados en el AAR.

android_library

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. Se coloca implícitamente la biblioteca android.jar del tiempo de ejecución de Android. la ruta de la clase de compilación.

Destinos de salida implícitos

libname.jar: Es un archivo de Java.
libname-src.jar: Es un archivo que contiene lo siguiente: de origen (“Source jar”).
name.aar: Es un "aar" de Android. paquete que contiene el archivo de Java y recursos de este objetivo. No contiene el cierre transitivo.

Ejemplos

Puedes encontrar ejemplos de reglas de Android en el directorio examples/android de la Árbol de fuentes de Bazel.

En el siguiente ejemplo, se muestra cómo configurar idl_import_root Deja 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 este destino.
`deps`	`List of labels; optional` Es la lista de otras bibliotecas con las que se vinculará. Los tipos de bibliotecas permitidos son los siguientes: `android_library`, `java_library` con la restricción `android` y `cc_library` une o produce `.so` bibliotecas nativas para la plataforma de segmentación de Android.
`srcs`	`List of labels; optional` La lista de archivos `.java` o `.srcjar` que se procesan para crear el destino. Se compilaron los archivos `srcs` de tipo `.java`. Para que sea más legible, no es recomendable poner el nombre de un se generó el archivo `.java` de origen en `srcs`. En su lugar, coloca el nombre de la regla dependiente en `srcs`, como que se describe a continuación. Se descomprimen `srcs` archivos de tipo `.srcjar` se compilan. (Esto resulta útil si necesitas generar un conjunto de archivos .java con una extensión de generación o de compilación). Si se omite `srcs`, cualquier dependencia especificada en `deps` se exporta desde esta regla (consulta exportaciones de java_library para más información sobre la exportación de dependencias). Sin embargo, este comportamiento será dejará de estar disponible pronto; intenta no confiar en él.
`assets`	`List of labels; optional` La lista de elementos que se empaquetarán. Por lo general, es un `glob` de todos los archivos del `assets`. También puedes hacer referencia a otras reglas (cualquier regla que produzca archivos) o exportados en los otros paquetes, siempre que todos esos archivos estén en el `assets_dir` en el paquete correspondiente.
`assets_dir`	`String; optional` Es la cadena que proporciona la ruta de acceso a los archivos en `assets`. El par `assets` y `assets_dir` describen los paquetes se deben proporcionar los recursos y se deben proporcionar ambos, o ninguno.
`custom_package`	`String; optional` Es el paquete de Java para el que se generarán fuentes de Java. De forma predeterminada, el paquete se infiere del directorio en el que se encuentra el archivo BUILD. en la que se encuentra la regla. Puedes especificar otro paquete, se desaconseja, ya que puede introducir conflictos de ruta de clase con otros que solo se detectarán en el tiempo de ejecución.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadera, esta regla procesa datos vinculante en los recursos de diseño incluidos a través del resource_files. Sin este las expresiones de vinculación de datos producen fallas de compilación. Para 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 dependan de este de forma transitiva. Esto se debe a que las dependencias heredan las expresiones de vinculación de datos de la regla a través de recursos fusionando. Por lo tanto, también deben compilar con 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., anotación procesadores) para exportarlos a bibliotecas que dependen directamente de ella. La lista especificada de `java_plugin` se aplicará a cualquier biblioteca que depende directamente de esta biblioteca, como si esta hubiera declarado explícitamente etiquetas en `plugins`.
`exports`	`List of labels; optional` El cierre de todas las reglas a las que se llegó mediante los atributos `exports` se consideran dependencias directas de cualquier regla que depende directamente del se orienta con `exports`. Los `exports` no son dependencias directas de la regla a la que pertenecen.
`exports_manifest`	`Integer; optional; default is 1` Si se exportan las entradas del manifiesto a destinos `android_binary` que dependen de este objetivo. Los atributos `uses-permissions` nunca se exportan.
`idl_import_root`	`String; optional` Ruta de acceso relativa al paquete a la raíz del árbol de paquetes de Java que contiene idl fuentes incluidas en esta biblioteca. Esta ruta se usará como raíz de importación cuando se procesen fuentes inactivas que depender de esta biblioteca. Cuando se especifica `idl_import_root`, tanto `idl_parcelables` y `idl_srcs` debe estar en la ruta de acceso especificada por el paquete Java del objeto que representan por debajo de `idl_import_root`. Cuando `idl_import_root` sea no especificado, tanto `idl_parcelables` como `idl_srcs` deben estar en el ruta de acceso especificada por el paquete en una raíz de Java. Consulta ejemplos comunes.
`idl_parcelables`	`List of labels; optional` Lista de definiciones de IDL de Android para proporcionar como importaciones. Estos archivos estarán disponibles como importaciones para cualquier Destino `android_library` que depende de esta biblioteca, directamente o a través de su cierre transitivo, pero no se traducirá a Java o compilarse. Solo los `.aidl` archivos que corresponden directamente a Se deben incluir `.java` fuentes en esta biblioteca (p.ej., personalizadas implementaciones de Parcelable), de lo contrario, `idl_srcs` debe ser que se usan. Estos archivos deben estar ubicados correctamente para que el compilador Aidl los encuentre. 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 que se proporcionarán como importaciones. Estos archivos estarán disponibles como importaciones para cualquier Destino `android_library` que depende de esta biblioteca, directamente o a través de su cierre transitivo, pero no se traducirá a Java o compilarse. Solo los archivos `.aidl` preprocesados que corresponden directamente a Se deben incluir `.java` fuentes en esta biblioteca (p.ej., personalizadas de Parcelable), de lo contrario, usa `idl_srcs` para Las definiciones de IDL de Android que deben traducirse a interfaces de Java y usar `idl_parcelable` para archivos AIDL sin procesamiento previo.
`idl_srcs`	`List of labels; optional` Lista de definiciones de IDL de Android que se traducirán a interfaces de Java. Una vez generadas las interfaces Java, se compilarán juntas con el contenido de `srcs`. Estos archivos estarán disponibles como importaciones para cualquier Destino `android_library` que depende de esta biblioteca, directamente o a través de su cierre transitivo. Estos archivos deben estar ubicados correctamente para que el compilador Aidl los encuentre. Consulta la descripción de idl_import_root. para obtener información sobre lo que esto significa.
`javacopts`	`List of strings; optional` Opciones de compilador adicionales para este destino. Con la sustitución "Make variable" y Asignación de token de shell de Bourne. Estas opciones del compilador se pasan a javac después de las opciones globales del compilador.
`manifest`	`Label; optional` Es el nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Se debe definir si se definen recursos_archivos o 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 Creación de `.apk`. Es útil si la biblioteca se proporciona a través del del entorno de ejecución durante la ejecución.
`plugins`	`List of labels; optional` Complementos de compilador de Java para ejecutarse en el tiempo de compilación. Cada `java_plugin` especificado en el atributo de complementos se ejecutará siempre que se compila este destino. Recursos generados por el complemento se incluirá en el archivo jar de resultados de el objetivo.
`proguard_specs`	`List of labels; optional` Archivos que se usarán como especificación de ProGuard. Describirán el conjunto de especificaciones que usará ProGuard. Si se especifica, se agregarán a cualquier destino de `android_binary` según la biblioteca. Los archivos incluidos aquí solo deben tener reglas idempotentes, es decir, -dontnote, -dontwarn, asume efectos secundarios y reglas que comienzan con -keep. Otras opciones solo pueden aparecer en Proguard_specs de `android_binary` para garantizar combinaciones no tautoló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 del `res`. Se puede hacer referencia a los archivos generados (desde genrules) También puedes etiquetar aquí. La única restricción es que las salidas generadas deben estar bajo el mismo “`res`” como en cualquier otro archivos de recursos que se incluyen.

android_instrumentation_test

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. Si iniciar un emulador, instalar la aplicación que se está probando, la aplicación de prueba y cualquier otra aplicación necesaria y ejecuta las pruebas definidas en el paquete de pruebas.

El atributo test_app especifica la android_binary, que contiene la prueba. Este android_binary a la vez especifica la aplicación de android_binary que se está probando mediante su 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 este destino.
`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` Es el elemento android_device en el que se debe ejecutar la prueba. Para ejecutar la prueba en un emulador que ya se está ejecutando 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 destino `android_binary` debe especificar el destino durante el que realiza pruebas su atributo `instruments`.

android_local_test

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 probar unidades de reglas android_library de forma local (a diferencia de un dispositivo). Funciona con el framework de pruebas de Robolectric de Android. Consulta el sitio de Android Robolectric para obtener más información sobre escribiendo 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. ("archivo de origen").
name_deploy.jar: Es un archivo de implementación de Java adecuado. para la implementación (solo se compila si se solicita explícitamente).

Ejemplos

Para usar Robolectric con android_local_test, agrega Robolectric's repositorio a tu archivo WORKSPACE:

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

Esto extrae las reglas maven_jar necesarias para Robolectric. Luego, cada regla android_local_test debería depender @robolectric//bazel:robolectric Consulta el siguiente ejemplo.

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

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 este destino.
`deps`	`List of labels; optional` La lista de bibliotecas que se probarán y las bibliotecas adicionales que se vincularán en el objetivo. Todos los recursos, elementos y archivos de manifiesto declarados en las reglas de Android en la configuración el cierre de este atributo están disponibles en la prueba. La lista de reglas permitidas en `deps` es `android_library`, `aar_import`, `java_import` y `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 compilaron los archivos `srcs` de tipo `.java`. Para que sea más legible, no es recomendable poner el nombre de un se generó el archivo `.java` de origen en `srcs`. En su lugar, coloca el nombre de la regla dependiente en `srcs`, como que se describe a continuación. Se descomprimen `srcs` archivos de tipo `.srcjar` se compilan. (Esto resulta útil si necesitas generar un conjunto de archivos .java con una extensión de generación o de compilación). Se ignoran todos los demás archivos, siempre y cuando hay al menos un archivo de uno de los tipos descritos anteriormente. De lo contrario, se si se genera un error. El atributo `srcs` es obligatorio y no puede estar vacío, a menos que Se especifica `runtime_deps`.
`custom_package`	`String; optional` Paquete de Java en el que se generará la clase R. De forma predeterminada, el paquete se infiere desde el 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 deben filtrar cuando se compila el APK Una pantalla compatible correspondiente también se agregará al manifiesto si aún no contiene un superconjunto StarlarkListing.
`enable_data_binding`	`Boolean; optional; default is False` Si es verdadera, esta regla procesa datos binding que se usan en las dependencias habilitadas para la vinculación de datos que se usan en esta prueba. Sin las dependencias de vinculación de datos no tendrán la generación de código a nivel binario, y puede producir fallas de compilación.
`javacopts`	`List of strings; optional` Opciones de compilador adicionales para esta biblioteca. Con la sustitución "Make variable" y Asignación de token de shell de Bourne. Estas opciones del compilador se pasan a javac después de las opciones globales del compilador.
`jvm_flags`	`List of strings; optional` Una lista de marcas para incorporar en la secuencia de comandos del wrapper generada para ejecutar este objeto binario. Sujeto a $(location) y Sustitución "Make variable" y Asignación de token de shell de Bourne. La secuencia de comandos del wrapper para un objeto binario de Java incluye una definición de CLASSPATH (para encontrar todos los archivos jar dependientes) y, luego, invoca el intérprete de Java correcto. La línea de comandos que genera la secuencia de comandos del wrapper incluye el nombre del la clase principal seguida de un elemento `"$@"` para que puedas pasar otros argumentos después del nombre de clase. Sin embargo, los argumentos para analizar por la JVM debe especificarse antes del nombre de clase del comando línea. El contenido de `jvm_flags` se agrega al wrapper secuencia de comandos antes de que aparezca el nombre de clase. Ten en cuenta que este atributo no tiene efecto en `*_deploy.jar`. de salida.
`manifest`	`Label; optional` Es el nombre del archivo de manifiesto de Android, normalmente `AndroidManifest.xml`. Debe definirse si se definen recursos_files o assets, o si alguno de los manifiestos de Las bibliotecas que se están probando tienen 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 la manifiesto se reemplazará por el valor correspondiente al nombre en este diccionario. `applicationId`, `versionCode` y `versionName` `minSdkVersion`, `targetSdkVersion` y `maxSdkVersion` también anulará los atributos correspondientes del manifiesto y uses-sdk. `packageName` se ignorará y se establecerá desde cualquiera de las dos opciones `applicationId` si especificado o el paquete en el manifiesto. No es necesario tener un manifiesto en la regla para usar manifest_values.
`nocompress_extensions`	`List of strings; optional` Una lista de extensiones de archivo que se deben dejar sin comprimir en el APK del recurso.
`plugins`	`List of labels; optional` Complementos de compilador de Java para ejecutarse en el tiempo de compilación. Cada `java_plugin` especificado en este atributo se ejecutará cada vez que esta regla la infraestructura. Una biblioteca también puede heredar complementos de dependencias que usan `exported_plugins` Recursos que genera 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 la apk solo a los que se encuentran en la columna "en" configuración.
`resource_jars`	`List of labels; optional` Obsoleto: usa java_import and deps o runtime_deps.
`resource_strip_prefix`	`String; optional` El prefijo de la ruta de acceso que se quitará de los recursos de Java. Si se especifica, este prefijo de ruta de acceso se quita de cada archivo en el `resources` . Es un error que un archivo de recursos no esté en este directorio. Si no es así especificado (predeterminado), la ruta de acceso del archivo de recursos se determina según el mismo como el paquete de Java de los archivos fuente. Por ejemplo, un archivo fuente en `stuff/java/foo/bar/a.txt` se ubicará en `foo/bar/a.txt`.
`runtime_deps`	`List of labels; optional` Bibliotecas que estarán disponibles para el objeto binario final o que se prueben solo en el tiempo de ejecución. Al igual que los `deps` comunes, estos aparecerán en la ruta de clase del tiempo de ejecución, pero, a diferencia de no en la ruta de clase del tiempo de compilación. Las dependencias que se necesitan solo en el entorno de ejecución que se enumeran aquí. Las herramientas de análisis de dependencias deben ignorar los objetivos que aparecen en ambos `runtime_deps` y `deps`.
`stamp`	`Integer; optional; default is 0` Establece si se debe codificar información de compilación en el objeto binario. Valores posibles: `stamp = 1`: Siempre marca la información de la compilación en el objeto binario, incluso en `--nostamp`. Este de configuración debe evitarse, ya que puede finalizar el almacenamiento en caché remoto binario y las acciones descendentes que dependan de él. `stamp = 0`: Siempre reemplaza la información de compilación por valores constantes. Esta brinda un buen almacenamiento en caché de resultados de compilación. `stamp = -1`: la incorporación de la información de la compilación está controlada por el `--[no]stamp`. 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 esta configuración. Si se omite este argumento, la clase Java cuyo nombre corresponde al `name` de este Se usará `android_local_test` regla. La clase de prueba debe tener anotaciones `org.junit.runner.RunWith`.
`use_launcher`	`Boolean; optional; default is True` Indica si el objeto binario debe usar un selector personalizado. Si este atributo se establece en falso, launcher y los atributos relacionados marca `--java_launcher` se ignorarán para este destino.

android_device

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 Android Emulator configurado con el y las especificaciones del servicio. Este emulador puede iniciarse mediante una ejecución de Bazel o ejecutando directamente la secuencia de comandos generada. Se recomienda que dependa según las reglas existentes de android_device, en lugar de definir la tuya.

Esta regla es un destino adecuado para que la marca --run_under realice pruebas de Bazel y Blaze. cuando se ejecute. Inicia un emulador, copia el destino que se está probando o ejecuta en el emulador. y lo prueba o ejecuta según corresponda.

android_device admite la creación de imágenes de KVM si la instancia system_image se basa en X86 y como máximo para la arquitectura de CPU I686. 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 información serializada necesaria para pasar al emulador al reiniciarla.

Ejemplos

En el siguiente ejemplo, se muestra la manera de 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 lo siguiente:

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. Puedes iniciar el emulador localmente ejecutando bazel run :nexus_s -- --action=start. La secuencia de comandos expone las siguientes marcas:

--adb_port: Es el puerto en el que se debe exponer adb. Si deseas emitir adb al emulador, este es el puerto en el que se emitirá adb connect a los que tiene acceso una cuenta.
--emulator_port: Es el puerto en el que se expone la administración de Telnet del emulador. la consola de Cloud.
--enable_display: Inicia el emulador con una pantalla si es verdadero (valor predeterminado). como falso).
--action: Comienza o termina.
--apks_to_install: Una lista de APK para instalar en el emulador.

Argumentos

Atributos
`name`	`Name; required` Un nombre único para este destino.
`cache`	`Integer; required` Es el tamaño en megabytes de la partición de caché del emulador. El valor mínimo es de 16 megabytes.
`default_properties`	`Label; optional` Se debe colocar un único archivo de propiedades en /default.prop en el emulador. Esto permite que el autor de la regla configure aún más el emulador para que se vea más similar a lo siguiente: un dispositivo real (en particular, para controlar sus cadenas de UserAgent y otras comportamiento que podría hacer que una aplicación o un servidor se comporte de manera diferente un dispositivo específico). Las propiedades de este archivo anularán el acceso de solo lectura propiedades que suele establecer el emulador, como ro.product.model.
`horizontal_resolution`	`Integer; required` Es la resolución horizontal de la pantalla en píxeles para emular. El valor mínimo es 240.
`platform_apks`	`List of labels; optional` Una lista de los APK que se instalarán en el dispositivo al momento del inicio.
`ram`	`Integer; required` Es la cantidad de RAM en megabytes que se emulará para el dispositivo. Esto es para todo el dispositivo, no solo para una app específica instalada en él. El el valor mínimo es de 64 megabytes.
`screen_density`	`Integer; required` Es la densidad de la pantalla emulada en píxeles por pulgada. El valor mínimo es de 30 ppp.
`system_image`	`Label; required` Un grupo de archivos que contiene los siguientes archivos: system.img: La partición del sistema kernel-qemu: Es el kernel de Linux que cargará el emulador. ramdisk.img: La imagen initrd que se usará en el inicio userdata.img: La partición inicial userdata source.properties: Es un archivo de propiedades que contiene información sobre el imágenes Estos archivos son parte del SDK de Android o los proporcionan terceros (por ejemplo, Intel proporciona imágenes x86).
`vertical_resolution`	`Integer; required` Es la resolución de pantalla vertical en píxeles que se emula. El valor mínimo es 240.
`vm_heap`	`Integer; required` Es el tamaño en megabytes del montón de máquina virtual que usará Android para cada proceso. El valor mínimo es 16 megabytes.

android_ndk_repository

android_ndk_repository(name, api_level, path, repo_mapping)

Configura Bazel para que use un NDK de Android y admita la compilación de destinos de Android con formatos nativos. código.

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

Para obtener más información, consulta el documentación completa sobre el uso del NDK de Android con Bazel.

Ejemplos

android_ndk_repository(
    name = "androidndk",
)

El ejemplo anterior ubicará tu NDK de Android en $ANDROID_NDK_HOME y detectará el nivel de API más alto que admita.

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

El ejemplo anterior usará el NDK de Android ubicado dentro de tu espacio de trabajo en ./android-ndk-r20 Usará las bibliotecas de nivel de API 24 cuando compile tu JNI código.

funciones de CPU

Android NDK contiene las Biblioteca cpufeatures que se puede usar para detectar la CPU de un dispositivo durante 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 este destino.
`api_level`	`Integer; optional; nonconfigurable; default is 0` Nivel de API de Android con el cual compilar. Si no se especifica, se instala el nivel de API más alto que se usará.
`path`	`String; optional; nonconfigurable` Una ruta de acceso absoluta o relativa a un NDK de Android. Ya sea este atributo o el Se debe configurar la variable de entorno `$ANDROID_NDK_HOME`. El NDK de Android se puede descargar desde el sitio para desarrolladores de Android
`repo_mapping`	`Dictionary: String -> String; optional` Un diccionario que va del nombre del repositorio local al nombre del repositorio global. Esto permite controlar resolución de dependencias de Workspace para las dependencias de este repositorio. Por ejemplo, una entrada `"@foo": "@bar"` declara que, en todo momento, este repositorio depende de `"@foo"` (como una dependencia de `"@foo//some:target"`), debería resolver esa dependencia en un declarada a nivel global `"@bar"` (`"@bar//some:target"`).

android_sdk_repository

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

Configura Bazel para que use un SDK de Android local para admitir la compilación de destinos de Android.

Ejemplos

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

android_sdk_repository(
    name = "androidsdk",
)

Para garantizar compilaciones reproducibles, path, api_level y Los atributos 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 ni 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 demuestra el uso de una ruta de acceso relativa del espacio de trabajo al SDK de Android. Este es Es útil si el SDK de Android forma parte de tu espacio de trabajo de Bazel (p.ej., si está registrado en la versión control).

Bibliotecas de compatibilidad

Las bibliotecas de compatibilidad están disponibles en SDK Manager de Android como "Repositorio de compatibilidad de Android". Se trata de un conjunto con control de versiones de bibliotecas de Android comunes, como las bibliotecas de compatibilidad y AppCompat, empaquetado como un repositorio local de Maven. android_sdk_repository genera Bazel. objetivos para cada una de estas bibliotecas que se pueden usar en las dependencias Destinos android_binary y android_library.

Los nombres de los destinos generados derivan de las coordenadas de Maven de las bibliotecas en la 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 este destino.
`api_level`	`Integer; optional; nonconfigurable; default is 0` Es el nivel de API de Android en el que se realizará la compilación de forma predeterminada. Si no se especifica, el nivel de API más alto de la aplicación instalada. El nivel de API que se usa para una compilación determinada se puede anular con `android_sdk`. marca. `android_sdk_repository` crea un objetivo `android_sdk` para cada nivel de API instalado en el SDK con el nombre `@androidsdk//:sdk-${level}` si se especificó este atributo o no. Por ejemplo, para compilar con una API no predeterminada nivel: `bazel build --android_sdk=@androidsdk//:sdk-19 //java/com/example:app`. Para ver todos los destinos de `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 desde el SDK de Android. Si no se especifica, se usará la última versión instalada de las herramientas de compilación. Bazel requiere la versión 30.0.0 o posterior de las herramientas de compilación.
`path`	`String; optional; nonconfigurable` Una ruta de acceso absoluta o relativa a un SDK de Android. Ya sea este atributo o el Se debe configurar la variable de entorno `$ANDROID_HOME`. El SDK de Android se puede descargar el sitio para desarrolladores de Android.
`repo_mapping`	`Dictionary: String -> String; optional` Un diccionario que va del nombre del repositorio local al nombre del repositorio global. Esto permite controlar resolución de dependencias de Workspace para las dependencias de este repositorio. Por ejemplo, una entrada `"@foo": "@bar"` declara que, en todo momento, este repositorio depende de `"@foo"` (como una dependencia de `"@foo//some:target"`), debería resolver esa dependencia en un declarada a nivel global `"@bar"` (`"@bar//some:target"`).