android_library

An android_library() rule is used to define a set of Java files that can be compiled together against the Android SDK. The main output of an android_library() rule is a single JAR file containing all of the compiled class files and resources.

Function Signature

def android_library(
    *,
    name: str,
    default_target_platform: None | str = None,
    target_compatible_with: list[str] = [],
    compatible_with: list[str] = [],
    exec_compatible_with: list[str] = [],
    visibility: list[str] = [],
    within_view: list[str] = ["PUBLIC"],
    metadata: OpaqueMetadata = {},
    tests: list[str] = [],
    modifiers: OpaqueMetadata = [],
    _android_toolchain: str = "gh_facebook_buck2_shims_meta//:android",
    _apple_platforms: dict[str, str] = {},
    _build_only_native_code: bool = select({"prelude//android/constraints:build_only_native_code": True, "DEFAULT": False}),
    _dex_min_sdk_version: None | int = select({"prelude//android/constraints:min_sdk_version_19": 19, "prelude//android/constraints:min_sdk_version_20": 20, "prelude//android/constraints:min_sdk_version_21": 21, "prelude//android/constraints:min_sdk_version_22": 22, "prelude//android/constraints:min_sdk_version_23": 23, "prelude//android/constraints:min_sdk_version_24": 24, "prelude//android/constraints:min_sdk_version_25": 25, "prelude//android/constraints:min_sdk_version_26": 26, "prelude//android/constraints:min_sdk_version_27": 27, "prelude//android/constraints:min_sdk_version_28": 28, "prelude//android/constraints:min_sdk_version_29": 29, "prelude//android/constraints:min_sdk_version_30": 30, "prelude//android/constraints:min_sdk_version_31": 31, "prelude//android/constraints:min_sdk_version_32": 32, "prelude//android/constraints:min_sdk_version_33": 33, "prelude//android/constraints:min_sdk_version_34": 34, "prelude//android/constraints:min_sdk_version_35": 35, "DEFAULT": None}),
    _dex_toolchain: str = "gh_facebook_buck2_shims_meta//:dex",
    _exec_os_type: str = "prelude//os_lookup/targets:os_lookup",
    _is_building_android_binary: bool = select({"prelude//os:building_android_binary": True, "DEFAULT": False}),
    _java_toolchain: str = "gh_facebook_buck2_shims_meta//:java_for_android",
    _kotlin_toolchain: str = "gh_facebook_buck2_shims_meta//:kotlin_for_android",
    abi_generation_mode: None | str = None,
    android_optional_jars: None | list[str] = None,
    annotation_processing_tool: None | str = None,
    annotation_processor_deps: list[str] = [],
    annotation_processor_params: list[str] = [],
    annotation_processors: list[str] = [],
    attrs_validators: None | list[str] = None,
    contacts: list[str] = [],
    default_host_platform: None | str = None,
    deps: list[str] = [],
    enable_used_classes: bool = True,
    exported_deps: list[str] = [],
    exported_provided_deps: list[str] = [],
    extra_arguments: list[str] = [],
    extra_kotlinc_arguments: list[str] = [],
    friend_paths: list[str] = [],
    incremental: bool = False,
    jar_postprocessor: None | str = None,
    java_version: None | str = None,
    javac: None | str = None,
    k2: bool = False,
    kotlin_compiler_plugins: list[(str, dict[str, str])] = [],
    labels: list[str] = [],
    language: None | str = None,
    licenses: list[str] = [],
    manifest: None | str = None,
    manifest_file: None | str = None,
    maven_coords: None | str = None,
    never_mark_as_unused_dependency: None | bool = None,
    non_exec_dep_plugins_deprecated: list[str | (str, list[str])] = [],
    on_unused_dependencies: None | str = None,
    plugins: list[str | (str, list[str])] = [],
    proguard_config: None | str = None,
    provided_deps: list[str] = [],
    provided_deps_query: None | str = None,
    remove_classes: list[str] = [],
    required_for_source_only_abi: bool = False,
    resource_union_package: None | str = None,
    resources: list[str] = [],
    resources_root: None | str = None,
    runtime_deps: list[str] = [],
    should_kosabi_jvm_abi_gen_use_k2: None | bool = None,
    source: None | str = None,
    source_abi_verification_mode: None | str = None,
    source_only_abi_deps: list[str] = [],
    srcs: list[str] = [],
    target: None | str = None,
    use_jvm_abi_gen: None | bool = None,
    validation_deps: list[str] = [],
    validation_specs: dict[str, str] = {},
) -> None

