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

 srcs list of string, path to the prebuilt file

 defaults list of string

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

 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

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

 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.

 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.

 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 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_required list of string, names of other modules to install on host if this module is installed

 include_dirs list of string, path to include directories to pass to cc_* modules, only relevant for static/shared variants.

 init_rc 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.

 link_dirs list of string, directories containing associated rlib dependencies

 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 Default: true

 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 bool, When prefer is set to true the prebuilt will be used instead of any source module with a matching name.

 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 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 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_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.

 stdlibs 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

 sysroot bool, Whether this library is part of the Rust toolchain sysroot.

 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

 use_source_config_var ConfigVarProperties, When specified this names a Soong config variable that controls the prefer property. If the value of the named Soong config variable is true then prefer is set to false and vice versa. If the Soong config variable is not set then it defaults to false, so prefer defaults to true. If specified then the prefer property is ignored in favor of the value of the Soong config variable.

 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

 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.