Build Docs

name string, The name of the module. Must be unique across all modules.

srcs list of string, path to the source file that is the main entry point of the program (e.g. main.rs or lib.rs)

defaults list of string

host_supported bool, If set to true, build a variant of the module for the host. Defaults to false.

device_supported bool, If set to true, build a variant of the module for the device. Defaults to true.

androidMkDylibs list of string

androidMkProcMacroLibs list of string

androidMkRlibs list of string

androidMkSharedLibs list of string

androidMkStaticLibs list of string

apex_available list of string, Availability of this module in APEXes. Only the listed APEXes can contain this module. If the module has stubs then other APEXes and the platform may access it through them (subject to visibility). "//apex_available:anyapex" is a pseudo APEX name that matches to any APEX. "//apex_available:platform" refers to non-APEX partitions like "system.img". "com.android.gki.*" matches any APEX module name with the prefix "com.android.gki.". Default is ["//apex_available:platform"].

arch interface

cfgs list of string, list of configuration options to enable for this crate. To enable features, use the "features" property.

clippy_lints string, name of the lint set that should be used to validate this module. Possible values are "default" (for using a sensible set of lints depending on the module's location), "android" (for the strictest lint set that applies to all Android platform code), "vendor" (for a relaxed set) and "none" (to disable the execution of clippy). The default value is "default". See also the `lints` property.

compile_multilib string, control whether this module compiles for 32-bit, 64-bit, or both. Possible values are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both architectures), or "first" (compile for 64-bit on a 64-bit platform, and 32-bit on a 32-bit platform).

crate_name string, crate name, required for modules which produce Rust libraries: rust_library, rust_ffi and SourceProvider modules which create library variants (rust_bindgen). This must be the expected extern crate name used in source, and is required to conform to an enforced format matching library output files (if the output file is lib<someName><suffix>, the crate_name property must be <someName>).

device_specific bool, whether this module is specific to a device, not only for SoC, but also for off-chip peripherals. When set to true, it is installed into /odm (or /vendor/odm if odm partition does not exist, or /system/vendor/odm if both odm and vendor partitions do not exist). This implies `soc_specific:true`.

dists list of Dist, a list of configurations to distribute output files from this module to the distribution directory (default: $OUT/dist, configurable with $DIST_DIR)

double_loadable bool, whether this module is capable of being loaded with other instance (possibly an older version) of the same module in the same process. Currently, a shared library that is a member of VNDK (vndk: {enabled: true}) can be double loaded in a vendor process if the library is also a (direct and indirect) dependency of an LLNDK library. Such libraries must be explicitly marked as `double_loadable: true` by the owner, or the dependency from the LLNDK lib should be cut if the lib is not designed to be double loaded.

dylibs list of string, list of rust dylib crate dependencies

edition string, specific rust edition that should be used if the default version is not desired

enabled bool, emit build rules for this module Disabling a module should only be done for those modules that cannot be built in the current environment. Modules that can build in the current environment but are not usually required (e.g. superceded by a prebuilt) should not be disabled as that will prevent them from being built by the checkbuild target and so prevent early detection of changes that have broken those modules.

features list of string, list of features to enable for this crate

flags list of string, flags to pass to rustc. To enable configuration options or features, use the "cfgs" or "features" properties.

hideFromMake bool

host_required list of string, names of other modules to install on host if this module is installed

init_rc list of string, init.rc files to be installed if this module is installed

ld_flags list of string, flags to pass to the linker

licenses list of string, Describes the licenses applicable to this module. Must reference license modules.