Parameters

name: (required)

name of the target
default_target_platform: (defaults to: None)

specifies the default target platform, used when no platforms are specified on the command line
target_compatible_with: (defaults to: [])

a list of constraints that are required to be satisfied for this target to be compatible with a configuration
compatible_with: (defaults to: [])

a list of constraints that are required to be satisfied for this target to be compatible with a configuration
exec_compatible_with: (defaults to: [])

a list of constraints that are required to be satisfied for this target to be compatible with an execution platform
visibility: (defaults to: [])

a list of visibility patterns restricting what targets can depend on this one
within_view: (defaults to: ["PUBLIC"])

a list of visibility patterns restricting what this target can depend on
metadata: (defaults to: {})

a key-value map of metadata associated with this target
tests: (defaults to: [])

a list of targets that provide tests for this one
modifiers: (defaults to: [])

an array of modifiers associated with this target
annotation_processing_tool: (defaults to: None)

Specifies the tool to use for annotation processing. Possible values: "kapt" or "javac". "kapt" allows running Java annotation processors against Kotlin sources while backporting it for Java sources too. "javac" works only against Java sources, Kotlin sources won't have access to generated classes at compile time.
deps: (defaults to: [])

Rules (usually other android_library rules) that are used to generate the classpath required to compile this android_library.
enable_used_classes: (defaults to: True)

Deprecated: for an experiment only, will be removed
exported_deps: (defaults to: [])

Other rules that depend on this rule will also include its exported_deps in their classpaths. This is useful when the public API of a rule has return types or checked exceptions that are defined in another rule, which would otherwise require callers to add an extra dependency. It's also useful for exposing e.g. a collection of prebuilt_jar rules as a single target for callers to depend on. Targets in exported_deps are implicitly included in the deps of this rule, so they don't need to be repeated there.
exported_provided_deps: (defaults to: [])

This is a combination of provided_deps and exported_deps. Rules listed in this parameter will be added to classpath of rules that depend on this rule, but they will not be included in a binary if binary depends on a such target.
extra_arguments: (defaults to: [])

List of additional arguments to pass into the Java compiler. These arguments follow the ones specified in .buckconfig.
extra_kotlinc_arguments: (defaults to: [])

List of additional arguments to pass into the Kotlin compiler.
incremental: (defaults to: False)

Enables Kotlin incremental compilation.
javac: (defaults to: None)

