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). Only a single source file can be defined. Modules which generate source can be included by prefixing the module name with ":", for example ":libfoo_bindgen" If no source file is defined, a single generated source module can be defined to be used as the main source.

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.

afdo bool, Afdo allows developers self-service enroll for automatic feedback-directed optimization using profile data.

aliases list of string, Rust crate dependencies to rename. Each entry should be a string of the form "dependencyname:alias". "dependencyname" here should be the name of the crate, not the Android module. This is equivalent to writing `alias = { package = "dependencyname" }` in a `Cargo.toml`.

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". Prefix pattern (com.foo.*) can be used to match with any APEX name with the prefix(com.foo.). Default is ["//apex_available:platform"].

arch interface

auto_gen_config bool, Flag to indicate whether or not to create test config automatically. If AndroidTest.xml doesn't exist next to the Android.bp, this attribute doesn't need to be set to true explicitly.

bootstrap bool, Allows this module to use non-APEX version of libraries. Useful for building binaries that are started before APEXes are activated.

cargo_env_compat bool, Enables emitting certain Cargo environment variables. Only intended to be used for compatibility purposes. Will set CARGO_CRATE_NAME to the crate_name property's value. Will set CARGO_BIN_NAME to the output filename value without the extension.

cargo_pkg_version string, If cargo_env_compat is true, sets the CARGO_PKG_VERSION env var to this value.

cfgs configurable 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>).

crate_root string, Entry point that is passed to rustc to begin the compilation. E.g. main.rs or lib.rs. When this property is set,


   * sandboxing is enabled for this module, and
   * the srcs attribute is interpreted as a list of all source files potentially
         used in compilation, including the entrypoint, and
   * compile_data can be used to add additional files used in compilation that
         not directly used as source files.

debug_ramdisk bool, Whether this module is installed to debug ramdisk

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.

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

enabled configurable 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.

exclude_from_recovery_snapshot bool, Normally Soong uses the directory structure to decide which modules should be included (framework) or excluded (non-framework) from the different snapshots (vendor, recovery, etc.), but this property allows a partner to exclude a module normally thought of as a framework module from the recovery snapshot.

exclude_from_vendor_snapshot bool, Normally Soong uses the directory structure to decide which modules should be included (framework) or excluded (non-framework) from the different snapshots (vendor, recovery, etc.), but this property allows a partner to exclude a module normally thought of as a framework module from the vendor snapshot.

features configurable 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.

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

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

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

installable bool

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 OS API level supported by this C or C++ module. This property becomes the value of the __ANDROID_API__ macro. When the C or C++ module is included in an APEX or an APK, this property is also used to ensure that the min_sdk_version of the containing module is not older (i.e. less) than this module's min_sdk_version. When not set, this property defaults to the value of sdk_version. When this is set to "apex_inherit", this tracks min_sdk_version of the containing APEX. When the module is not built for an APEX, "apex_inherit" defaults to sdk_version.

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_full_install bool, When set to true, this module is not installed to the full install path (ex: under out/target/product/<name>/<partition>). It can be installed only to the packaging modules like android_filesystem.

no_named_install_directory bool, Disables the creation of a test-specific directory when used with relative_install_path. Useful if several tests need to be in the same directory.

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

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.

odm_dlkm_specific bool, Install to partition odm_dlkm when set to true.

overrides list of string, List of module names that are prevented from being installed when this module gets installed.

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.

proc_macros configurable 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

ramdisk_available bool, Make this module available when building for 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.

recovery bool, Whether this module is installed to recovery partition

recovery_available bool, Make this module available when building for recovery

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

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

rlibs configurable list of string, list of rust rlib crate dependencies

rustlibs configurable list of string, list of rust automatic crate dependencies. Rustlibs linkage is rlib for host targets and dylib for device targets.

sdk_version string, The API level that this module is built against. The APIs of this API level will be visible at build time, but use of any APIs newer than min_sdk_version will render the module unloadable on older devices. In the future it will be possible to weakly-link new APIs, making the behavior match Java: such modules will load on older devices, but calling new APIs on devices that do not support them will result in a crash. This property has the same behavior as sdk_version does for Java modules. For those familiar with Android Gradle, the property behaves similarly to how compileSdkVersion does for Java code. In addition, setting this property causes two variants to be built, one for the platform and one for apps.

shared_libs configurable 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 configurable 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.

stdlibs configurable list of string, list of Rust system library dependencies. This is usually only needed when `no_stdlibs` is true, in which case it can be used to depend on system crates like `core` and `alloc`.

stem string, sets name of the output

suffix string, append to name of output

system_dlkm_specific bool, Install to partition system_dlkm when set to true.

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

team string, The team (defined by the owner/vendor) who owns the property.

test_config string, the name of the test configuration (for example "AndroidBenchmark.xml") that should be installed with the module.

test_config_template string, the name of the test configuration template (for example "AndroidBenchmarkTemplate.xml") that should be installed with the module.

test_suites list of string, list of compatibility suites (for example "cts", "vts") that the module should be installed into.

use_expansive_default_srcs bool, Set this to true to use an expansive default set of source file requirements (all .rs, .h, .xml, and .md files in the module tree). This is primarily for tracking sources for RBE purposes. Currently defaults to true, though this may change in the future.

use_generic_config bool, Set to true if this module must be generic and does not require product-specific information. To be included in the system image, this property must be set to true.

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_dlkm_specific bool, Install to partition vendor_dlkm when set to true.

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

vintf_fragment_modules configurable list of string, vintf_fragment Modules required from this module.

vintf_fragments configurable 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/+/main/README.md#visibility for more details.

whole_static_libs configurable 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.