lints string, name of the lint set that should be used to validate this module. Possible values are "default" (for using a sensible set of lints depending on the module's location), "android" (for the strictest lint set that applies to all Android platform code), "vendor" (for a relaxed set) and "none" (for ignoring all lint warnings and errors). The default value is "default".

min_sdk_version string, Minimum sdk version that the artifact should support when it runs as part of mainline modules(APEX).

multilib interface

native_bridge_supported bool, Whether this module is built for non-native architectures (also known as native bridge binary)

native_coverage bool

no_stdlibs bool, whether to suppress inclusion of standard crates - defaults to false

notice string, relative path to a file to include in the list of notices for the device

odm_available bool, This is the same as the "vendor_available" except that the install path of the vendor variant is /odm or /vendor/odm. By replacing "vendor_available: true" with "odm_available: true", the module will install its vendor variant to the /odm partition or /vendor/odm. As the modules with "odm_available: true" still create the vendor variants, they can link to the other vendor modules as the vendor_available modules do. Also, the vendor modules can link to odm_available modules. It may not be used for VNDK modules.

owner string, vendor who owns this module

prefer_rlib bool, Change the rustlibs linkage to select rlib linkage by default for device targets. Also link libstd as an rlib as well on device targets. Note: This is the default behavior for host targets. This is primarily meant for rust_binary and rust_ffi modules where the default linkage of libstd might need to be overridden in some use cases. This should generally be avoided with other module types since it may cause collisions at linkage if all dependencies of the root binary module do not link against libstd\ the same way.

preventInstall bool

proc_macros list of string, list of rust proc_macro crate dependencies

product_available bool, whether this module should be allowed to be directly depended by other modules with `product_specific: true` or `product_available: true`. If set to true, an additional product variant will be built separately that is limited to the set of libraries and headers that are exposed to /product modules. The product variant may be used with a different (newer) /system, so it shouldn't have any unversioned runtime dependencies, or make assumptions about the system that may not be true in the future. If set to false, this module becomes inaccessible from /product modules. Different from the 'vendor_available' property, the modules with vndk: {enabled: true} don't have to define 'product_available'. The VNDK library without 'product_available' may not be depended on by any other modules that has product variants including the product available VNDKs. Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk and PRODUCT_PRODUCT_VNDK_VERSION isn't set.

product_specific bool, whether this module is specific to a software configuration of a product (e.g. country, network operator, etc). When set to true, it is installed into /product (or /system/product if product partition does not exist).

proprietary bool, whether this is a proprietary vendor module, and should be installed into /vendor

ramdisk bool, Whether this module is installed to ramdisk

recovery bool, Whether this module is installed to recovery partition

relative_install_path string, install to a subdirectory of the default install path for the module

required list of string, names of other modules to install if this module is installed

rlibs list of string, list of rust rlib crate dependencies

rustlibs list of string, list of rust automatic crate dependencies

shared_libs list of string, list of C shared library dependencies

soc_specific bool, whether this module is specific to an SoC (System-On-a-Chip). When set to true, it is installed into /vendor (or /system/vendor if vendor partition does not exist).

static_executable bool, Builds this binary as a static binary. Implies prefer_rlib true. Static executables currently only support for bionic targets. Non-bionic targets will not produce a fully static binary, but will still implicitly imply prefer_rlib true.

static_libs list of string, list of C static library dependencies. These dependencies do not normally propagate to dependents and may need to be redeclared. See whole_static_libs for bundling static dependencies into a library.

stem string, sets name of the output

suffix string, append to name of output

system_ext_specific bool, whether this module extends system. When set to true, it is installed into /system_ext (or /system/system_ext if system_ext partition does not exist).

target interface

target_required list of string, names of other modules to install on target if this module is installed

vendor bool, whether this module is specific to an SoC (System-On-a-Chip). When set to true, it is installed into /vendor (or /system/vendor if vendor partition does not exist). Use `soc_specific` instead for better meaning.

vendor_available bool, whether this module should be allowed to be directly depended by other modules with `vendor: true`, `proprietary: true`, or `vendor_available:true`. If set to true, two variants will be built separately, one like normal, and the other limited to the set of libraries and headers that are exposed to /vendor modules. The vendor variant may be used with a different (newer) /system, so it shouldn't have any unversioned runtime dependencies, or make assumptions about the system that may not be true in the future. If set to false, this module becomes inaccessible from /vendor modules. The modules with vndk: {enabled: true} must define 'vendor_available' to 'true'. Nothing happens if BOARD_VNDK_VERSION isn't set in the BoardConfig.mk

vendor_ramdisk bool, Whether this module is installed to vendor ramdisk

vendor_ramdisk_available bool, Make this module available when building for vendor ramdisk. On device without a dedicated recovery partition, the module is only available after switching root into /first_stage_ramdisk. To expose the module before switching root, install the recovery variant instead (TODO(b/165791368) recovery not yet supported)

vintf_fragments list of string, VINTF manifest fragments to be installed if this module is installed

visibility list of string, Controls the visibility of this module to other modules. Allowable values are one or more of these formats:


 ["//visibility:public"]: Anyone can use this module.
 ["//visibility:private"]: Only rules in the module's package (not its subpackages) can use
     this module.
 ["//visibility:override"]: Discards any rules inherited from defaults or a creating module.
     Can only be used at the beginning of a list of visibility rules.
 ["//some/package:__pkg__", "//other/package:__pkg__"]: Only modules in some/package and
     other/package (defined in some/package/*.bp and other/package/*.bp) have access to
     this module. Note that sub-packages do not have access to the rule; for example,
     //some/package/foo:bar or //other/package/testing:bla wouldn't have access. __pkg__
     is a special module and must be used verbatim. It represents all of the modules in the
     package.
 ["//project:__subpackages__", "//other:__subpackages__"]: Only modules in packages project
     or other or in one of their sub-packages have access to this module. For example,
     //project:rule, //project/library:lib or //other/testing/internal:munge are allowed
     to depend on this rule (but not //independent:evil)
 ["//project"]: This is shorthand for ["//project:__pkg__"]
 [":__subpackages__"]: This is shorthand for ["//project:__subpackages__"] where
     //project is the module's package. e.g. using [":__subpackages__"] in
     packages/apps/Settings/Android.bp is equivalent to
     //packages/apps/Settings:__subpackages__.
 ["//visibility:legacy_public"]: The default visibility, behaves as //visibility:public
     for now. It is an error if it is used in a module.

If a module does not specify the `visibility` property then it uses the `default_visibility` property of the `package` module in the module's package. If the `default_visibility` property is not set for the module's package then it will use the `default_visibility` of its closest ancestor package for which a `default_visibility` property is specified. If no `default_visibility` property can be found then the module uses the global default of `//visibility:legacy_public`. The `visibility` property has no effect on a defaults module although it does apply to any non-defaults module that uses it. To set the visibility of a defaults module, use the `defaults_visibility` property on the defaults module; not to be confused with the `default_visibility` property on the package module. See https://android.googlesource.com/platform/build/soong/+/master/README.md#visibility for more details.

whole_static_libs list of string, Similar to static_libs, but will bundle the static library dependency into a library. This is helpful to avoid having to redeclare the dependency for dependents of this library, but in some cases may also result in bloat if multiple dependencies all include the same static library whole. The common use case for this is when the static library is unlikely to be a dependency of other modules to avoid having to redeclare the static library dependency for every dependent module. If you are not sure what to, for rust_library modules most static dependencies should go in static_libraries, and for rust_ffi modules most static dependencies should go into whole_static_libraries. For rust_ffi static variants, these libraries will be included in the resulting static library archive. For rust_library rlib variants, these libraries will be bundled into the resulting rlib library. This will include all of the static libraries symbols in any dylibs or binaries which use this rlib as well.