Specifies the Java compiler program to use for this rule. The value is a source path or an execution dep (e.g., //foo/bar:bar). Overrides the value in "javac" in the "tools" section of .buckconfig.
k2: (defaults to: False)

Enables the Kotlin K2 compiler.

kotlin_compiler_plugins: (defaults to: [])

Use this to specify Kotlin compiler plugins to use when compiling this library. This takes a map, with each entry specify one plugin. Entry's key is plugin source path, and value is a map of plugin option key value pair. Unlike extra_kotlinc_arguments, these can be source paths, not just strings.

A special option value is __codegen_dir__, in which case Buck will provide a default codegen folder's path as option value instead. E.g.

fbcode/buck2/prelude/decls/jvm_common.bzl
kotlin_compiler_plugins = {
    "somePluginSourcePath": {
        "plugin:somePluginId:somePluginOptionKey": "somePluginOptionValue",
        "plugin:somePluginId:someDirectoryRelatedOptionKey": "__codegen_dir__",
    },
},

Each plugin source path will be prefixed with -Xplugin= and passed as extra arguments to the compiler. Plugin options will be appended after its plugin with -P.

A specific example is, if you want to use kotlinx.serialization with kotlin_library(), you need to specify kotlinx-serialization-compiler-plugin.jar under kotlin_compiler_plugins and kotlinx-serialization-runtime.jar (which you may have to fetch from Maven) in your deps:

kotlin_library(
    name = "example",
    srcs = glob(["*.kt"]),
    deps = [
        ":kotlinx-serialization-runtime",
    ],
    kotlin_compiler_plugins = {
        # Likely copied from your $KOTLIN_HOME directory.
        "kotlinx-serialization-compiler-plugin.jar": {},
    },
)

prebuilt_jar(
    name = "kotlinx-serialization-runtime",
    binary_jar = ":kotlinx-serialization-runtime-0.10.0",
)

# Note you probably want to set
# maven_repo=http://jcenter.bintray.com/ in your .buckconfig until
# https://github.com/Kotlin/kotlinx.serialization/issues/64
# is closed.
remote_file(
    name = "kotlinx-serialization-runtime-0.10.0",
    out = "kotlinx-serialization-runtime-0.10.0.jar",
    url = "mvn:org.jetbrains.kotlinx:kotlinx-serialization-runtime:jar:0.10.0",
    sha1 = "23d777a5282c1957c7ce35946374fff0adab114c"
)

manifest: (defaults to: None)

An optional Android Manifest for the to declare any permissions or intents it may need or want to handle. May either be a file or an android_manifest() target.
non_exec_dep_plugins_deprecated: (defaults to: [])

Plugins that do not use the execution platform. This exists for historical reasons, and should not be used. Use plugins instead - plugins should be configured for the execution platform since that is where they are used.
plugins: (defaults to: [])

List of plugins that should be run during compilation of the target. A list of strings may additionally be provided in order to pass additional arguments to the plugin.
provided_deps: (defaults to: [])

These represent dependencies that are known to be provided at run time, but are required in order for the code to compile. Examples of provided_deps include the JEE servlet APIs. When this rule is included in a , the provided_deps will not be packaged into the output.
provided_deps_query: (defaults to: None)

Status: experimental/unstable. The provided deps query functions in the same way as the deps query, but the results of the query are appended to the declared provided deps.
remove_classes: (defaults to: [])

List of classes to remove from the output jar. It only removes classes from the target's own sources, not from any of its dependencies.
required_for_source_only_abi: (defaults to: False)

Indicates that this rule must be present on the classpath during source-only ABI generation of any rule that depends on it. Typically this is done when a rule contains annotations, enums, constants, or interfaces.

Having rules present on the classpath during source-only ABI generation prevents Buck from completely flattening the build graph, thus reducing the performance win from source-only ABI generation. These rules should be kept small (ideally just containing annotations, constants, enums, and interfaces) and with minimal dependencies of their own.
resources: (defaults to: [])

Static files to include among the compiled .class files. These files can be loaded via Class.getResource().

Note: Buck uses the src_roots property in .buckconfig to help determine where resources should be placed within the generated JAR file.
source: (defaults to: None)

Specifies the version of Java (as a string) to interpret source files as. Overrides the value in "source_level" in the "java" section of .buckconfig.
source_only_abi_deps: (defaults to: [])

These are dependencies that must be present during source-only ABI generation. Typically such dependencies are added when some property of the code in this rule prevents source-only ABI generation from being correct without these dependencies being present.

Having source_only_abi_deps prevents Buck from completely flattening the build graph, thus reducing the performance win from source-only ABI generation. They should be avoided when possible. Often only a small code change is needed to avoid them. For more information on such code changes, read about source-only ABI generation.
srcs: (defaults to: [])

The set of .java files to compile for this rule.
target: (defaults to: None)

Specifies the version of Java (as a string) for which to generate code. Overrides the value in "target_level" in the "java" section of .buckconfig.

Examples

An android_library rule used in concert with an android_resource() rule. This would be a common arrangement for a standard Android Library project as defined by http://developer.android.com/tools/projects/index.html

android_resource(
  name = 'res',
  res = 'res',
  package = 'com.example',
)

android_library(
  name = 'my_library',
  srcs = glob(['src/**/*.java']),
  deps = [
    ':res',
  ],
)

Function Signature​

Parameters​

Examples​

Function Signature

Parameters

Examples