// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// package apex implements build rules for creating the APEX files which are container for
// lower-level system components. See https://source.android.com/devices/tech/ota/apex
package apex

import (
 "fmt"
 "path"
 "path/filepath"
 "regexp"
 "slices"
 "sort"
 "strings"

 "github.com/google/blueprint"
 "github.com/google/blueprint/depset"
 "github.com/google/blueprint/proptools"

 "android/soong/android"
 "android/soong/bpf"
 "android/soong/cc"
 "android/soong/dexpreopt"
 prebuilt_etc "android/soong/etc"
 "android/soong/filesystem"
 "android/soong/java"
 "android/soong/rust"
 "android/soong/sh"
)

var sdvApexPattern = regexp.MustCompile(`^com\.(?:\w+\.)?sdv\.`)

func init() {
 registerApexBuildComponents(android.InitRegistrationContext)
}

func registerApexBuildComponents(ctx android.RegistrationContext) {
 ctx.RegisterModuleType("apex", BundleFactory)
 ctx.RegisterModuleType("apex_test", TestApexBundleFactory)
 ctx.RegisterModuleType("apex_vndk", vndkApexBundleFactory)
 ctx.RegisterModuleType("apex_defaults", DefaultsFactory)
 ctx.RegisterModuleType("prebuilt_apex", PrebuiltFactory)
 ctx.RegisterModuleType("override_apex", OverrideApexFactory)
 ctx.RegisterModuleType("apex_set", apexSetFactory)

 ctx.PreDepsMutators(RegisterPreDepsMutators)
 ctx.PostDepsMutators(RegisterPostDepsMutators)
}

func RegisterPreDepsMutators(ctx android.RegisterMutatorsContext) {
 ctx.BottomUp("apex_vndk_deps", apexVndkDepsMutator).UsesReverseDependencies()
}

func RegisterPostDepsMutators(ctx android.RegisterMutatorsContext) {
 ctx.BottomUp("apex_unique", apexUniqueVariationsMutator)
 // Run mark_platform_availability before the apexMutator as the apexMutator needs to know whether
 // it should create a platform variant.
 ctx.BottomUp("mark_platform_availability", markPlatformAvailability)
 ctx.InfoBasedTransition("apex", android.NewGenericTransitionMutatorAdapter(&apexTransitionMutator{}))
}

type apexBundleProperties struct {
 // Json manifest file describing meta info of this APEX bundle. Refer to
 // system/apex/proto/apex_manifest.proto for the schema. Default: "apex_manifest.json"
 Manifest *string `android:"path"`

 // AndroidManifest.xml file used for the zip container of this APEX bundle. If unspecified,
 // a default one is automatically generated.
 AndroidManifest proptools.Configurable[string] `android:"path,replace_instead_of_append"`

 // Determines the file contexts file for setting the security contexts to files in this APEX
 // bundle. For platform APEXes, this should points to a file under /system/sepolicy Default:
 // /system/sepolicy/apex/<module_name>_file_contexts.
 File_contexts *string `android:"path"`

 // Path to the canned fs config file for customizing file's
 // uid/gid/mod/capabilities. The content of this file is appended to the
 // default config, so that the custom entries are preferred. The format is
 // /<path_or_glob> <uid> <gid> <mode> [capabilities=0x<cap>], where
 // path_or_glob is a path or glob pattern for a file or set of files,
 // uid/gid are numerial values of user ID and group ID, mode is octal value
 // for the file mode, and cap is hexadecimal value for the capability.
 Canned_fs_config proptools.Configurable[string] `android:"path,replace_instead_of_append"`

 ApexNativeDependencies

 Multilib apexMultilibProperties

 // List of runtime resource overlays (RROs) that are embedded inside this APEX.
 Rros []string

 // List of bootclasspath fragments that are embedded inside this APEX bundle.
 Bootclasspath_fragments proptools.Configurable[[]string]

 // List of systemserverclasspath fragments that are embedded inside this APEX bundle.
 Systemserverclasspath_fragments proptools.Configurable[[]string]

 // List of java libraries that are embedded inside this APEX bundle.
 Java_libs []string

 // List of sh binaries that are embedded inside this APEX bundle.
 Sh_binaries proptools.Configurable[[]string]

 // List of platform_compat_config files that are embedded inside this APEX bundle.
 Compat_configs proptools.Configurable[[]string]

 // List of module names which we don't want to add as transitive deps. This can be used as
 // a workaround when the current implementation collects more than necessary. For example,
 // Rust binaries with prefer_rlib:true add unnecessary dependencies.
 Unwanted_transitive_deps []string

 // Whether this APEX is considered updatable or not. When set to true, this will enforce
 // additional rules for making sure that the APEX is truly updatable. To be updatable,
 // min_sdk_version should be set as well. This will also disable the size optimizations like
 // symlinking to the system libs. Default is true.
 Updatable *bool

 // Marks that this APEX is designed to be updatable in the future, although it's not
 // updatable yet. This is used to mimic some of the build behaviors that are applied only to
 // updatable APEXes. Currently, this disables the size optimization, so that the size of
 // APEX will not increase when the APEX is actually marked as truly updatable. Default is
 // false.
 Future_updatable *bool

 // Whether this APEX can use platform APIs or not. Can be set to true only when `updatable:
 // false`. Default is false.
 Platform_apis *bool

 // Whether this APEX is installable to one of the partitions like system, vendor, etc.
 // Default: true.
 Installable *bool

 // The type of filesystem to use. Either 'ext4', 'f2fs' or 'erofs'. Default 'ext4'.
 Payload_fs_type *string

 // Override default settings (PRODUCT_DEFAULT_APEX_PAYLOAD_EROFS_*) for EROFS APEX
 Erofs struct {
  // Compressor and Compression level passed to mkfs.erofs. e.g. (lz4hc,9)
  // Please see external/erofs-utils/README for complete documentation.
  // Use "none" for uncompressed EROFS image.
  // Default: (defined in apexer)
  Compressor *string

  // Used as --compress-hints for mkfs.erofs
  Compress_hints *string `android:"path"`

  // Specify the size of compress physical cluster in bytes
  // Default: (defined in apexer)
  Pcluster_size *int64
 }

 // For telling the APEX to ignore special handling for system libraries such as bionic.
 // Default is false.
 Ignore_system_library_special_case *bool

 // Whenever apex_payload.img of the APEX should not be dm-verity signed. Should be only
 // used in tests.
 Test_only_unsigned_payload *bool

 // Whenever apex should be compressed, regardless of product flag used. Should be only
 // used in tests.
 Test_only_force_compression *bool

 // Put extra tags (signer=<value>) to apexkeys.txt, so that release tools can sign this apex
 // with the tool to sign payload contents.
 Custom_sign_tool *string

 // Whether this is a dynamic common lib apex, if so the native shared libs will be placed
 // in a special way that include the digest of the lib file under /lib(64)?
 Dynamic_common_lib_apex *bool

 // Canonical name of this APEX bundle. Used to determine the path to the
 // activated APEX on device (i.e. /apex/<apexVariationName>), and used for the
 // apex mutator variations. For override_apex modules, this is the name of the
 // overridden base module.
 ApexVariationName string `blueprint:"mutated"`

 // List of sanitizer names that this APEX is enabled for
 SanitizerNames []string `blueprint:"mutated"`

 HideFromMake bool `blueprint:"mutated"`

 // Name that dependencies can specify in their apex_available properties to refer to this module.
 // If not specified, this defaults to Soong module name. This must be the name of a Soong module.
 Apex_available_name *string

 // Variant version of the mainline module. Must be an integer between 0-9
 Variant_version *string
}

type ApexNativeDependencies struct {
 // List of native libraries that are embedded inside this APEX.
 Native_shared_libs proptools.Configurable[[]string]

 // List of JNI libraries that are embedded inside this APEX.
 Jni_libs proptools.Configurable[[]string]

 // List of rust dyn libraries that are embedded inside this APEX.
 Rust_dyn_libs []string

 // List of native executables that are embedded inside this APEX.
 Binaries proptools.Configurable[[]string]

 // List of native tests that are embedded inside this APEX.
 Tests []string

 // List of filesystem images that are embedded inside this APEX bundle.
 Filesystems []string

 // List of prebuilt_etcs that are embedded inside this APEX bundle.
 Prebuilts proptools.Configurable[[]string]

 // List of prebuilt_kernel_modules that are embedded inside this APEX bundle.
 Kernel_modules []string

 // List of native libraries to exclude from this APEX.
 Exclude_native_shared_libs []string

 // List of JNI libraries to exclude from this APEX.
 Exclude_jni_libs []string

 // List of rust dyn libraries to exclude from this APEX.
 Exclude_rust_dyn_libs []string

 // List of native executables to exclude from this APEX.
 Exclude_binaries []string

 // List of native tests to exclude from this APEX.
 Exclude_tests []string

 // List of filesystem images to exclude from this APEX bundle.
 Exclude_filesystems []string

 // List of prebuilt_etcs to exclude from this APEX bundle.
 Exclude_prebuilts []string

 // List of prebuilt_kernel_modules to exclude from this APEX bundle.
 Exclude_kernel_modules []string
}

type ResolvedApexNativeDependencies struct {
 // List of native libraries that are embedded inside this APEX.
 Native_shared_libs []string

 // List of JNI libraries that are embedded inside this APEX.
 Jni_libs []string

 // List of rust dyn libraries that are embedded inside this APEX.
 Rust_dyn_libs []string

 // List of native executables that are embedded inside this APEX.
 Binaries []string

 // List of native tests that are embedded inside this APEX.
 Tests []string

 // List of filesystem images that are embedded inside this APEX bundle.
 Filesystems []string

 // List of prebuilt_etcs that are embedded inside this APEX bundle.
 Prebuilts []string

 // List of prebuilt_kernel_modules that are embedded inside this APEX bundle.
 Kernel_modules []string

 // List of native libraries to exclude from this APEX.
 Exclude_native_shared_libs []string

 // List of JNI libraries to exclude from this APEX.
 Exclude_jni_libs []string

 // List of rust dyn libraries to exclude from this APEX.
 Exclude_rust_dyn_libs []string

 // List of native executables to exclude from this APEX.
 Exclude_binaries []string

 // List of native tests to exclude from this APEX.
 Exclude_tests []string

 // List of filesystem images to exclude from this APEX bundle.
 Exclude_filesystems []string

 // List of prebuilt_etcs to exclude from this APEX bundle.
 Exclude_prebuilts []string

 // List of prebuilt_kernel_modules to exclude from this APEX bundle.
 Exclude_kernel_modules []string
}

// Merge combines another ApexNativeDependencies into this one
func (a *ResolvedApexNativeDependencies) Merge(ctx android.BaseModuleContext, b ApexNativeDependencies) {
 a.Native_shared_libs = append(a.Native_shared_libs, b.Native_shared_libs.GetOrDefault(ctx, nil)...)
 a.Jni_libs = append(a.Jni_libs, b.Jni_libs.GetOrDefault(ctx, nil)...)
 a.Rust_dyn_libs = append(a.Rust_dyn_libs, b.Rust_dyn_libs...)
 a.Binaries = append(a.Binaries, b.Binaries.GetOrDefault(ctx, nil)...)
 a.Tests = append(a.Tests, b.Tests...)
 a.Filesystems = append(a.Filesystems, b.Filesystems...)
 a.Prebuilts = append(a.Prebuilts, b.Prebuilts.GetOrDefault(ctx, nil)...)
 a.Kernel_modules = append(a.Kernel_modules, b.Kernel_modules...)

 a.Exclude_native_shared_libs = append(a.Exclude_native_shared_libs, b.Exclude_native_shared_libs...)
 a.Exclude_jni_libs = append(a.Exclude_jni_libs, b.Exclude_jni_libs...)
 a.Exclude_rust_dyn_libs = append(a.Exclude_rust_dyn_libs, b.Exclude_rust_dyn_libs...)
 a.Exclude_binaries = append(a.Exclude_binaries, b.Exclude_binaries...)
 a.Exclude_tests = append(a.Exclude_tests, b.Exclude_tests...)
 a.Exclude_filesystems = append(a.Exclude_filesystems, b.Exclude_filesystems...)
 a.Exclude_prebuilts = append(a.Exclude_prebuilts, b.Exclude_prebuilts...)
 a.Exclude_kernel_modules = append(a.Exclude_kernel_modules, b.Exclude_kernel_modules...)
}

type apexMultilibProperties struct {
 // Native dependencies whose compile_multilib is "first"
 First ApexNativeDependencies

 // Native dependencies whose compile_multilib is "both"
 Both ApexNativeDependencies

 // Native dependencies whose compile_multilib is "prefer32"
 Prefer32 ApexNativeDependencies

 // Native dependencies whose compile_multilib is "32"
 Lib32 ApexNativeDependencies

 // Native dependencies whose compile_multilib is "64"
 Lib64 ApexNativeDependencies
}

type apexTargetBundleProperties struct {
 Target struct {
  // Multilib properties only for android.
  Android struct {
   Multilib apexMultilibProperties
  }

  // Multilib properties only for host.
  Host struct {
   Multilib apexMultilibProperties
  }

  // Multilib properties only for host linux_bionic.
  Linux_bionic struct {
   Multilib apexMultilibProperties
  }

  // Multilib properties only for host linux_glibc.
  Linux_glibc struct {
   Multilib apexMultilibProperties
  }
 }
}

type apexArchBundleProperties struct {
 Arch struct {
  Arm struct {
   ApexNativeDependencies
  }
  Arm64 struct {
   ApexNativeDependencies
  }
  Riscv64 struct {
   ApexNativeDependencies
  }
  X86 struct {
   ApexNativeDependencies
  }
  X86_64 struct {
   ApexNativeDependencies
  }
 }
}

// These properties can be used in override_apex to override the corresponding properties in the
// base apex.
type overridableProperties struct {
 // List of APKs that are embedded inside this APEX.
 Apps proptools.Configurable[[]string]

 // List of prebuilt files that are embedded inside this APEX bundle.
 Prebuilts proptools.Configurable[[]string]

 // List of BPF programs inside this APEX bundle.
 Bpfs proptools.Configurable[[]string]

 // Names of modules to be overridden. Listed modules can only be other binaries (in Make or
 // Soong). This does not completely prevent installation of the overridden binaries, but if
 // both binaries would be installed by default (in PRODUCT_PACKAGES) the other binary will
 // be removed from PRODUCT_PACKAGES.
 Overrides []string

 Multilib apexMultilibProperties

 // Logging parent value.
 Logging_parent string

 // Apex Container package name. Override value for attribute package:name in
 // AndroidManifest.xml
 Package_name proptools.Configurable[string]

 // A txt file containing list of files that are allowed to be included in this APEX.
 Allowed_files *string `android:"path"`

 // Name of the apex_key module that provides the private key to sign this APEX bundle.
 Key *string

 // Specifies the certificate and the private key to sign the zip container of this APEX. If
 // this is "foo", foo.x509.pem and foo.pk8 under PRODUCT_DEFAULT_DEV_CERTIFICATE are used
 // as the certificate and the private key, respectively. If this is ":module", then the
 // certificate and the private key are provided from the android_app_certificate module
 // named "module".
 Certificate *string

 // Whether this APEX can be compressed or not. Setting this property to false means this
 // APEX will never be compressed. When set to true, APEX will be compressed if other
 // conditions, e.g., target device needs to support APEX compression, are also fulfilled.
 // Default: false.
 Compressible *bool

 // Trim against a specific Dynamic Common Lib APEX
 Trim_against *string

 // The minimum SDK version that this APEX must support at minimum. This is usually set to
 // the SDK version that the APEX was first introduced.
 Min_sdk_version proptools.Configurable[string] `android:"replace_instead_of_append"`

 // Mainline beta namespace. Each mainline module would have a dedicated server side
 // namespace to support flag based A/B feature testing on mainline beta population.
 Beta_namespace *string

 // Mark the apex as non-production. Google Play Store will prevent it from being
 // distributed to production channels.
 Non_production *bool
}

// installPair stores a path to a built object and its install location.  It is used for holding
// the installation location of the dexpreopt artifacts for system server jars in apexes that need
// to be installed when the apex is installed.
type installPair struct {
 from android.Path
 to   android.InstallPath
}

type installPairs []installPair

// String converts a list of installPair structs to the form accepted by LOCAL_SOONG_INSTALL_PAIRS.
func (p installPairs) String() string {
 sb := &strings.Builder{}
 for i, pair := range p {
  if i != 0 {
   sb.WriteByte(' ')
  }
  sb.WriteString(pair.from.String())
  sb.WriteByte(':')
  sb.WriteString(pair.to.String())
 }
 return sb.String()
}

type apexBundle struct {
 // Inherited structs
 android.ModuleBase
 android.DefaultableModuleBase
 android.OverridableModuleBase
 blueprint.ModuleUsesIncrementalWalkDeps

 // Properties
 properties            apexBundleProperties
 targetProperties      apexTargetBundleProperties
 archProperties        apexArchBundleProperties
 overridableProperties overridableProperties
 vndkProperties        apexVndkProperties // only for apex_vndk modules
 testProperties        apexTestProperties // only for apex_test modules

 ///////////////////////////////////////////////////////////////////////////////////////////
 // Inputs

 // Keys for apex_payload.img
 publicKeyFile  android.Path
 privateKeyFile android.Path

 // Cert/priv-key for the zip container
 containerCertificateFile android.Path
 containerPrivateKeyFile  android.Path

 // Flags for special variants of APEX
 testApex bool
 vndkApex bool

 // File system type of apex_payload.img
 payloadFsType fsType

 // Whether to create symlink to the system file instead of having a file inside the apex or
 // not
 linkToSystemLib bool

 // List of files to be included in this APEX. This is filled in the first part of
 // GenerateAndroidBuildActions.
 filesInfo []apexFile

 // List of files that were excluded by the unwanted_transitive_deps property.
 unwantedTransitiveFilesInfo []apexFile

 // List of files that were excluded due to conflicts with other variants of the same module.
 duplicateTransitiveFilesInfo []apexFile

 // List of other module names that should be installed when this APEX gets installed (LOCAL_REQUIRED_MODULES).
 makeModulesToInstall []string

 ///////////////////////////////////////////////////////////////////////////////////////////
 // Outputs (final and intermediates)

 // Processed apex manifest in JSONson format (for Q)
 manifestJsonOut android.WritablePath

 // Processed apex manifest in PB format (for R+)
 manifestPbOut android.WritablePath

 // Processed file_contexts files
 fileContexts android.WritablePath

 // The built APEX file. This is the main product.
 // Could be .apex or .capex
 outputFile android.WritablePath

 // The built uncompressed .apex file.
 outputApexFile android.WritablePath

 // The built APEX file in app bundle format. This file is not directly installed to the
 // device. For an APEX, multiple app bundles are created each of which is for a specific ABI
 // like arm, arm64, x86, etc. Then they are processed again (outside of the Android build
 // system) to be merged into a single app bundle file that Play accepts. See
 // vendor/google/build/build_unbundled_mainline_module.sh for more detail.
 bundleModuleFile android.WritablePath

 // Target directory to install this APEX. Usually out/target/product/<device>/<partition>/apex.
 installDir android.InstallPath

 // Path where this APEX was installed.
 installedFile android.InstallPath

 // Extra files that are installed alongside this APEX.
 extraInstalledFiles android.InstallPaths

 // The source and install locations for extraInstalledFiles for use in LOCAL_SOONG_INSTALL_PAIRS.
 extraInstalledPairs installPairs

 // fragment for this apex for apexkeys.txt
 apexKeysPath android.WritablePath

 // Installed locations of symlinks for backward compatibility.
 compatSymlinks android.InstallPaths

 // Text file having the list of individual files that are included in this APEX. Used for
 // debugging purpose.
 installedFilesFile android.Path

 // List of module names that this APEX is including (to be shown via *-deps-info target).
 // Used for debugging purpose.
 android.ApexBundleDepsInfo

 // Optional list of lint report zip files for apexes that contain java or app modules
 lintReports android.Paths

 isCompressed bool

 aconfigFiles []android.Path

 // Required modules, filled out during GenerateAndroidBuildActions and used in AndroidMk
 required []string

 // apkCerts of the apk-in-apex of this module
 apkCerts java.ApkCertsInfo
}

// apexFileClass represents a type of file that can be included in APEX.
type apexFileClass int

const (
 app apexFileClass = iota
 appSet
 etc
 javaSharedLib
 nativeExecutable
 nativeSharedLib
 nativeTest
 shBinary
)

// apexFile represents a file in an APEX bundle. This is created during the first half of
// GenerateAndroidBuildActions by traversing the dependencies of the APEX. Then in the second half
// of the function, this is used to create commands that copies the files into a staging directory,
// where they are packaged into the APEX file.
type apexFile struct {
 // buildFile is put in the installDir inside the APEX.
 builtFile  android.Path
 installDir string
 partition  string
 customStem string
 symlinks   []string             // additional symlinks
 extraZip   android.OptionalPath // addition zip files to be unzipped into installDir

 checkbuildTarget android.Path

 // Info for Android.mk Module name of `module` in AndroidMk. Note the generated AndroidMk
 // module for apexFile is named something like <AndroidMk module name>.<apex name>[<apex
 // suffix>]
 androidMkModuleName string             // becomes LOCAL_MODULE
 class               apexFileClass      // becomes LOCAL_MODULE_CLASS
 moduleDir           string             // becomes LOCAL_PATH
 dataPaths           []android.DataPath // becomes LOCAL_TEST_DATA

 // systemServerDexpreoptInstalls stores the list of dexpreopt artifacts for a system server jar.
 systemServerDexpreoptInstalls []java.DexpreopterInstall
 // systemServerDexJars stores the list of dexjars for a system server jar.
 systemServerDexJars android.Paths

 jacocoInfo            java.JacocoInfo  // only for javalibs and apps
 lintInfo              *java.LintInfo   // only for javalibs and apps
 certificate           java.Certificate // only for apps
 overriddenPackageName string           // only for apps

 transitiveDep bool
 isJniLib      bool

 multilib string

 // TODO(jiyong): remove this
 module    android.ModuleProxy
 providers *providerInfoForApexFile
}

type providerInfoForApexFile struct {
 commonInfo        *android.CommonModuleInfo
 javaInfo          *java.JavaInfo
 appInfo           *java.AppInfo
 ccInfo            *cc.CcInfo
 rustInfo          *rust.RustInfo
 linkableInfo      *cc.LinkableInfo
 vintfFragmentInfo *android.VintfFragmentInfo
}

// TODO(jiyong): shorten the arglist using an option struct
func newApexFile(ctx android.BaseModuleContext, builtFile android.Path, androidMkModuleName string,
 installDir string, class apexFileClass, module android.ModuleProxy) apexFile {
 ret := apexFile{
  builtFile:           builtFile,
  installDir:          installDir,
  androidMkModuleName: androidMkModuleName,
  class:               class,
  module:              module,
 }
 if !module.IsNil() {
  if buildTargetsInfo := android.GetModuleBuildTargets(ctx, module); buildTargetsInfo != nil {
   ret.checkbuildTarget = buildTargetsInfo.CheckbuildTarget
  }
  ret.moduleDir = ctx.OtherModuleDir(module)
  commonInfo := android.OtherModulePointerProviderOrDefault(ctx, module, android.CommonModuleInfoProvider)
  ret.partition = commonInfo.PartitionTag
  ret.multilib = commonInfo.Target.Arch.ArchType.Multilib
  ret.providers = &providerInfoForApexFile{}
  if commonInfo, ok := android.OtherModuleProvider(ctx, module, android.CommonModuleInfoProvider); ok {
   ret.providers.commonInfo = commonInfo
  }
  if javaInfo, ok := android.OtherModuleProvider(ctx, module, java.JavaInfoProvider); ok {
   ret.providers.javaInfo = javaInfo
  }
  if appInfo, ok := android.OtherModuleProvider(ctx, module, java.AppInfoProvider); ok {
   ret.providers.appInfo = appInfo
  }
  if ccInfo, ok := android.OtherModuleProvider(ctx, module, cc.CcInfoProvider); ok {
   ret.providers.ccInfo = ccInfo
  }
  if linkableInfo, ok := android.OtherModuleProvider(ctx, module, cc.LinkableInfoProvider); ok {
   ret.providers.linkableInfo = linkableInfo
  }
  if rustInfo, ok := android.OtherModuleProvider(ctx, module, rust.RustInfoProvider); ok {
   ret.providers.rustInfo = rustInfo
  }
  if vintfInfo, ok := android.OtherModuleProvider(ctx, module, android.VintfFragmentInfoProvider); ok {
   ret.providers.vintfFragmentInfo = &vintfInfo
  }
 }
 return ret
}

func (af *apexFile) ok() bool {
 return af.builtFile != nil && af.builtFile.String() != ""
}

// apexRelativePath returns the relative path of the given path from the install directory of this
// apexFile.
// TODO(jiyong): rename this
func (af *apexFile) apexRelativePath(path string) string {
 return filepath.Join(af.installDir, path)
}

// path returns path of this apex file relative to the APEX root
func (af *apexFile) path() string {
 return af.apexRelativePath(af.stem())
}

// stem returns the base filename of this apex file
func (af *apexFile) stem() string {
 if af.customStem != "" {
  return af.customStem
 }
 return af.builtFile.Base()
}

// symlinkPaths returns paths of the symlinks (if any) relative to the APEX root
func (af *apexFile) symlinkPaths() []string {
 var ret []string
 for _, symlink := range af.symlinks {
  ret = append(ret, af.apexRelativePath(symlink))
 }
 return ret
}

// availableToPlatform tests whether this apexFile is from a module that can be installed to the
// platform.
func (af *apexFile) availableToPlatform() bool {
 if af.providers == nil || af.providers.commonInfo == nil {
  return false
 }
 if af.providers.commonInfo.IsApexModule {
  return android.CheckAvailableForApex(android.AvailableToPlatform, af.providers.commonInfo.ApexAvailableFor)
 }
 return false
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// Mutators
//
// Brief description about mutators for APEX. The following three mutators are the most important
// ones.
//
// 1) DepsMutator: from the properties like native_shared_libs, java_libs, etc., modules are added
// to the (direct) dependencies of this APEX bundle.
//
// 2) apexInfoMutator: this is a post-deps mutator, so runs after DepsMutator. Its goal is to
// collect modules that are direct and transitive dependencies of each APEX bundle. The collected
// modules are marked as being included in the APEX via BuildForApex().
//
// 3) apexMutator: this is a post-deps mutator that runs after apexInfoMutator. For each module that
// are marked by the apexInfoMutator, apex variations are created using CreateApexVariations().

type dependencyTag struct {
 blueprint.BaseDependencyTag
 name string

 // Determines if the dependent will be part of the APEX payload. Can be false for the
 // dependencies to the signing key module, etc.
 payload bool

 // True if the dependent can only be a source module, false if a prebuilt module is a suitable
 // replacement. This is needed because some prebuilt modules do not provide all the information
 // needed by the apex.
 sourceOnly bool

 // If not-nil and an APEX is a member of an SDK then dependencies of that APEX with this tag will
 // also be added as exported members of that SDK.
 memberType android.SdkMemberType

 installable bool
}

type excludeFromVisibilityEnforcementDependencyTag struct {
 dependencyTag
}

func (e excludeFromVisibilityEnforcementDependencyTag) ExcludeFromVisibilityEnforcement() {}

func (d *dependencyTag) SdkMemberType(_ android.ModuleContext, _ android.ModuleProxy) android.SdkMemberType {
 return d.memberType
}

func (d *dependencyTag) ExportMember() bool {
 return true
}

func (d *dependencyTag) String() string {
 return fmt.Sprintf("apex.dependencyTag{%q}", d.name)
}

func (d *dependencyTag) ReplaceSourceWithPrebuilt() bool {
 return !d.sourceOnly
}

func (d *dependencyTag) InstallDepNeeded() bool {
 return d.installable
}

var _ android.ReplaceSourceWithPrebuilt = &dependencyTag{}
var _ android.SdkMemberDependencyTag = &dependencyTag{}

var (
 androidAppTag  = &dependencyTag{name: "androidApp", payload: true}
 bpfTag         = &dependencyTag{name: "bpf", payload: true}
 certificateTag = &dependencyTag{name: "certificate"}
 executableTag  = &dependencyTag{name: "executable", payload: true}
 fsTag          = &dependencyTag{name: "filesystem", payload: true}
 bcpfTag        = &dependencyTag{name: "bootclasspathFragment", payload: true, sourceOnly: true, memberType: java.BootclasspathFragmentSdkMemberType}
 // The dexpreopt artifacts of apex system server jars are installed onto system image.
 sscpfTag        = &dependencyTag{name: "systemserverclasspathFragment", payload: true, sourceOnly: true, memberType: java.SystemServerClasspathFragmentSdkMemberType, installable: true}
 compatConfigTag = &dependencyTag{name: "compatConfig", payload: true, sourceOnly: true, memberType: java.CompatConfigSdkMemberType}
 javaLibTag      = &dependencyTag{name: "javaLib", payload: true}
 jniLibTag       = &dependencyTag{name: "jniLib", payload: true}
 //TODO(b/465840743): Enable the visibility enforcement for keyTag dependency.
 keyTag           = &excludeFromVisibilityEnforcementDependencyTag{dependencyTag{name: "key"}}
 prebuiltTag      = &dependencyTag{name: "prebuilt", payload: true}
 rroTag           = &dependencyTag{name: "rro", payload: true}
 sharedLibTag     = &dependencyTag{name: "sharedLib", payload: true}
 testTag          = &dependencyTag{name: "test", payload: true}
 shBinaryTag      = &dependencyTag{name: "shBinary", payload: true}
 kernelModulesTag = &dependencyTag{name: "kernelModule", payload: true}
)

type fragmentInApexDepTag struct {
 blueprint.BaseDependencyTag
 android.FragmentInApexTag
}

func (fragmentInApexDepTag) ExcludeFromVisibilityEnforcement() {}

// fragmentInApexTag is used by apex modules to depend on their fragments.  Java bootclasspath
// modules can traverse from the apex to the fragment using android.IsFragmentInApexTag.
var fragmentInApexTag = fragmentInApexDepTag{}

// TODO(jiyong): shorten this function signature
func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext, nativeModules ResolvedApexNativeDependencies, target android.Target, imageVariation string) {
 binVariations := target.Variations()
 libVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"})
 rustLibVariations := append(
  target.Variations(), []blueprint.Variation{
   {Mutator: "rust_libraries", Variation: "dylib"},
  }...,
 )

 // Append "image" variation
 binVariations = append(binVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})
 libVariations = append(libVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})
 rustLibVariations = append(rustLibVariations, blueprint.Variation{Mutator: "image", Variation: imageVariation})

 // Use *FarVariation* to be able to depend on modules having conflicting variations with
 // this module. This is required since arch variant of an APEX bundle is 'common' but it is
 // 'arm' or 'arm64' for native shared libs.
 ctx.AddFarVariationDependencies(binVariations, executableTag,
  android.RemoveListFromList(nativeModules.Binaries, nativeModules.Exclude_binaries)...)
 ctx.AddFarVariationDependencies(binVariations, testTag,
  android.RemoveListFromList(nativeModules.Tests, nativeModules.Exclude_tests)...)
 ctx.AddFarVariationDependencies(libVariations, jniLibTag,
  android.RemoveListFromList(nativeModules.Jni_libs, nativeModules.Exclude_jni_libs)...)
 ctx.AddVariationDependencies(libVariations, sharedLibTag,
  android.RemoveListFromList(nativeModules.Native_shared_libs, nativeModules.Exclude_native_shared_libs)...)
 ctx.AddFarVariationDependencies(rustLibVariations, sharedLibTag,
  android.RemoveListFromList(nativeModules.Rust_dyn_libs, nativeModules.Exclude_rust_dyn_libs)...)
 ctx.AddFarVariationDependencies(target.Variations(), fsTag,
  android.RemoveListFromList(nativeModules.Filesystems, nativeModules.Exclude_filesystems)...)
 ctx.AddFarVariationDependencies(target.Variations(), prebuiltTag,
  android.RemoveListFromList(nativeModules.Prebuilts, nativeModules.Exclude_prebuilts)...)
 ctx.AddFarVariationDependencies(target.Variations(), kernelModulesTag,
  android.RemoveListFromList(nativeModules.Kernel_modules, nativeModules.Exclude_kernel_modules)...)
}

func (a *apexBundle) combineProperties(ctx android.BottomUpMutatorContext) {
 proptools.AppendProperties(&a.properties.Multilib, &a.targetProperties.Target.Android.Multilib, nil)
}

// getImageVariationPair returns a pair for the image variation name as its
// prefix and suffix. The prefix indicates whether it's core/vendor/product and the
// suffix indicates the vndk version for vendor/product if vndk is enabled.
// getImageVariation can simply join the result of this function to get the
// image variation name.
func (a *apexBundle) getImageVariationPair() (string, string) {
 if a.vndkApex {
  return cc.VendorVariationPrefix, a.vndkVersion()
 }

 prefix := android.CoreVariation
 if a.SocSpecific() || a.DeviceSpecific() {
  prefix = android.VendorVariation
 } else if a.ProductSpecific() {
  prefix = android.ProductVariation
 }

 return prefix, ""
}

// getImageVariation returns the image variant name for this apexBundle. In most cases, it's simply
// android.CoreVariation, but gets complicated for the vendor APEXes and the VNDK APEX.
func (a *apexBundle) getImageVariation() string {
 prefix, vndkVersion := a.getImageVariationPair()
 return prefix + vndkVersion
}

func (a *apexBundle) DepsMutator(ctx android.BottomUpMutatorContext) {
 // apexBundle is a multi-arch targets module. Arch variant of apexBundle is set to 'common'.
 // arch-specific targets are enabled by the compile_multilib setting of the apex bundle. For
 // each target os/architectures, appropriate dependencies are selected by their
 // target.<os>.multilib.<type> groups and are added as (direct) dependencies.
 targets := ctx.MultiTargets()
 imageVariation := a.getImageVariation()

 a.combineProperties(ctx)

 has32BitTarget := false
 for _, target := range targets {
  if target.Arch.ArchType.Multilib == "lib32" {
   has32BitTarget = true
  }
 }
 for i, target := range targets {
  var deps ResolvedApexNativeDependencies

  // Add native modules targeting both ABIs. When multilib.* is omitted for
  // native_shared_libs/jni_libs/tests, it implies multilib.both
  deps.Merge(ctx, a.properties.Multilib.Both)
  deps.Merge(ctx, ApexNativeDependencies{
   Native_shared_libs: a.properties.Native_shared_libs,
   Rust_dyn_libs:      a.properties.Rust_dyn_libs,
   Tests:              a.properties.Tests,
   Jni_libs:           a.properties.Jni_libs,
   Kernel_modules:     a.properties.Kernel_modules,
  })

  // Add native modules targeting the first ABI When multilib.* is omitted for
  // binaries, it implies multilib.first
  isPrimaryAbi := i == 0
  if isPrimaryAbi {
   deps.Merge(ctx, a.properties.Multilib.First)
   deps.Merge(ctx, ApexNativeDependencies{
    Native_shared_libs: proptools.NewConfigurable[[]string](nil, nil),
    Tests:              nil,
    Jni_libs:           proptools.NewConfigurable[[]string](nil, nil),
    Binaries:           a.properties.Binaries,
   })
  }

  // Add native modules targeting either 32-bit or 64-bit ABI
  switch target.Arch.ArchType.Multilib {
  case "lib32":
   deps.Merge(ctx, a.properties.Multilib.Lib32)
   deps.Merge(ctx, a.properties.Multilib.Prefer32)
  case "lib64":
   deps.Merge(ctx, a.properties.Multilib.Lib64)
   if !has32BitTarget {
    deps.Merge(ctx, a.properties.Multilib.Prefer32)
   }
  }

  // Add native modules targeting a specific arch variant
  switch target.Arch.ArchType {
  case android.Arm:
   deps.Merge(ctx, a.archProperties.Arch.Arm.ApexNativeDependencies)
  case android.Arm64:
   deps.Merge(ctx, a.archProperties.Arch.Arm64.ApexNativeDependencies)
  case android.Riscv64:
   deps.Merge(ctx, a.archProperties.Arch.Riscv64.ApexNativeDependencies)
  case android.X86:
   deps.Merge(ctx, a.archProperties.Arch.X86.ApexNativeDependencies)
  case android.X86_64:
   deps.Merge(ctx, a.archProperties.Arch.X86_64.ApexNativeDependencies)
  default:
   panic(fmt.Errorf("unsupported arch %v\n", ctx.Arch().ArchType))
  }

  addDependenciesForNativeModules(ctx, deps, target, imageVariation)
  if isPrimaryAbi {
   ctx.AddFarVariationDependencies([]blueprint.Variation{
    {Mutator: "os", Variation: target.OsVariation()},
    {Mutator: "arch", Variation: target.ArchVariation()},
   }, shBinaryTag, a.properties.Sh_binaries.GetOrDefault(ctx, nil)...)
  }
 }

 // Common-arch dependencies come next
 commonVariation := ctx.Config().AndroidCommonTarget.Variations()
 ctx.AddFarVariationDependencies(commonVariation, rroTag, a.properties.Rros...)
 ctx.AddFarVariationDependencies(commonVariation, bcpfTag, a.properties.Bootclasspath_fragments.GetOrDefault(ctx, nil)...)
 ctx.AddFarVariationDependencies(commonVariation, fragmentInApexTag, a.properties.Bootclasspath_fragments.GetOrDefault(ctx, nil)...)
 ctx.AddFarVariationDependencies(commonVariation, sscpfTag, a.properties.Systemserverclasspath_fragments.GetOrDefault(ctx, nil)...)
 ctx.AddFarVariationDependencies(commonVariation, javaLibTag, a.properties.Java_libs...)
 ctx.AddFarVariationDependencies(commonVariation, fsTag, a.properties.Filesystems...)
 ctx.AddFarVariationDependencies(commonVariation, compatConfigTag, a.properties.Compat_configs.GetOrDefault(ctx, nil)...)

 // Add a reverse dependency to all_apex_certs singleton module.
 // all_apex_certs will use this dependency to collect the certificate of this apex.
 ctx.AddReverseDependency(ctx.Module(), allApexCertsDepTag, "all_apex_certs")

 // TODO: When all branches contain this singleton module, make this strict
 // TODO: Add this dependency only for mainline prebuilts and not every prebuilt module
 if ctx.OtherModuleExists("all_apex_contributions") {
  ctx.AddDependency(ctx.Module(), android.AcDepTag, "all_apex_contributions")
 }

 ctx.AddHostToolDependencies("zipsync", "apex_compression_tool", "gen_apex_symbols", "dexdeps")
}

type allApexCertsDependencyTag struct {
 blueprint.DependencyTag
}

func (_ allApexCertsDependencyTag) ExcludeFromVisibilityEnforcement() {}

var allApexCertsDepTag = allApexCertsDependencyTag{}

// DepsMutator for the overridden properties.
func (a *apexBundle) OverridablePropertiesDepsMutator(ctx android.BottomUpMutatorContext) {
 if a.overridableProperties.Allowed_files != nil {
  android.ExtractSourceDeps(ctx, a.overridableProperties.Allowed_files)
 }

 commonVariation := ctx.Config().AndroidCommonTarget.Variations()
 ctx.AddFarVariationDependencies(commonVariation, androidAppTag, a.overridableProperties.Apps.GetOrDefault(ctx, nil)...)
 ctx.AddFarVariationDependencies(commonVariation, bpfTag, a.overridableProperties.Bpfs.GetOrDefault(ctx, nil)...)
 if prebuilts := a.overridableProperties.Prebuilts.GetOrDefault(ctx, nil); len(prebuilts) > 0 {
  // For prebuilt_etc, use the first variant (64 on 64/32bit device, 32 on 32bit device)
  // regardless of the TARGET_PREFER_* setting. See b/144532908
  arches := ctx.DeviceConfig().Arches()
  if len(arches) != 0 {
   archForPrebuiltEtc := arches[0]
   for _, arch := range arches {
    // Prefer 64-bit arch if there is any
    if arch.ArchType.Multilib == "lib64" {
     archForPrebuiltEtc = arch
     break
    }
   }
   ctx.AddFarVariationDependencies([]blueprint.Variation{
    {Mutator: "os", Variation: ctx.Os().String()},
    {Mutator: "arch", Variation: archForPrebuiltEtc.String()},
   }, prebuiltTag, prebuilts...)
  }
 }

 // Dependencies for signing
 if String(a.overridableProperties.Key) == "" {
  ctx.PropertyErrorf("key", "missing")
  return
 }
 ctx.AddDependency(ctx.Module(), keyTag, String(a.overridableProperties.Key))

 cert := android.SrcIsModule(a.getCertString(ctx))
 if cert != "" {
  ctx.AddDependency(ctx.Module(), certificateTag, cert)
  // empty cert is not an error. Cert and private keys will be directly found under
  // PRODUCT_DEFAULT_DEV_CERTIFICATE
 }
}

var _ ApexTransitionMutator = (*apexBundle)(nil)

func (a *apexBundle) ApexVariationName() string {
 return a.properties.ApexVariationName
}

type generateApexInfoContext interface {
 android.MinSdkVersionFromValueContext
 Module() android.Module
 ModuleName() string
}

// generateApexInfo returns an android.ApexInfo configuration that should be used for dependencies of this apex.
func (a *apexBundle) generateApexInfo(ctx generateApexInfoContext) android.ApexInfo {
 // The VNDK APEX is special. For the APEX, the membership is described in a very different
 // way. There is no dependency from the VNDK APEX to the VNDK libraries. Instead, VNDK
 // libraries are self-identified by their vndk.enabled properties. There is no need to run
 // this mutator for the APEX as nothing will be collected so return an empty ApexInfo.
 if a.vndkApex {
  return android.ApexInfo{}
 }

 minSdkVersion := a.minSdkVersion(ctx)
 // When min_sdk_version is not set, the apex is built against FutureApiLevel.
 if minSdkVersion.IsNone() {
  minSdkVersion = android.FutureApiLevel
 }

 // This is the main part of this mutator. Mark the collected dependencies that they need to
 // be built for this apexBundle.

 apexVariationName := ctx.ModuleName() // could be com.android.foo
 if a.GetOverriddenBy() != "" {
  // use the overridden name com.mycompany.android.foo
  apexVariationName = a.GetOverriddenBy()
 }

 apexInfo := android.ApexInfo{
  ApexVariationName: apexVariationName,
  MinSdkVersion:     minSdkVersion,
  Updatable:         a.Updatable(),
  UsePlatformApis:   a.UsePlatformApis(),
  BaseApexName:      ctx.ModuleName(),
  ApexAvailableName: proptools.String(a.properties.Apex_available_name),
 }
 return apexInfo
}

func (a *apexBundle) ApexTransitionMutatorSplit(ctx android.BaseModuleContext) []android.ApexInfo {
 return []android.ApexInfo{a.generateApexInfo(ctx)}
}

func (a *apexBundle) ApexTransitionMutatorOutgoing(ctx android.OutgoingTransitionContext, sourceInfo android.ApexInfo) android.ApexInfo {
 return sourceInfo
}

func (a *apexBundle) ApexTransitionMutatorIncoming(ctx android.IncomingTransitionContext, outgoingInfo android.ApexInfo) android.ApexInfo {
 return a.generateApexInfo(ctx)
}

func (a *apexBundle) ApexTransitionMutatorMutate(ctx android.BottomUpMutatorContext, info android.ApexInfo) {
 android.SetProvider(ctx, android.ApexBundleInfoProvider, android.ApexBundleInfo{})
 a.properties.ApexVariationName = info.ApexVariationName
}

type ApexTransitionMutator interface {
 ApexTransitionMutatorSplit(ctx android.BaseModuleContext) []android.ApexInfo
 ApexTransitionMutatorOutgoing(ctx android.OutgoingTransitionContext, sourceInfo android.ApexInfo) android.ApexInfo
 ApexTransitionMutatorIncoming(ctx android.IncomingTransitionContext, outgoingInfo android.ApexInfo) android.ApexInfo
 ApexTransitionMutatorMutate(ctx android.BottomUpMutatorContext, info android.ApexInfo)
}

// TODO: b/215736885 Whittle the denylist
// Transitive deps of certain mainline modules baseline NewApi errors
// Skip these mainline modules for now
var (
 skipStrictUpdatabilityLintAllowlist = []string{
  // go/keep-sorted start
  "PackageManagerTestApex",
  "com.android.adservices",
  "com.android.appsearch",
  "com.android.art",
  "com.android.art.debug",
  "com.android.bt",
  "com.android.cellbroadcast",
  "com.android.configinfrastructure",
  "com.android.conscrypt",
  "com.android.extservices",
  "com.android.extservices_tplus",
  "com.android.healthfitness",
  "com.android.ipsec",
  "com.android.media",
  "com.android.mediaprovider",
  "com.android.nfcservices",
  "com.android.ondevicepersonalization",
  "com.android.os.statsd",
  "com.android.permission",
  "com.android.profiling",
  "com.android.rkpd",
  "com.android.scheduling",
  "com.android.telephonycore",
  "com.android.tethering",
  "com.android.uwb",
  "com.android.wifi",
  "test_com.android.art",
  "test_com.android.cellbroadcast",
  "test_com.android.conscrypt",
  "test_com.android.extservices",
  "test_com.android.ipsec",
  "test_com.android.media",
  "test_com.android.mediaprovider",
  "test_com.android.os.statsd",
  "test_com.android.permission",
  "test_com.android.wifi",
  "test_imgdiag_com.android.art",
  "test_jitzygote_com.android.art",
  // go/keep-sorted end
 }
)

func (a *apexBundle) checkStrictUpdatabilityLinting(mctx android.ModuleContext) bool {
 // The allowlist contains the base apex name, so use that instead of the ApexVariationName
 return a.Updatable() && !android.InList(mctx.ModuleName(), skipStrictUpdatabilityLintAllowlist)
}

// apexUniqueVariationsMutator checks if any dependencies use unique apex variations. If so, use
// unique apex variations for this module. See android/apex.go for more about unique apex variant.
// TODO(jiyong): move this to android/apex.go?
func apexUniqueVariationsMutator(mctx android.BottomUpMutatorContext) {
 if !mctx.Module().Enabled(mctx) {
  return
 }
 if am, ok := mctx.Module().(android.ApexModule); ok {
  android.UpdateUniqueApexVariationsForDeps(mctx, am)
  android.SetProvider(mctx, android.DepInSameApexInfoProvider, android.DepInSameApexInfo{
   Checker: am.GetDepInSameApexChecker(),
  })
 }
}

// markPlatformAvailability marks whether or not a module can be available to platform. A module
// cannot be available to platform if 1) it is explicitly marked as not available (i.e.
// "//apex_available:platform" is absent) or 2) it depends on another module that isn't (or can't
// be) available to platform
// TODO(jiyong): move this to android/apex.go?
func markPlatformAvailability(mctx android.BottomUpMutatorContext) {
 // Recovery is not considered as platform
 if mctx.Module().InstallInRecovery() {
  return
 }

 am, ok := mctx.Module().(android.ApexModule)
 if !ok {
  return
 }

 availableToPlatform := am.AvailableFor(android.AvailableToPlatform)

 // If any of the dep is not available to platform, this module is also considered as being
 // not available to platform even if it has "//apex_available:platform"
 mctx.VisitDirectDepsProxy(func(child android.ModuleProxy) {
  if !android.IsDepInSameApex(mctx, am, child) {
   // if the dependency crosses apex boundary, don't consider it
   return
  }
  info := android.OtherModuleProviderOrDefault(mctx, child, android.PlatformAvailabilityInfoProvider)
  if info.NotAvailableToPlatform {
   availableToPlatform = false
   // TODO(b/154889534) trigger an error when 'am' has
   // "//apex_available:platform"
  }
 })

 // Exception 1: check to see if the module always requires it.
 if am.AlwaysRequiresPlatformApexVariant() {
  availableToPlatform = true
 }

 // Exception 2: bootstrap bionic libraries are also always available to platform
 if cc.InstallToBootstrap(mctx.ModuleName(), mctx.Config()) {
  availableToPlatform = true
 }

 if !availableToPlatform {
  android.SetProvider(mctx, android.PlatformAvailabilityInfoProvider, android.PlatformAvailabilityInfo{
   NotAvailableToPlatform: true,
  })
 }

}

type apexTransitionMutator struct{}

func (a *apexTransitionMutator) Split(ctx android.BaseModuleContext) []android.ApexInfo {
 if ai, ok := ctx.Module().(ApexTransitionMutator); ok {
  return ai.ApexTransitionMutatorSplit(ctx)
 }
 return []android.ApexInfo{{}}
}

func (a *apexTransitionMutator) SplitOnDemand(ctx android.BaseModuleContext) []android.ApexInfo {
 return nil
}

func (a *apexTransitionMutator) OutgoingTransition(ctx android.OutgoingTransitionContext, sourceInfo android.ApexInfo) android.ApexInfo {
 if ai, ok := ctx.Module().(ApexTransitionMutator); ok {
  return ai.ApexTransitionMutatorOutgoing(ctx, sourceInfo)
 }
 return android.ApexInfo{}
}

func (a *apexTransitionMutator) IncomingTransition(ctx android.IncomingTransitionContext, outgoingInfo android.ApexInfo) android.ApexInfo {
 if ai, ok := ctx.Module().(ApexTransitionMutator); ok {
  return ai.ApexTransitionMutatorIncoming(ctx, outgoingInfo)
 }
 return android.ApexInfo{}
}

func (a *apexTransitionMutator) Mutate(ctx android.BottomUpMutatorContext, info android.ApexInfo) {
 if ai, ok := ctx.Module().(ApexTransitionMutator); ok {
  ai.ApexTransitionMutatorMutate(ctx, info)
 }
}

func (a *apexTransitionMutator) TransitionInfoFromVariation(variation string) android.ApexInfo {
 panic(fmt.Errorf("adding dependencies on explicit apex variations is not supported"))
}

const (
 // File extensions of an APEX for different packaging methods
 imageApexSuffix  = ".apex"
 imageCapexSuffix = ".capex"

 // variant names each of which is for a packaging method
 imageApexType = "image"

 ext4FsType  = "ext4"
 f2fsFsType  = "f2fs"
 erofsFsType = "erofs"
)

func (a *apexBundle) Exportable() bool {
 return true
}

func (a *apexBundle) TaggedOutputs() map[string]android.Paths {
 ret := make(map[string]android.Paths)
 ret["apex"] = android.Paths{a.outputFile}
 return ret
}

// Implements cc.UseCoverage
func (a *apexBundle) IsNativeCoverageNeeded(ctx cc.IsNativeCoverageNeededContext) bool {
 return ctx.DeviceConfig().NativeCoverageEnabled()
}

var _ cc.UseCoverage = &apexBundle{}

// Implements cc.Coverage
func (a *apexBundle) HideFromMake() {
 a.properties.HideFromMake = true
 // This HideFromMake is shadowing the ModuleBase one, call through to it for now.
 // TODO(ccross): untangle these
 a.ModuleBase.HideFromMake()
}

var _ android.ApexBundleDepsInfoIntf = (*apexBundle)(nil)

// Implements android.ApexBundleDepsInfoIntf
func (a *apexBundle) Updatable() bool {
 return proptools.BoolDefault(a.properties.Updatable, true)
}

func (a *apexBundle) FutureUpdatable() bool {
 return proptools.BoolDefault(a.properties.Future_updatable, false)
}

func (a *apexBundle) UsePlatformApis() bool {
 return proptools.BoolDefault(a.properties.Platform_apis, false)
}

type apexValidationType int

const (
 hostApexVerifier apexValidationType = iota
 apexSepolicyTests
)

func (a *apexBundle) skipValidation(validationType apexValidationType) bool {
 switch validationType {
 case hostApexVerifier:
  return proptools.Bool(a.testProperties.Skip_validations.Host_apex_verifier)
 case apexSepolicyTests:
  return proptools.Bool(a.testProperties.Skip_validations.Apex_sepolicy_tests)
 }
 panic("Unknown validation type")
}

// getCertString returns the name of the cert that should be used to sign this APEX. This is
// basically from the "certificate" property, but could be overridden by the device config.
func (a *apexBundle) getCertString(ctx android.BaseModuleContext) string {
 moduleName := ctx.ModuleName()
 // VNDK APEXes share the same certificate. To avoid adding a new VNDK version to the
 // OVERRIDE_* list, we check with the pseudo module name to see if its certificate is
 // overridden.
 if a.vndkApex {
  moduleName = vndkApexName
 }
 certificate, overridden := ctx.DeviceConfig().OverrideCertificateFor(moduleName)
 if overridden {
  return ":" + certificate
 }
 return String(a.overridableProperties.Certificate)
}

// See the installable property
func (a *apexBundle) installable() bool {
 return proptools.BoolDefault(a.properties.Installable, true)
}

// See the test_only_unsigned_payload property
func (a *apexBundle) testOnlyShouldSkipPayloadSign() bool {
 return proptools.Bool(a.properties.Test_only_unsigned_payload)
}

// See the test_only_force_compression property
func (a *apexBundle) testOnlyShouldForceCompression() bool {
 return proptools.Bool(a.properties.Test_only_force_compression)
}

// See the dynamic_common_lib_apex property
func (a *apexBundle) dynamic_common_lib_apex() bool {
 return proptools.BoolDefault(a.properties.Dynamic_common_lib_apex, false)
}

func (a *apexBundle) nonProduction() bool {
 return proptools.Bool(a.overridableProperties.Non_production)
}

// These functions are interfacing with cc/sanitizer.go. The entire APEX (along with all of its
// members) can be sanitized, either forcibly, or by the global configuration. For some of the
// sanitizers, extra dependencies can be forcibly added as well.

func (a *apexBundle) EnableSanitizer(sanitizerName string) {
 if !android.InList(sanitizerName, a.properties.SanitizerNames) {
  a.properties.SanitizerNames = append(a.properties.SanitizerNames, sanitizerName)
 }
}

func (a *apexBundle) IsSanitizerEnabled(config android.Config, sanitizerName string) bool {
 if android.InList(sanitizerName, a.properties.SanitizerNames) {
  return true
 }

 // Then follow the global setting
 var globalSanitizerNames []string
 arches := config.SanitizeDeviceArch()
 if len(arches) == 0 || android.InList(a.Arch().ArchType.Name, arches) {
  globalSanitizerNames = config.SanitizeDevice()
 }
 return android.InList(sanitizerName, globalSanitizerNames)
}

func (a *apexBundle) AddSanitizerDependencies(ctx android.BottomUpMutatorContext, sanitizerName string) {
 if ctx.Config().GetBuildFlagBool("RELEASE_DEPRECATE_RUNTIME_APEX") {
  return
 }
 // TODO(jiyong): move this info (the sanitizer name, the lib name, etc.) to cc/sanitize.go
 // Keep only the mechanism here.
 if sanitizerName == "hwaddress" && strings.HasPrefix(a.Name(), "com.android.runtime") {
  imageVariation := a.getImageVariation()
  for _, target := range ctx.MultiTargets() {
   if target.Arch.ArchType.Multilib == "lib64" {
    addDependenciesForNativeModules(ctx, ResolvedApexNativeDependencies{
     Native_shared_libs: []string{"libclang_rt.hwasan"},
     Tests:              nil,
     Jni_libs:           nil,
    }, target, imageVariation)
    break
   }
  }
 }
}

func setDirInApexForNativeBridge(commonInfo *android.CommonModuleInfo, dir *string) {
 if commonInfo.Target.NativeBridge == android.NativeBridgeEnabled {
  *dir = filepath.Join(*dir, commonInfo.Target.NativeBridgeRelativePath)
 }
}

// apexFileFor<Type> functions below create an apexFile struct for a given Soong module. The
// returned apexFile saves information about the Soong module that will be used for creating the
// build rules.
func apexFileForNativeLibrary(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo, ccMod *cc.LinkableInfo, handleSpecialLibs bool) apexFile {
 // Decide the APEX-local directory by the multilib of the library In the future, we may
 // query this to the module.
 // TODO(jiyong): use the new PackagingSpec
 var dirInApex string
 switch ccMod.Multilib {
 case "lib32":
  dirInApex = "lib"
 case "lib64":
  dirInApex = "lib64"
 }
 setDirInApexForNativeBridge(commonInfo, &dirInApex)
 if handleSpecialLibs && cc.InstallToBootstrap(commonInfo.BaseModuleName, ctx.Config()) {
  // Special case for Bionic libs and other libs installed with them. This is to
  // prevent those libs from being included in the search path
  // /apex/com.android.runtime/${LIB}. This exclusion is required because those libs
  // in the Runtime APEX are available via the legacy paths in /system/lib/. By the
  // init process, the libs in the APEX are bind-mounted to the legacy paths and thus
  // will be loaded into the default linker namespace (aka "platform" namespace). If
  // the libs are directly in /apex/com.android.runtime/${LIB} then the same libs will
  // be loaded again into the runtime linker namespace, which will result in double
  // loading of them, which isn't supported.
  dirInApex = filepath.Join(dirInApex, "bionic")
 }
 // This needs to go after the runtime APEX handling because otherwise we would get
 // weird paths like lib64/rel_install_path/bionic rather than
 // lib64/bionic/rel_install_path.
 dirInApex = filepath.Join(dirInApex, ccMod.RelativeInstallPath)

 fileToCopy := android.OutputFileForModule(ctx, module, "")
 androidMkModuleName := commonInfo.BaseModuleName + ccMod.SubName
 return newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeSharedLib, module)
}

func apexFileForExecutable(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo, ccInfo *cc.CcInfo) apexFile {
 linkableInfo := android.OtherModuleProviderOrDefault(ctx, module, cc.LinkableInfoProvider)
 dirInApex := "bin"
 setDirInApexForNativeBridge(commonInfo, &dirInApex)
 dirInApex = filepath.Join(dirInApex, linkableInfo.RelativeInstallPath)
 fileToCopy := android.OutputFileForModule(ctx, module, "")
 androidMkModuleName := commonInfo.BaseModuleName + linkableInfo.SubName
 af := newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeExecutable, module)
 af.symlinks = linkableInfo.Symlinks
 af.dataPaths = ccInfo.DataPaths
 return af
}

func apexFileForRustExecutable(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo) apexFile {
 linkableInfo := android.OtherModuleProviderOrDefault(ctx, module, cc.LinkableInfoProvider)
 dirInApex := "bin"
 setDirInApexForNativeBridge(commonInfo, &dirInApex)
 dirInApex = filepath.Join(dirInApex, linkableInfo.RelativeInstallPath)
 fileToCopy := android.OutputFileForModule(ctx, module, "")
 androidMkModuleName := commonInfo.BaseModuleName + linkableInfo.SubName
 af := newApexFile(ctx, fileToCopy, androidMkModuleName, dirInApex, nativeExecutable, module)
 return af
}

func apexFileForShBinary(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo, sh *sh.ShBinaryInfo) apexFile {
 dirInApex := filepath.Join("bin", sh.SubDir)
 setDirInApexForNativeBridge(commonInfo, &dirInApex)
 fileToCopy := sh.OutputFile
 af := newApexFile(ctx, fileToCopy, commonInfo.BaseModuleName, dirInApex, shBinary, module)
 af.symlinks = sh.Symlinks
 return af
}

func apexFileForPrebuiltEtc(ctx android.BaseModuleContext, module android.ModuleProxy,
 prebuilt *prebuilt_etc.PrebuiltEtcInfo, outputFile android.Path) apexFile {
 dirInApex := filepath.Join(prebuilt.BaseDir, prebuilt.SubDir)
 makeModuleName := strings.ReplaceAll(filepath.Join(dirInApex, outputFile.Base()), "/", "_")
 return newApexFile(ctx, outputFile, makeModuleName, dirInApex, etc, module)
}

func apexFileForCompatConfig(ctx android.BaseModuleContext, module android.ModuleProxy,
 config *java.PlatformCompatConfigInfo, depName string) apexFile {
 dirInApex := filepath.Join("etc", config.SubDir)
 fileToCopy := config.CompatConfig
 return newApexFile(ctx, fileToCopy, depName, dirInApex, etc, module)
}

func apexFileForVintfFragment(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo, vf *android.VintfFragmentInfo) apexFile {
 dirInApex := filepath.Join("etc", "vintf")

 return newApexFile(ctx, vf.OutputFile, commonInfo.BaseModuleName, dirInApex, etc, module)
}

// javaModule is an interface to handle all Java modules (java_library, dex_import, etc) in the same
// way.
type javaModule interface {
 android.Module
 BaseModuleName() string
 DexJarBuildPath(ctx android.ModuleErrorfContext) java.OptionalDexJarPath
 Stem() string
}

var _ javaModule = (*java.Library)(nil)
var _ javaModule = (*java.Import)(nil)
var _ javaModule = (*java.SdkLibrary)(nil)
var _ javaModule = (*java.DexImport)(nil)
var _ javaModule = (*java.SdkLibraryImport)(nil)

// apexFileForJavaModule creates an apexFile for a java module's dex implementation jar.
func apexFileForJavaModule(ctx android.ModuleContext, module android.ModuleProxy, javaInfo *java.JavaInfo) apexFile {
 return apexFileForJavaModuleWithFile(ctx, module, javaInfo, javaInfo.DexJarBuildPath.PathOrNil())
}

// apexFileForJavaModuleWithFile creates an apexFile for a java module with the supplied file.
func apexFileForJavaModuleWithFile(ctx android.ModuleContext, module android.ModuleProxy,
 javaInfo *java.JavaInfo, dexImplementationJar android.Path) apexFile {
 dirInApex := "javalib"
 commonInfo := android.OtherModulePointerProviderOrDefault(ctx, module, android.CommonModuleInfoProvider)
 af := newApexFile(ctx, dexImplementationJar, commonInfo.BaseModuleName, dirInApex, javaSharedLib, module)
 af.jacocoInfo = javaInfo.JacocoInfo
 if lintInfo, ok := android.OtherModuleProvider(ctx, module, java.LintProvider); ok {
  af.lintInfo = lintInfo
 }
 af.customStem = javaInfo.Stem + ".jar"
 // Collect any system server dex jars and dexpreopt artifacts for installation alongside the apex.
 // TODO: b/338641779 - Remove special casing of sdkLibrary once bcpf and sscpf depends
 // on the implementation library
 if javaInfo.DexpreopterInfo != nil {
  af.systemServerDexpreoptInstalls = append(af.systemServerDexpreoptInstalls, javaInfo.DexpreopterInfo.ApexSystemServerDexpreoptInstalls...)
  af.systemServerDexJars = append(af.systemServerDexJars, javaInfo.DexpreopterInfo.ApexSystemServerDexJars...)
 }
 return af
}

func apexFileForJavaModuleProfile(ctx android.BaseModuleContext, commonInfo *android.CommonModuleInfo,
 javaInfo *java.JavaInfo) *apexFile {
 if profilePathOnHost := javaInfo.DexpreopterInfo.OutputProfilePathOnHost; profilePathOnHost != nil {
  dirInApex := "javalib"
  af := newApexFile(ctx, profilePathOnHost, commonInfo.BaseModuleName+"-profile", dirInApex, etc, android.ModuleProxy{})
  af.customStem = javaInfo.Stem + ".jar.prof"
  return &af
 }
 return nil
}

func sanitizedBuildIdForPath(ctx android.BaseModuleContext) string {
 buildId := ctx.Config().BuildId()

 // The build ID is used as a suffix for a filename, so ensure that
 // the set of characters being used are sanitized.
 // - any word character: [a-zA-Z0-9_]
 // - dots: .
 // - dashes: -
 validRegex := regexp.MustCompile(`^[\w\.\-\_]+$`)
 if !validRegex.MatchString(buildId) {
  ctx.ModuleErrorf("Unable to use build id %s as filename suffix, valid characters are [a-z A-Z 0-9 _ . -].", buildId)
 }
 return buildId
}

func apexFilesForAndroidApp(ctx android.BaseModuleContext, module android.ModuleProxy,
 commonInfo *android.CommonModuleInfo, aapp *java.AppInfo) []apexFile {
 appDir := "app"
 if aapp.Privileged {
  appDir = "priv-app"
 }

 // TODO(b/224589412, b/226559955): Ensure that the subdirname is suffixed
 // so that PackageManager correctly invalidates the existing installed apk
 // in favour of the new APK-in-APEX.  See bugs for more information.
 dirInApex := filepath.Join(appDir, aapp.InstallApkName+"@"+sanitizedBuildIdForPath(ctx))
 fileToCopy := aapp.OutputFile

 af := newApexFile(ctx, fileToCopy, commonInfo.BaseModuleName, dirInApex, app, module)
 af.jacocoInfo = aapp.JacocoInfo
 if lintInfo, ok := android.OtherModuleProvider(ctx, module, java.LintProvider); ok {
  af.lintInfo = lintInfo
 }
 af.certificate = aapp.Certificate

 if aapp.OverriddenManifestPackageName != nil {
  af.overriddenPackageName = *aapp.OverriddenManifestPackageName
 }

 apexFiles := []apexFile{}

 if allowlist := aapp.PrivAppAllowlist; allowlist.Valid() {
  dirInApex := filepath.Join("etc", "permissions")
  privAppAllowlist := newApexFile(ctx, allowlist.Path(), commonInfo.BaseModuleName+"_privapp", dirInApex, etc, module)
  apexFiles = append(apexFiles, privAppAllowlist)
 }

 if preinstall := aapp.PreinstallAllowlist; preinstall.Valid() {
  dirInApex := filepath.Join("etc", "sysconfig")
  preinstallAllowlist := newApexFile(ctx, preinstall.Path(), commonInfo.BaseModuleName+"_preinstall", dirInApex, etc, module)
  apexFiles = append(apexFiles, preinstallAllowlist)
 }

 apexFiles = append(apexFiles, af)

 return apexFiles
}

func apexFileForRuntimeResourceOverlay(ctx android.BaseModuleContext, module android.ModuleProxy, rro java.RuntimeResourceOverlayInfo) apexFile {
 rroDir := "overlay"
 dirInApex := filepath.Join(rroDir, rro.Theme)
 fileToCopy := rro.OutputFile
 af := newApexFile(ctx, fileToCopy, module.Name(), dirInApex, app, module)
 af.certificate = rro.Certificate

 return af
}

func apexFileForBpfProgram(ctx android.BaseModuleContext, builtFile android.Path, apex_sub_dir string, bpfProgram android.ModuleProxy) apexFile {
 dirInApex := filepath.Join("etc", "bpf", apex_sub_dir)
 return newApexFile(ctx, builtFile, builtFile.Base(), dirInApex, etc, bpfProgram)
}

func apexFileForFilesystem(ctx android.BaseModuleContext, buildFile android.Path, module android.ModuleProxy) apexFile {
 dirInApex := filepath.Join("etc", "fs")
 return newApexFile(ctx, buildFile, buildFile.Base(), dirInApex, etc, module)
}

// WalkPayloadDeps visits dependencies that contributes to the payload of this APEX. For each of the
// visited module, the `do` callback is executed. Returning true in the callback continues the visit
// to the child modules. Returning false makes the visit to continue in the sibling or the parent
// modules. This is used in check* functions below.
func (a *apexBundle) WalkPayloadDeps(ctx android.BaseModuleContext, do android.PayloadDepsCallback) {
 ctx.WalkDepsProxy(func(child, parent android.ModuleProxy) bool {
  if !android.OtherModulePointerProviderOrDefault(ctx, child, android.CommonModuleInfoProvider).CanHaveApexVariants {
   return false
  }
  // Filter-out unwanted depedendencies
  depTag := ctx.OtherModuleDependencyTag(child)
  if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok {
   return false
  }
  if dt, ok := depTag.(*dependencyTag); ok && !dt.payload {
   return false
  }
  if depTag == android.RequiredDepTag {
   return false
  }

  externalDep := !android.IsDepInSameApex(ctx, parent, child)

  // Visit actually
  return do(ctx, parent, child, externalDep)
 })
}

// filesystem type of the apex_payload.img inside the APEX. Currently, ext4 and f2fs are supported.
type fsType int

const (
 ext4 fsType = iota
 f2fs
 erofs
)

func (f fsType) string() string {
 switch f {
 case ext4:
  return ext4FsType
 case f2fs:
  return f2fsFsType
 case erofs:
  return erofsFsType
 default:
  panic(fmt.Errorf("unknown APEX payload type %d", f))
 }
}

func (a *apexBundle) setCompression(ctx android.ModuleContext) {
 if a.isCompressable() {
  if !a.Updatable() {
   ctx.PropertyErrorf("compressible", "do not compress non-updatable APEX")
  }
  if a.PartitionTag(ctx.DeviceConfig()) != "system" {
   ctx.PropertyErrorf("compressible", "do not compress non-system APEX")
  }
 }

 if a.testOnlyShouldForceCompression() {
  a.isCompressed = true
 } else {
  a.isCompressed = ctx.Config().ApexCompressionEnabled() && a.isCompressable()
 }
}

func (a *apexBundle) setSystemLibLink(ctx android.ModuleContext) {
 // Optimization. If we are building bundled APEX, for the files that are gathered due to the
 // transitive dependencies, don't place them inside the APEX, but place a symlink pointing
 // the same library in the system partition, thus effectively sharing the same libraries
 // across the APEX boundary. For unbundled APEX, all the gathered files are actually placed
 // in the APEX.
 a.linkToSystemLib = !ctx.Config().UnbundledBuild() && a.installable()

 // APEXes targeting other than system/system_ext partitions use vendor/product variants.
 // So we can't link them to /system/lib libs which are core variants.
 if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
  a.linkToSystemLib = false
 }

 forced := ctx.Config().ForceApexSymlinkOptimization()
 updatable := a.Updatable() || a.FutureUpdatable()

 // We don't need the optimization for updatable APEXes, as it might give false signal
 // to the system health when the APEXes are still bundled (b/149805758).
 if !forced && updatable {
  a.linkToSystemLib = false
 }
}

func (a *apexBundle) setPayloadFsType(ctx android.ModuleContext) {
 defaultFsType := ctx.Config().DefaultApexPayloadType()
 switch proptools.StringDefault(a.properties.Payload_fs_type, defaultFsType) {
 case ext4FsType:
  a.payloadFsType = ext4
 case f2fsFsType:
  a.payloadFsType = f2fs
 case erofsFsType:
  a.payloadFsType = erofs
 default:
  ctx.PropertyErrorf("payload_fs_type", "%q is not a valid filesystem for apex [ext4, f2fs, erofs]", *a.properties.Payload_fs_type)
 }
}

func (a *apexBundle) isCompressable() bool {
 return proptools.BoolDefault(a.overridableProperties.Compressible, false) && !a.testApex
}

func (a *apexBundle) commonBuildActions(ctx android.ModuleContext) bool {
 a.checkApexAvailability(ctx)
 a.checkUpdatable(ctx)
 a.CheckMinSdkVersion(ctx)
 a.checkStaticLinkingToStubLibraries(ctx)
 a.checkStaticExecutables(ctx)
 a.enforceAppUpdatability(ctx)
 if len(a.properties.Tests) > 0 && !a.testApex {
  ctx.PropertyErrorf("tests", "property allowed only in apex_test module type")
  return false
 }
 return true
}

type visitorContext struct {
 // all the files that will be included in this APEX
 filesInfo []apexFile

 // native lib dependencies
 provideNativeLibs []string
 requireNativeLibs []string

 handleSpecialLibs bool

 // if true, raise error on duplicate apexFile
 checkDuplicate bool

 // visitor skips these from this list of module names
 unwantedTransitiveDeps []string

 // unwantedTransitiveFilesInfo contains files that would have been in the apex
 // except that they were listed in unwantedTransitiveDeps.
 unwantedTransitiveFilesInfo []apexFile

 // duplicateTransitiveFilesInfo contains files that would ahve been in the apex
 // except that another variant of the same module was already in the apex.
 duplicateTransitiveFilesInfo []apexFile
}

func (vctx *visitorContext) normalizeFileInfo(mctx android.ModuleContext) {
 encountered := make(map[string]apexFile)
 for _, f := range vctx.filesInfo {
  // Skips unwanted transitive deps. This happens, for example, with Rust binaries with prefer_rlib:true.
  // TODO(b/295593640)
  // Needs additional verification for the resulting APEX to ensure that skipped artifacts don't make problems.
  // For example, DT_NEEDED modules should be found within the APEX unless they are marked in `requiredNativeLibs`.
  if f.transitiveDep && !f.module.IsNil() && android.InList(mctx.OtherModuleName(f.module), vctx.unwantedTransitiveDeps) {
   vctx.unwantedTransitiveFilesInfo = append(vctx.unwantedTransitiveFilesInfo, f)
   continue
  }
  if f.builtFile == nil {
   mctx.ModuleErrorf("Dependency %q had nil builtFile. Make sure the module has an output file. (the installable and compile_dex properties can affect this)", f.androidMkModuleName)
   continue
  }
  dest := filepath.Join(f.installDir, f.builtFile.Base())
  if e, ok := encountered[dest]; !ok {
   encountered[dest] = f
  } else {
   if vctx.checkDuplicate && f.builtFile.String() != e.builtFile.String() {
    mctx.ModuleErrorf("apex file %v is provided by two different files %v and %v",
     dest, e.builtFile, f.builtFile)
    return
   } else {
    vctx.duplicateTransitiveFilesInfo = append(vctx.duplicateTransitiveFilesInfo, f)
   }
   // If a module is directly included and also transitively depended on
   // consider it as directly included.
   e.transitiveDep = e.transitiveDep && f.transitiveDep
   // If a module is added as both a JNI library and a regular shared library, consider it as a
   // JNI library.
   e.isJniLib = e.isJniLib || f.isJniLib
   encountered[dest] = e
  }
 }
 vctx.filesInfo = vctx.filesInfo[:0]
 for _, v := range encountered {
  vctx.filesInfo = append(vctx.filesInfo, v)
 }

 sort.Slice(vctx.filesInfo, func(i, j int) bool {
  // Sort by destination path so as to ensure consistent ordering even if the source of the files
  // changes.
  return vctx.filesInfo[i].path() < vctx.filesInfo[j].path()
 })
}

// enforcePartitionTagOnApexSystemServerJar checks that the partition tags of an apex system server jar  matches
// the partition tags of the top-level apex.
// e.g. if the top-level apex sets system_ext_specific to true, the javalib must set this property to true as well.
// This check ensures that the dexpreopt artifacts of the apex system server jar is installed in the same partition
// as the apex.
func (a *apexBundle) enforcePartitionTagOnApexSystemServerJar(ctx android.ModuleContext) {
 global := dexpreopt.GetGlobalConfig(ctx)
 ctx.VisitDirectDepsProxyWithTag(sscpfTag, func(child android.ModuleProxy) {
  info, ok := android.OtherModuleProvider(ctx, child, java.LibraryNameToPartitionInfoProvider)
  if !ok {
   ctx.ModuleErrorf("Could not find partition info of apex system server jars.")
  }
  apexPartition := ctx.Module().PartitionTag(ctx.DeviceConfig())
  for javalib, javalibPartition := range info.LibraryNameToPartition {
   if !global.AllApexSystemServerJars(ctx).ContainsJar(javalib) {
    continue // not an apex system server jar
   }
   if apexPartition != javalibPartition {
    ctx.ModuleErrorf(`
%s is an apex systemserver jar, but its partition does not match the partition of its containing apex. Expected %s, Got %s`,
     javalib, apexPartition, javalibPartition)
   }
  }
 })
}

func (a *apexBundle) depVisitor(vctx *visitorContext, ctx android.ModuleContext, child, parent android.ModuleProxy) bool {
 depTag := ctx.OtherModuleDependencyTag(child)
 if _, ok := depTag.(android.ExcludeFromApexContentsTag); ok {
  return false
 }
 commonInfo := android.OtherModulePointerProviderOrDefault(ctx, child, android.CommonModuleInfoProvider)
 if !commonInfo.Enabled {
  return false
 }
 depName := ctx.OtherModuleName(child)
 if android.EqualModules(parent, ctx.Module()) {
  switch depTag {
  case sharedLibTag, jniLibTag:
   isJniLib := depTag == jniLibTag
   propertyName := "native_shared_libs"
   if isJniLib {
    propertyName = "jni_libs"
   }

   if ch, ok := android.OtherModuleProvider(ctx, child, cc.LinkableInfoProvider); ok {
    if ch.IsStubs {
     ctx.PropertyErrorf(propertyName, "%q is a stub. Remove it from the list.", depName)
    }
    fi := apexFileForNativeLibrary(ctx, child, commonInfo, ch, vctx.handleSpecialLibs)
    fi.isJniLib = isJniLib
    vctx.filesInfo = append(vctx.filesInfo, fi)
    // Collect the list of stub-providing libs except:
    // - VNDK libs are only for vendors
    // - bootstrap bionic libs are treated as provided by system
    if ch.HasStubsVariants && !a.vndkApex && !cc.InstallToBootstrap(commonInfo.BaseModuleName, ctx.Config()) {
     vctx.provideNativeLibs = append(vctx.provideNativeLibs, fi.stem())
    }
    return true // track transitive dependencies
   } else {
    ctx.PropertyErrorf(propertyName,
     "%q is not a VersionLinkableInterface (e.g. cc_library or rust_ffi module)", depName)
   }

  case executableTag:
   if ccInfo, ok := android.OtherModuleProvider(ctx, child, cc.CcInfoProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForExecutable(ctx, child, commonInfo, ccInfo))
    return true // track transitive dependencies
   }
   if _, ok := android.OtherModuleProvider(ctx, child, rust.RustInfoProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForRustExecutable(ctx, child, commonInfo))
    return true // track transitive dependencies
   } else {
    ctx.PropertyErrorf("binaries",
     "%q is neither cc_binary, rust_binary, (embedded) py_binary, (host) blueprint_go_binary, nor (host) bootstrap_go_binary", depName)
   }
  case shBinaryTag:
   if csh, ok := android.OtherModuleProvider(ctx, child, sh.ShBinaryInfoProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForShBinary(ctx, child, commonInfo, &csh))
   } else {
    ctx.PropertyErrorf("sh_binaries", "%q is not a sh_binary module", depName)
   }
  case bcpfTag:
   _, ok := android.OtherModuleProvider(ctx, child, java.BootclasspathFragmentInfoProvider)
   if !ok {
    ctx.PropertyErrorf("bootclasspath_fragments", "%q is not a bootclasspath_fragment module", depName)
    return false
   }
   vctx.filesInfo = append(vctx.filesInfo, apexBootclasspathFragmentFiles(ctx, child)...)
   return true
  case sscpfTag:
   if _, ok := android.OtherModuleProvider(ctx, child, java.LibraryNameToPartitionInfoProvider); !ok {
    ctx.PropertyErrorf("systemserverclasspath_fragments",
     "%q is not a systemserverclasspath_fragment module", depName)
    return false
   }
   if af := apexClasspathFragmentProtoFile(ctx, child); af != nil {
    vctx.filesInfo = append(vctx.filesInfo, *af)
   }
   return true
  case javaLibTag:
   if ctx.OtherModuleHasProvider(child, java.JavaLibraryInfoProvider) ||
    ctx.OtherModuleHasProvider(child, java.JavaDexImportInfoProvider) ||
    ctx.OtherModuleHasProvider(child, java.SdkLibraryInfoProvider) {
    javaInfo := android.OtherModuleProviderOrDefault(ctx, child, java.JavaInfoProvider)
    af := apexFileForJavaModule(ctx, child, javaInfo)
    if !af.ok() {
     ctx.PropertyErrorf("java_libs", "%q is not configured to be compiled into dex", depName)
     return false
    }
    vctx.filesInfo = append(vctx.filesInfo, af)
    return true // track transitive dependencies
   } else {
    ctx.PropertyErrorf("java_libs", "%q of type %q is not supported", depName, ctx.OtherModuleType(child))
   }
  case androidAppTag:
   if appInfo, ok := android.OtherModuleProvider(ctx, child, java.AppInfoProvider); ok {
    if appInfo.AppSet {
     appDir := "app"
     if appInfo.Privileged {
      appDir = "priv-app"
     }
     // TODO(b/224589412, b/226559955): Ensure that the dirname is
     // suffixed so that PackageManager correctly invalidates the
     // existing installed apk in favour of the new APK-in-APEX.
     // See bugs for more information.
     appDirName := filepath.Join(appDir, commonInfo.BaseModuleName+"@"+sanitizedBuildIdForPath(ctx))
     af := newApexFile(ctx, appInfo.OutputFile, commonInfo.BaseModuleName, appDirName, appSet, child)
     af.certificate = java.PresignedCertificate
     af.extraZip = android.OptionalPathForPath(appInfo.PackedAdditionalOutputs)
     vctx.filesInfo = append(vctx.filesInfo, af)
    } else {
     vctx.filesInfo = append(vctx.filesInfo, apexFilesForAndroidApp(ctx, child, commonInfo, appInfo)...)
    }

    // androidMkForFiles is only called if a.installable(), so historically make would
    // only see certs from apks inside installable apexes
    if a.installable() {
     if apkCertInfo, ok := android.OtherModuleProvider(ctx, child, java.ApkCertInfoProvider); ok {
      a.apkCerts = append(a.apkCerts, apkCertInfo)
     }
    }

    if !appInfo.AppSet && !appInfo.Prebuilt && !appInfo.TestHelperApp {
     return true // track transitive dependencies
    }
   } else {
    ctx.PropertyErrorf("apps", "%q is not an android_app module", depName)
   }
  case rroTag:
   if rro, ok := android.OtherModuleProvider(ctx, child, java.RuntimeResourceOverlayInfoProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForRuntimeResourceOverlay(ctx, child, rro))
   } else {
    ctx.PropertyErrorf("rros", "%q is not an runtime_resource_overlay module", depName)
   }
  case bpfTag:
   if bpfProgram, ok := android.OtherModuleProvider(ctx, child, bpf.BpfInfoProvider); ok {
    filesToCopy := android.OutputFilesForModule(ctx, child, "")
    apex_sub_dir := bpfProgram.SubDir
    for _, bpfFile := range filesToCopy {
     vctx.filesInfo = append(vctx.filesInfo, apexFileForBpfProgram(ctx, bpfFile, apex_sub_dir, child))
    }
   } else {
    ctx.PropertyErrorf("bpfs", "%q is not a bpf module", depName)
   }
  case fsTag:
   if fs, ok := android.OtherModuleProvider(ctx, child, filesystem.FilesystemProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForFilesystem(ctx, fs.Output, child))
   } else {
    ctx.PropertyErrorf("filesystems", "%q is not a filesystem module", depName)
   }
  case prebuiltTag:
   if prebuilt, ok := android.OtherModuleProvider(ctx, child, prebuilt_etc.PrebuiltEtcInfoProvider); ok {
    filesToCopy := android.OutputFilesForModule(ctx, child, "")
    for _, etcFile := range filesToCopy {
     vctx.filesInfo = append(vctx.filesInfo, apexFileForPrebuiltEtc(ctx, child, &prebuilt, etcFile))
    }
   } else {
    ctx.PropertyErrorf("prebuilts", "%q is not a prebuilt_etc module", depName)
   }
  case kernelModulesTag:
   if _, ok := android.OtherModuleProvider(ctx, child, android.PrebuiltKernelModulesComplianceMetadataProvider); ok {
    for _, ps := range android.GetInstallFilesCommon(commonInfo).PackagingSpecs {
     src := ps.SrcPath()
     dir := path.Dir(ps.RelPathInPackage())
     makeModuleName := strings.ReplaceAll(filepath.Join(dir, src.Base()), "/", "_")
     af := newApexFile(ctx, src, makeModuleName, dir, etc, child)
     af.extraZip = ps.ExtraZip()
     vctx.filesInfo = append(vctx.filesInfo, af)
    }
   } else {
    ctx.PropertyErrorf("kernel_modules", "%q is not a prebuilt_kernel_modules module", depName)
   }
  case compatConfigTag:
   if compatConfig, ok := android.OtherModuleProvider(ctx, child, java.PlatformCompatConfigInfoProvider); ok {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForCompatConfig(ctx, child, &compatConfig, depName))
   } else {
    ctx.PropertyErrorf("compat_configs", "%q is not a platform_compat_config module", depName)
   }
  case testTag:
   if ccInfo, ok := android.OtherModuleProvider(ctx, child, cc.CcInfoProvider); ok {
    af := apexFileForExecutable(ctx, child, commonInfo, ccInfo)
    // We make this a nativeExecutable instead of a nativeTest because we don't want
    // the androidmk modules generated in AndroidMkForFiles to be treated as real
    // tests that are then packaged into suites. Our AndroidMkForFiles does not
    // implement enough functionality to support real tests.
    af.class = nativeExecutable
    vctx.filesInfo = append(vctx.filesInfo, af)
    return true // track transitive dependencies
   } else {
    ctx.PropertyErrorf("tests", "%q is not a cc module", depName)
   }
  case keyTag:
   if key, ok := android.OtherModuleProvider(ctx, child, ApexKeyInfoProvider); ok {
    a.privateKeyFile = key.PrivateKeyFile
    a.publicKeyFile = key.PublicKeyFile
   } else {
    ctx.PropertyErrorf("key", "%q is not an apex_key module", depName)
   }
  case certificateTag:
   if dep, ok := android.OtherModuleProvider(ctx, child, java.AndroidAppCertificateInfoProvider); ok {
    a.containerCertificateFile = dep.Certificate.Pem
    a.containerPrivateKeyFile = dep.Certificate.Key
   } else {
    ctx.ModuleErrorf("certificate dependency %q must be an android_app_certificate module", depName)
   }
  }
  return false
 }

 if a.vndkApex {
  return false
 }

 // indirect dependencies
 if !commonInfo.IsApexModule {
  return false
 }
 // We cannot use a switch statement on `depTag` here as the checked
 // tags used below are private (e.g. `cc.sharedDepTag`).
 if cc.IsSharedDepTag(depTag) || cc.IsRuntimeDepTag(depTag) {
  if ch, ok := android.OtherModuleProvider(ctx, child, cc.LinkableInfoProvider); ok {
   af := apexFileForNativeLibrary(ctx, child, commonInfo, ch, vctx.handleSpecialLibs)
   af.transitiveDep = true

   if ch.IsStubs || ch.HasStubsVariants {
    // If the dependency is a stubs lib, don't include it in this APEX,
    // but make sure that the lib is installed on the device.
    // In case no APEX is having the lib, the lib is installed to the system
    // partition.
    //
    // Always include if we are a host-apex however since those won't have any
    // system libraries.
    //
    // Skip the dependency in unbundled builds where the device image is not
    // being built.
    if ch.IsStubsImplementationRequired &&
     !commonInfo.NotInPlatform && !ctx.Config().UnbundledBuild() {
     // we need a module name for Make
     name := ch.ImplementationModuleNameForMake + ch.SubName
     if !android.InList(name, a.makeModulesToInstall) {
      a.makeModulesToInstall = append(a.makeModulesToInstall, name)
     }
    }
    vctx.requireNativeLibs = append(vctx.requireNativeLibs, af.stem())
    // Don't track further
    return false
   }

   // If the dep is not considered to be in the same
   // apex, don't add it to filesInfo so that it is not
   // included in this APEX.
   // TODO(jiyong): move this to at the top of the
   // else-if clause for the indirect dependencies.
   // Currently, that's impossible because we would
   // like to record requiredNativeLibs even when
   // DepIsInSameAPex is false. We also shouldn't do
   // this for host.
   if !android.IsDepInSameApex(ctx, parent, child) {
    return false
   }

   vctx.filesInfo = append(vctx.filesInfo, af)
   return true // track transitive dependencies
  }
 } else if cc.IsHeaderDepTag(depTag) {
  // nothing
 } else if java.IsJniDepTag(depTag) {
  // Because APK-in-APEX embeds jni_libs transitively, we don't need to track transitive deps
 } else if java.IsXmlPermissionsFileDepTag(depTag) {
  if prebuilt, ok := android.OtherModuleProvider(ctx, child, prebuilt_etc.PrebuiltEtcInfoProvider); ok {
   filesToCopy := android.OutputFilesForModule(ctx, child, "")
   for _, etcFile := range filesToCopy {
    vctx.filesInfo = append(vctx.filesInfo, apexFileForPrebuiltEtc(ctx, child, &prebuilt, etcFile))
   }
  }
 } else if rust.IsDylibDepTag(depTag) {
  if _, ok := android.OtherModuleProvider(ctx, child, rust.RustInfoProvider); ok &&
   commonInfo.IsInstallableToApex {
   if !android.IsDepInSameApex(ctx, parent, child) {
    return false
   }

   linkableInfo := android.OtherModuleProviderOrDefault(ctx, child, cc.LinkableInfoProvider)
   af := apexFileForNativeLibrary(ctx, child, commonInfo, linkableInfo, vctx.handleSpecialLibs)
   af.transitiveDep = true
   vctx.filesInfo = append(vctx.filesInfo, af)
   return true // track transitive dependencies
  }
 } else if rust.IsRlibDepTag(depTag) {
  // Rlib is statically linked, but it might have shared lib
  // dependencies. Track them.
  return true
 } else if java.IsBootclasspathFragmentContentDepTag(depTag) {
  // Add the contents of the bootclasspath fragment to the apex.
  if ctx.OtherModuleHasProvider(child, java.JavaLibraryInfoProvider) ||
   ctx.OtherModuleHasProvider(child, java.SdkLibraryInfoProvider) {
   af := apexFileForBootclasspathFragmentContentModule(ctx, parent, child)
   if !af.ok() {
    ctx.PropertyErrorf("bootclasspath_fragments",
     "bootclasspath_fragment content %q is not configured to be compiled into dex", depName)
    return false
   }
   vctx.filesInfo = append(vctx.filesInfo, af)
   return true // track transitive dependencies
  } else {
   ctx.PropertyErrorf("bootclasspath_fragments",
    "bootclasspath_fragment content %q of type %q is not supported", depName, ctx.OtherModuleType(child))
  }
 } else if java.IsSystemServerClasspathFragmentContentDepTag(depTag) {
  // Add the contents of the systemserverclasspath fragment to the apex.
  if ctx.OtherModuleHasProvider(child, java.JavaLibraryInfoProvider) ||
   ctx.OtherModuleHasProvider(child, java.SdkLibraryInfoProvider) {
   javaInfo := android.OtherModuleProviderOrDefault(ctx, child, java.JavaInfoProvider)
   af := apexFileForJavaModule(ctx, child, javaInfo)
   vctx.filesInfo = append(vctx.filesInfo, af)
   if profileAf := apexFileForJavaModuleProfile(ctx, commonInfo, javaInfo); profileAf != nil {
    vctx.filesInfo = append(vctx.filesInfo, *profileAf)
   }
   return true // track transitive dependencies
  } else {
   ctx.PropertyErrorf("systemserverclasspath_fragments",
    "systemserverclasspath_fragment content %q of type %q is not supported", depName, ctx.OtherModuleType(child))
  }
 } else if depTag == android.DarwinUniversalVariantTag {
  // nothing
 } else if depTag == android.RequiredDepTag {
  // nothing
 } else if depTag == cc.LFIDepTag {
  // nothing
 } else if commonInfo.IsInstallableToApex {
  ctx.ModuleErrorf("unexpected tag %s for indirect dependency %q", android.PrettyPrintTag(depTag), depName)
 } else if android.IsVintfDepTag(depTag) {
  if vf, ok := android.OtherModuleProvider(ctx, child, android.VintfFragmentInfoProvider); ok {
   apexFile := apexFileForVintfFragment(ctx, child, commonInfo, &vf)
   vctx.filesInfo = append(vctx.filesInfo, apexFile)
  }
 }

 return false
}

func (a *apexBundle) shouldCheckDuplicate(ctx android.ModuleContext) bool {
 return ctx.DeviceConfig().DeviceArch() != ""
}

// Creates build rules for an APEX. It consists of the following major steps:
//
// 1) do some validity checks such as apex_available, min_sdk_version, etc.
// 2) traverse the dependency tree to collect apexFile structs from them.
// 3) some fields in apexBundle struct are configured
// 4) generate the build rules to create the APEX. This is mostly done in builder.go.
func (a *apexBundle) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 ////////////////////////////////////////////////////////////////////////////////////////////
 // 1) do some validity checks such as apex_available, min_sdk_version, etc.
 if !a.commonBuildActions(ctx) {
  return
 }
 ////////////////////////////////////////////////////////////////////////////////////////////
 // 2) traverse the dependency tree to collect apexFile structs from them.

 // TODO(jiyong): do this using WalkPayloadDeps
 // TODO(jiyong): make this clean!!!
 vctx := visitorContext{
  handleSpecialLibs:      !android.Bool(a.properties.Ignore_system_library_special_case),
  checkDuplicate:         a.shouldCheckDuplicate(ctx),
  unwantedTransitiveDeps: a.properties.Unwanted_transitive_deps,
 }
 ctx.WalkDepsProxy(func(child, parent android.ModuleProxy) bool { return a.depVisitor(&vctx,&nbsp;ctx, child, parent) })
 vctx.normalizeFileInfo(ctx)
 if a.privateKeyFile == nil {
  if ctx.Config().AllowMissingDependencies() {
   // TODO(b/266099037): a better approach for slim manifests.
   ctx.AddMissingDependencies([]string{String(a.overridableProperties.Key)})
   // Create placeholder paths for later stages that expect to see those paths,
   // though they won't be used.
   var unusedPath = android.PathForModuleOut(ctx, "nonexistentprivatekey")
   android.ErrorRule(ctx, unusedPath, "Private key not available")
   a.privateKeyFile = unusedPath
  } else {
   ctx.PropertyErrorf("key", "private_key for %q could not be found", String(a.overridableProperties.Key))
   return
  }
 }

 if a.publicKeyFile == nil {
  if ctx.Config().AllowMissingDependencies() {
   // TODO(b/266099037): a better approach for slim manifests.
   ctx.AddMissingDependencies([]string{String(a.overridableProperties.Key)})
   // Create placeholder paths for later stages that expect to see those paths,
   // though they won't be used.
   var unusedPath = android.PathForModuleOut(ctx, "nonexistentpublickey")
   android.ErrorRule(ctx, unusedPath, "Public key not available")
   a.publicKeyFile = unusedPath
  } else {
   ctx.PropertyErrorf("key", "public_key for %q could not be found", String(a.overridableProperties.Key))
   return
  }
 }

 ////////////////////////////////////////////////////////////////////////////////////////////
 // 3) some fields in apexBundle struct are configured
 a.installDir = android.PathForModuleInstall(ctx, "apex")
 a.filesInfo = vctx.filesInfo
 a.unwantedTransitiveFilesInfo = vctx.unwantedTransitiveFilesInfo
 a.duplicateTransitiveFilesInfo = vctx.duplicateTransitiveFilesInfo

 a.setPayloadFsType(ctx)
 a.setSystemLibLink(ctx)
 a.compatSymlinks = makeCompatSymlinks(a.BaseModuleName(), ctx)

 ////////////////////////////////////////////////////////////////////////////////////////////
 // 3.a) some artifacts are generated from the collected files
 aconfigFiles := a.buildAconfigFiles(ctx)
 a.filesInfo = append(a.filesInfo, aconfigFiles...)

 ////////////////////////////////////////////////////////////////////////////////////////////
 // 4) generate the build rules to create the APEX. This is done in builder.go.
 a.buildManifest(ctx, vctx.provideNativeLibs, vctx.requireNativeLibs)
 a.installApexSystemServerFiles(ctx)
 a.buildApex(ctx)
 a.buildApexDependencyInfo(ctx)
 a.buildLintReports(ctx)
 a.reexportJacocoInfo(ctx)

 // Set a provider for dexpreopt of bootjars
 a.provideApexExportsInfo(ctx)

 a.providePrebuiltInfo(ctx)

 a.required = a.RequiredModuleNames(ctx)
 a.required = append(a.required, a.VintfFragmentModuleNames(ctx)...)

 a.setOutputFiles(ctx)
 a.enforcePartitionTagOnApexSystemServerJar(ctx)

 a.verifyNativeImplementationLibs(ctx)
 a.enforceNoVintfInUpdatable(ctx)

 android.SetProvider(ctx, filesystem.ApexKeyPathInfoProvider, filesystem.ApexKeyPathInfo{a.apexKeysPath})

 android.SetProvider(ctx, java.ApkCertsInfoProvider, a.apkCerts)
 a.setSymbolInfosProvider(ctx)
 a.setProguardInfosProvider(ctx)

 pem, key := a.getCertificateAndPrivateKey(ctx)
 android.SetProvider(ctx, android.ApexBundleTypeInfoProvider, android.ApexBundleTypeInfo{
  Pem: pem,
  Key: key,
 })

 moduleInfoJSON := ctx.ModuleInfoJSON()
 moduleInfoJSON.Class = []string{"ETC"}
 moduleInfoJSON.SystemSharedLibs = []string{"none"}
 moduleInfoJSON.Disabled = false

 // Build compliance metadata
 if a.installable() && slices.Contains(ctx.Config().UnbundledBuildApps(), a.Name()) {
  builtFiles := []string{}
  for _, file := range aconfigFiles {
   builtFiles = append(builtFiles, file.builtFile.String())
  }

  filesContained := []string{}
  buildOutputPaths := []string{}
  filesContained = append(filesContained, a.installedFile.String())
  buildOutputPaths = append(buildOutputPaths, a.outputFile.String())
  for _, f := range a.filesInfo {
   filesContained = append(filesContained, f.path())
   buildOutputPaths = append(buildOutputPaths, f.builtFile.String())
   imageDir := android.PathForModuleOut(ctx, "image"+imageApexSuffix).String()
   for _, symlinkPath := range f.symlinkPaths() {
    filesContained = append(filesContained, symlinkPath)
    buildOutputPaths = append(buildOutputPaths, filepath.Join(imageDir, symlinkPath))
    builtFiles = append(builtFiles, filepath.Join(imageDir, symlinkPath))
   }
  }
  complianceMetadataInfo := ctx.ComplianceMetadataInfo()
  complianceMetadataInfo.SetFilesContained(filesContained)
  complianceMetadataInfo.SetBuildOutputPathsOfFilesContained(buildOutputPaths)
  complianceMetadataInfo.AddBuiltFiles(builtFiles...)
 }
}

// Set prebuiltInfoProvider. This will be used by `apex_prebuiltinfo_singleton` to print out a metadata file
// with information about whether source or prebuilt of an apex was used during the build.
func (a *apexBundle) providePrebuiltInfo(ctx android.ModuleContext) {
 info := android.PrebuiltJsonInfo{
  Name:        a.Name(),
  Is_prebuilt: false,
 }
 android.SetProvider(ctx, android.PrebuiltJsonInfoProvider, info)
}

// Set a provider containing information about the jars and .prof provided by the apex
// Apexes built from source retrieve this information by visiting `bootclasspath_fragments`
// Used by dex_bootjars to generate the boot image
func (a *apexBundle) provideApexExportsInfo(ctx android.ModuleContext) {
 ctx.VisitDirectDepsProxyWithTag(bcpfTag, func(child android.ModuleProxy) {
  if info, ok := android.OtherModuleProvider(ctx, child, java.BootclasspathFragmentApexContentInfoProvider); ok {
   exports := android.ApexExportsInfo{
    ApexName:                      a.ApexVariationName(),
    ProfilePathOnHost:             info.ProfilePathOnHost(),
    LibraryNameToDexJarPathOnHost: info.DexBootJarPathMap(),
   }
   android.SetProvider(ctx, android.ApexExportsInfoProvider, exports)
  }
 })
}

// Set output files to outputFiles property, which is later used to set the
// OutputFilesProvider
func (a *apexBundle) setOutputFiles(ctx android.ModuleContext) {
 // default dist path
 ctx.SetOutputFiles(android.Paths{a.outputFile}, "")
 ctx.SetOutputFiles(android.Paths{a.outputFile}, android.DefaultDistTag)
 // uncompressed one
 if a.outputApexFile != nil {
  ctx.SetOutputFiles(android.Paths{a.outputApexFile}, imageApexSuffix)
 }
}

// enforceAppUpdatability propagates updatable=true to apps of updatable apexes
func (a *apexBundle) enforceAppUpdatability(mctx android.ModuleContext) {
 if !a.Enabled(mctx) {
  return
 }
 if a.Updatable() {
  // checking direct deps is sufficient since apex->apk is a direct edge, even when inherited via apex_defaults
  mctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
   if appInfo, ok := android.OtherModuleProvider(mctx, module, java.AppInfoProvider); ok {
    // ignore android_test_app and android_app_import
    if !appInfo.TestHelperApp && !appInfo.Prebuilt && !appInfo.Updatable {
     mctx.ModuleErrorf("app dependency %s must have updatable: true", mctx.OtherModuleName(module))
    }
   }
  })
 }
}

// apexBootclasspathFragmentFiles returns the list of apexFile structures defining the files that
// the bootclasspath_fragment contributes to the apex.
func apexBootclasspathFragmentFiles(ctx android.ModuleContext, module android.ModuleProxy) []apexFile {
 bootclasspathFragmentInfo, _ := android.OtherModuleProvider(ctx, module, java.BootclasspathFragmentApexContentInfoProvider)
 var filesToAdd []apexFile

 // Add classpaths.proto config.
 if af := apexClasspathFragmentProtoFile(ctx, module); af != nil {
  filesToAdd = append(filesToAdd, *af)
 }

 pathInApex := bootclasspathFragmentInfo.ProfileInstallPathInApex()
 if pathInApex != "" {
  pathOnHost := bootclasspathFragmentInfo.ProfilePathOnHost()
  tempPath := android.PathForModuleOut(ctx, "boot_image_profile", pathInApex)

  if pathOnHost != nil {
   // We need to copy the profile to a temporary path with the right filename because the apexer
   // will take the filename as is.
   ctx.Build(pctx, android.BuildParams{
    Rule:   android.CpRule,
    Input:  pathOnHost,
    Output: tempPath,
   })
   ctx.ComplianceMetadataInfo().AddBuiltFiles(tempPath.String())
  } else {
   // At this point, the boot image profile cannot be generated. It is probably because the boot
   // image profile source file does not exist on the branch, or it is not available for the
   // current build target.
   // However, we cannot enforce the boot image profile to be generated because some build
   // targets (such as module SDK) do not need it. It is only needed when the APEX is being
   // built. Therefore, we create an error rule so that an error will occur at the ninja phase
   // only if the APEX is being built.
   android.ErrorRule(ctx, tempPath, "Boot image profile cannot be generated")
  }

  androidMkModuleName := filepath.Base(pathInApex)
  af := newApexFile(ctx, tempPath, androidMkModuleName, filepath.Dir(pathInApex), etc, android.ModuleProxy{})
  filesToAdd = append(filesToAdd, af)
 }

 return filesToAdd
}

// apexClasspathFragmentProtoFile returns *apexFile structure defining the classpath.proto config that
// the module contributes to the apex; or nil if the proto config was not generated.
func apexClasspathFragmentProtoFile(ctx android.ModuleContext, module android.ModuleProxy) *apexFile {
 info, _ := android.OtherModuleProvider(ctx, module, java.ClasspathFragmentProtoContentInfoProvider)
 if !info.ClasspathFragmentProtoGenerated {
  return nil
 }
 classpathProtoOutput := info.ClasspathFragmentProtoOutput
 af := newApexFile(ctx, classpathProtoOutput, classpathProtoOutput.Base(), info.ClasspathFragmentProtoInstallDir.Rel(), etc, android.ModuleProxy{})
 return &af
}

// apexFileForBootclasspathFragmentContentModule creates an apexFile for a bootclasspath_fragment
// content module, i.e. a library that is part of the bootclasspath.
func apexFileForBootclasspathFragmentContentModule(ctx android.ModuleContext, fragmentModule, javaModule android.ModuleProxy) apexFile {
 bootclasspathFragmentInfo, _ := android.OtherModuleProvider(ctx, fragmentModule, java.BootclasspathFragmentApexContentInfoProvider)

 // Get the dexBootJar from the bootclasspath_fragment as that is responsible for performing the
 // hidden API encpding.
 dexBootJar, err := bootclasspathFragmentInfo.DexBootJarPathForContentModule(javaModule)
 if err != nil {
  ctx.ModuleErrorf("%s", err)
 }

 // Create an apexFile as for a normal java module but with the dex boot jar provided by the
 // bootclasspath_fragment.
 javaInfo := android.OtherModuleProviderOrDefault(ctx, javaModule, java.JavaInfoProvider)
 af := apexFileForJavaModuleWithFile(ctx, javaModule, javaInfo, dexBootJar)
 return af
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Factory functions
//

func newApexBundle() *apexBundle {
 module := &apexBundle{}

 module.AddProperties(&module.properties)
 module.AddProperties(&module.targetProperties)
 module.AddProperties(&module.archProperties)
 module.AddProperties(&module.overridableProperties)

 android.InitAndroidMultiTargetsArchModule(module, android.DeviceSupported, android.MultilibCommon)
 android.InitDefaultableModule(module)
 android.InitOverridableModule(module, &module.overridableProperties.Overrides)
 return module
}

type apexTestProperties struct {
 // Boolean flags for validation checks. Test APEXes can turn on/off individual checks.
 Skip_validations struct {
  // Skips `Apex_sepolicy_tests` check if true
  Apex_sepolicy_tests *bool
  // Skips `Host_apex_verifier` check if true
  Host_apex_verifier *bool
 }
}

// apex_test is an APEX for testing. The difference from the ordinary apex module type is that
// certain compatibility checks such as apex_available are not done for apex_test.
func TestApexBundleFactory() android.Module {
 bundle := newApexBundle()
 bundle.testApex = true
 bundle.AddProperties(&bundle.testProperties)
 return bundle
}

// apex packages other modules into an APEX file which is a packaging format for system-level
// components like binaries, shared libraries, etc.
func BundleFactory() android.Module {
 return newApexBundle()
}

type Defaults struct {
 android.ModuleBase
 android.DefaultsModuleBase
}

// apex_defaults provides defaultable properties to other apex modules.
func DefaultsFactory() android.Module {
 module := &Defaults{}

 module.AddProperties(
  &apexBundleProperties{},
  &apexTargetBundleProperties{},
  &apexArchBundleProperties{},
  &overridableProperties{},
 )

 android.InitDefaultsModule(module)
 return module
}

type OverrideApex struct {
 android.ModuleBase
 android.OverrideModuleBase
}

func (o *OverrideApex) GenerateAndroidBuildActions(_ android.ModuleContext) {
 // All the overrides happen in the base module.
}

// override_apex is used to create an apex module based on another apex module by overriding some of
// its properties.
func OverrideApexFactory() android.Module {
 m := &OverrideApex{}

 m.AddProperties(&overridableProperties{})

 android.InitAndroidMultiTargetsArchModule(m, android.DeviceSupported, android.MultilibCommon)
 android.InitOverrideModule(m)
 return m
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// Vality check routines
//
// These are called in at the very beginning of GenerateAndroidBuildActions to flag an error when
// certain conditions are not met.
//
// TODO(jiyong): move these checks to a separate go file.

var _ android.ModuleWithMinSdkVersionCheck = (*apexBundle)(nil)

// Ensures that min_sdk_version of the included modules are equal or less than the min_sdk_version
// of this apexBundle.
func (a *apexBundle) CheckMinSdkVersion(ctx android.ModuleContext) {
 if a.testApex || a.vndkApex {
  return
 }
 // apexBundle::minSdkVersion reports its own errors.
 minSdkVersion := a.minSdkVersion(ctx)
 android.CheckMinSdkVersion(ctx, minSdkVersion, a.WalkPayloadDeps)
}

// Returns apex's min_sdk_version string value, honoring overrides
func (a *apexBundle) minSdkVersionValue(ctx android.MinSdkVersionFromValueContext) string {
 // Only override the minSdkVersion value on Apexes which already specify
 // a min_sdk_version (it's optional for non-updatable apexes), and that its
 // min_sdk_version value is lower than the one to override with.
 minApiLevel := android.MinSdkVersionFromValue(ctx, a.overridableProperties.Min_sdk_version.GetOrDefault(a.ConfigurableEvaluator(ctx), ""))
 if minApiLevel.IsNone() {
  return ""
 }

 overrideMinSdkValue := ctx.DeviceConfig().ApexGlobalMinSdkVersionOverride()
 overrideApiLevel := android.MinSdkVersionFromValue(ctx, overrideMinSdkValue)
 if !overrideApiLevel.IsNone() && overrideApiLevel.CompareTo(minApiLevel) > 0 {
  minApiLevel = overrideApiLevel
 }

 return minApiLevel.String()
}

// Returns apex's min_sdk_version SdkSpec, honoring overrides
func (a *apexBundle) MinSdkVersion(ctx android.MinSdkVersionFromValueContext) android.ApiLevel {
 return a.minSdkVersion(ctx)
}

// Returns apex's min_sdk_version ApiLevel, honoring overrides
func (a *apexBundle) minSdkVersion(ctx android.MinSdkVersionFromValueContext) android.ApiLevel {
 return android.MinSdkVersionFromValue(ctx, a.minSdkVersionValue(ctx))
}

// Ensures that a lib providing stub isn't statically linked
func (a *apexBundle) checkStaticLinkingToStubLibraries(ctx android.ModuleContext) {
 // Practically, we only care about regular APEXes on the device.
 if a.testApex || a.vndkApex {
  return
 }

 librariesDirectlyInApex := make(map[string]bool)
 ctx.VisitDirectDepsProxyWithTag(sharedLibTag, func(dep android.ModuleProxy) {
  librariesDirectlyInApex[ctx.OtherModuleName(dep)] = true
 })

 a.WalkPayloadDeps(ctx, func(ctx android.BaseModuleContext, from, to android.ModuleProxy, externalDep bool) bool {
  if info, ok := android.OtherModuleProvider(ctx, to, cc.LinkableInfoProvider); ok {
   // If `to` is not actually in the same APEX as `from` then it does not need
   // apex_available and neither do any of its dependencies.
   if externalDep {
    // As soon as the dependency graph crosses the APEX boundary, don't go further.
    return false
   }

   apexName := ctx.ModuleName()
   fromName := ctx.OtherModuleName(from)
   toName := ctx.OtherModuleName(to)

   // The dynamic linker and crash_dump tool in the runtime APEX is an
   // exception to this rule. It can't make the static dependencies dynamic
   // because it can't do the dynamic linking for itself.
   // Same rule should be applied to linkerconfig, because it should be executed
   // only with static linked libraries before linker is available with ld.config.txt
   if apexName == "com.android.runtime" && (fromName == "linker" || fromName == "crash_dump" || fromName == "linkerconfig") {
    return false
   }

   // b/389067742 adds libz as an exception to this check. Although libz is
   // a part of NDK and thus provides a stable interface, it never was the
   // intention because the upstream zlib provides neither ABI- nor behavior-
   // stability. Therefore, we want to allow portable components like APEXes to
   // bundle libz by statically linking to it.
   if toName == "libz" {
    return false
   }

   isStubLibraryFromOtherApex := info.HasStubsVariants && !librariesDirectlyInApex[toName]
   if isStubLibraryFromOtherApex && !externalDep {
    ctx.ModuleErrorf("%q required by %q is a native library providing stub. "+
     "It shouldn't be included in this APEX via static linking. Dependency path: %s", to.String(), fromName, ctx.GetPathString(false))
   }
  }
  return true
 })
}

// checkUpdatable enforces APEX and its transitive dep properties to have desired values for updatable APEXes.
func (a *apexBundle) checkUpdatable(ctx android.ModuleContext) {
 if a.Updatable() {
  if a.minSdkVersionValue(ctx) == "" {
   ctx.PropertyErrorf("updatable", "updatable APEXes should set min_sdk_version as well")
  }
  if a.minSdkVersion(ctx).IsCurrent() {
   ctx.PropertyErrorf("updatable", "updatable APEXes should not set min_sdk_version to current. Please use a finalized API level or a recognized in-development codename")
  }
  if a.UsePlatformApis() {
   ctx.PropertyErrorf("updatable", "updatable APEXes can't use platform APIs")
  }
  if a.FutureUpdatable() {
   ctx.PropertyErrorf("future_updatable", "Already updatable. Remove `future_updatable: true:`")
  }
  a.checkJavaStableSdkVersion(ctx)
  a.checkClasspathFragments(ctx)
 }
}

// checkClasspathFragments enforces that all classpath fragments in deps generate classpaths.proto config.
func (a *apexBundle) checkClasspathFragments(ctx android.ModuleContext) {
 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
  if tag := ctx.OtherModuleDependencyTag(module); tag == bcpfTag || tag == sscpfTag {
   info, _ := android.OtherModuleProvider(ctx, module, java.ClasspathFragmentProtoContentInfoProvider)
   if !info.ClasspathFragmentProtoGenerated {
    ctx.OtherModuleErrorf(module, "is included in updatable apex %v, it must not set generate_classpaths_proto to false", ctx.ModuleName())
   }
  }
 })
}

// checkJavaStableSdkVersion enforces that all Java deps are using stable SDKs to compile.
func (a *apexBundle) checkJavaStableSdkVersion(ctx android.ModuleContext) {
 // Visit direct deps only. As long as we guarantee top-level deps are using stable SDKs,
 // java's checkLinkType guarantees correct usage for transitive deps
 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
  tag := ctx.OtherModuleDependencyTag(module)
  switch tag {
  case javaLibTag, androidAppTag:
   if err := java.CheckStableSdkVersion(ctx, module); err != nil {
    ctx.ModuleErrorf("cannot depend on \"%v\": %v", ctx.OtherModuleName(module), err)
   }
  }
 })
}

// checkApexAvailability ensures that the all the dependencies are marked as available for this APEX.
func (a *apexBundle) checkApexAvailability(ctx android.ModuleContext) {
 // Let's be practical. Availability for test, host, and the VNDK apex isn't important
 if a.testApex || a.vndkApex {
  return
 }

 // Because APEXes targeting other than system/system_ext partitions can't set
 // apex_available, we skip checks for these APEXes
 if a.SocSpecific() || a.DeviceSpecific() || (a.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
  return
 }

 // Temporarily bypass /product APEXes with a specific prefix.
 // TODO: b/352818241 - Remove this after APEX availability is enforced for /product APEXes.
 if a.ProductSpecific() && sdvApexPattern.MatchString(a.ApexVariationName()) {
  return
 }

 // Coverage build adds additional dependencies for the coverage-only runtime libraries.
 // Requiring them and their transitive depencies with apex_available is not right
 // because they just add noise.
 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") || a.IsNativeCoverageNeeded(ctx) {
  return
 }

 a.WalkPayloadDeps(ctx, func(ctx android.BaseModuleContext, from, to android.ModuleProxy, externalDep bool) bool {
  // As soon as the dependency graph crosses the APEX boundary, don't go further.
  if externalDep {
   return false
  }

  apexName := ctx.ModuleName()
  for _, props := range ctx.Module().GetProperties() {
   if apexProps, ok := props.(*apexBundleProperties); ok {
    if apexProps.Apex_available_name != nil {
     apexName = *apexProps.Apex_available_name
    }
   }
  }
  fromName := ctx.OtherModuleName(from)
  toName := ctx.OtherModuleName(to)

  if android.CheckAvailableForApex(apexName,
   android.OtherModuleProviderOrDefault(ctx, to, android.ApexAvailableInfoProvider).ApexAvailableFor) {
   return true
  }

  // Let's give some hint for apex_available
  hint := fmt.Sprintf("%q", apexName)

  if strings.HasPrefix(apexName, "com.") && !strings.HasPrefix(apexName, "com.android.") && strings.Count(apexName, ".") >= 2 {
   // In case of a partner APEX, prefix format might be an option.
   components := strings.Split(apexName, ".")
   components[len(components)-1] = "*"
   hint += fmt.Sprintf(" or %q", strings.Join(components, "."))
  }

  ctx.ModuleErrorf("%q requires %q that doesn't list the APEX under 'apex_available'."+
   "\n\nDependency path:%s\n\n"+
   "Consider adding %s to 'apex_available' property of %q",
   fromName, toName, ctx.GetPathString(true), hint, toName)
  // Visit this module's dependencies to check and report any issues with their availability.
  return true
 })
}

// checkStaticExecutable ensures that executables in an APEX are not static.
func (a *apexBundle) checkStaticExecutables(ctx android.ModuleContext) {
 ctx.VisitDirectDepsProxy(func(module android.ModuleProxy) {
  if ctx.OtherModuleDependencyTag(module) != executableTag {
   return
  }

  if android.OtherModuleProviderOrDefault(ctx, module, cc.LinkableInfoProvider).StaticExecutable {
   apex := a.ApexVariationName()
   exec := ctx.OtherModuleName(module)
   if isStaticExecutableAllowed(apex, exec) {
    return
   }
   ctx.ModuleErrorf("executable %s is static", ctx.OtherModuleName(module))
  }
 })
}

// A small list of exceptions where static executables are allowed in APEXes.
func isStaticExecutableAllowed(apex string, exec string) bool {
 m := map[string][]string{
  "com.android.runtime": {
   "linker",
   "linkerconfig",
  },
 }
 execNames, ok := m[apex]
 return ok && android.InList(exec, execNames)
}

// Collect information for opening IDE project files in java/jdeps.go.
func (a *apexBundle) IDEInfo(ctx android.BaseModuleContext, dpInfo *android.IdeInfo) {
 dpInfo.Deps = append(dpInfo.Deps, a.properties.Java_libs...)
 dpInfo.Deps = append(dpInfo.Deps, a.properties.Bootclasspath_fragments.GetOrDefault(ctx, nil)...)
 dpInfo.Deps = append(dpInfo.Deps, a.properties.Systemserverclasspath_fragments.GetOrDefault(ctx, nil)...)
}

func init() {
 android.AddNeverAllowRules(createBcpPermittedPackagesRules(qBcpPackages())...)
 android.AddNeverAllowRules(createBcpPermittedPackagesRules(rBcpPackages())...)
}

func createBcpPermittedPackagesRules(bcpPermittedPackages map[string][]string) []android.Rule {
 rules := make([]android.Rule, 0, len(bcpPermittedPackages))
 for jar, permittedPackages := range bcpPermittedPackages {
  permittedPackagesRule := android.NeverAllow().
   With("name", jar).
   WithMatcher("permitted_packages", android.NotInList(permittedPackages)).
   Because(jar +
    " bootjar may only use these package prefixes: " + strings.Join(permittedPackages, ",") +
    ". Please consider the following alternatives:\n" +
    "    1. If the offending code is from a statically linked library, consider " +
    "removing that dependency and using an alternative already in the " +
    "bootclasspath, or perhaps a shared library." +
    "    2. Move the offending code into an allowed package.\n" +
    "    3. Jarjar the offending code. Please be mindful of the potential system " +
    "health implications of bundling that code, particularly if the offending jar " +
    "is part of the bootclasspath.")

  rules = append(rules, permittedPackagesRule)
 }
 return rules
}

// DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART.
// Adding code to the bootclasspath in new packages will cause issues on module update.
func qBcpPackages() map[string][]string {
 return map[string][]string{
  "conscrypt": {
   "android.net.ssl",
   "com.android.org.conscrypt",
  },
  "updatable-media": {
   "android.media",
  },
 }
}

// DO NOT EDIT! These are the package prefixes that are exempted from being AOT'ed by ART.
// Adding code to the bootclasspath in new packages will cause issues on module update.
func rBcpPackages() map[string][]string {
 return map[string][]string{
  "framework-mediaprovider": {
   "android.provider",
  },
  "framework-permission": {
   "android.permission",
   "android.app.role",
   "com.android.permission",
   "com.android.role",
  },
  "framework-sdkextensions": {
   "android.os.ext",
  },
  "framework-statsd": {
   "android.app",
   "android.os",
   "android.util",
   "com.android.internal.statsd",
   "com.android.server.stats",
  },
  "framework-wifi": {
   "com.android.server.wifi",
   "com.android.wifi.x",
   "android.hardware.wifi",
   "android.net.wifi",
  },
  "framework-tethering": {
   "android.net",
  },
 }
}

// verifyNativeImplementationLibs compares the list of transitive implementation libraries used to link native
// libraries in the apex against the list of implementation libraries in the apex, ensuring that none of the
// libraries in the apex have references to private APIs from outside the apex.
func (a *apexBundle) verifyNativeImplementationLibs(ctx android.ModuleContext) {
 var directImplementationLibs android.Paths
 var transitiveImplementationLibs []depset.DepSet[android.Path]

 if a.testApex {
  return
 }

 if a.UsePlatformApis() {
  return
 }

 checkApexTag := func(tag blueprint.DependencyTag) bool {
  switch tag {
  case sharedLibTag, jniLibTag, executableTag, androidAppTag:
   return true
  default:
   return false
  }
 }

 checkTransitiveTag := func(tag blueprint.DependencyTag) bool {
  switch {
  case cc.IsSharedDepTag(tag), java.IsJniDepTag(tag), rust.IsRlibDepTag(tag), rust.IsDylibDepTag(tag), checkApexTag(tag):
   return true
  default:
   return false
  }
 }

 var appEmbeddedJNILibs android.Paths
 ctx.VisitDirectDepsProxy(func(dep android.ModuleProxy) {
  tag := ctx.OtherModuleDependencyTag(dep)
  if !checkApexTag(tag) {
   return
  }
  if tag == sharedLibTag || tag == jniLibTag {
   outputFile := android.OutputFileForModule(ctx, dep, "")
   directImplementationLibs = append(directImplementationLibs, outputFile)
  }
  if info, ok := android.OtherModuleProvider(ctx, dep, cc.ImplementationDepInfoProvider); ok {
   transitiveImplementationLibs = append(transitiveImplementationLibs, info.ImplementationDeps)
  }
  if info, ok := android.OtherModuleProvider(ctx, dep, java.AppInfoProvider); ok {
   appEmbeddedJNILibs = append(appEmbeddedJNILibs, info.EmbeddedJNILibs...)
  }
 })

 depSet := depset.New(depset.PREORDER, directImplementationLibs, transitiveImplementationLibs)
 allImplementationLibs := depSet.ToList()

 allFileInfos := slices.Concat(a.filesInfo, a.unwantedTransitiveFilesInfo, a.duplicateTransitiveFilesInfo)

 for _, lib := range allImplementationLibs {
  inApex := slices.ContainsFunc(allFileInfos, func(fi apexFile) bool {
   return fi.builtFile == lib
  })
  inApkInApex := slices.Contains(appEmbeddedJNILibs, lib)

  if !inApex && !inApkInApex {
   ctx.ModuleErrorf("library in apex transitively linked against implementation library %q not in apex", lib)
   var depPath []android.ModuleProxy
   ctx.WalkDepsProxy(func(child, parent android.ModuleProxy) bool {
    if depPath != nil {
     return false
    }

    tag := ctx.OtherModuleDependencyTag(child)

    if android.EqualModules(parent, ctx.Module()) {
     if !checkApexTag(tag) {
      return false
     }
    }

    if checkTransitiveTag(tag) {
     if android.OutputFileForModule(ctx, child, "") == lib {
      depPath = ctx.GetProxyWalkPath()
     }
     return true
    }

    return false
   })
   if depPath != nil {
    ctx.ModuleErrorf("dependency path:")
    for _, m := range depPath {
     ctx.ModuleErrorf("   %s", ctx.OtherModuleName(m))
    }
    return
   }
  }
 }
}

// TODO(b/399527905) libvintf is not forward compatible.
func (a *apexBundle) enforceNoVintfInUpdatable(ctx android.ModuleContext) {
 if !a.Updatable() {
  return
 }
 for _, fi := range a.filesInfo {
  if match, _ := path.Match("etc/vintf/*", fi.path()); match {
   ctx.ModuleErrorf("VINTF fragment (%s) is not supported in updatable APEX.", fi.path())
   break
  }
 }
}

func (a *apexBundle) setSymbolInfosProvider(ctx android.ModuleContext) {
 if !a.properties.HideFromMake && a.installable() {
  infos := &cc.SymbolInfos{}
  for _, fi := range a.filesInfo {
   linkToSystemLib := a.linkToSystemLib && fi.transitiveDep && fi.availableToPlatform()
   if linkToSystemLib {
    // No need to copy the file since it's linked to the system file
    continue
   }
   moduleDir := android.PathForModuleInPartitionInstall(ctx, "apex", a.BaseModuleName(), fi.installDir)
   info := &cc.SymbolInfo{
    Name:          a.fullModuleName(a.BaseModuleName(), linkToSystemLib, &fi),
    ModuleDir:     moduleDir.String(),
    Uninstallable: !a.installable(),
   }
   switch fi.class {
   case nativeSharedLib, nativeExecutable, nativeTest:
    info.Stem = fi.stem()
    if fi.providers != nil && fi.providers.linkableInfo != nil {
     linkableInfo := fi.providers.linkableInfo
     if linkableInfo.UnstrippedOutputFile != nil {
      info.UnstrippedBinaryPath = linkableInfo.UnstrippedOutputFile
     }
    }
    if info.UnstrippedBinaryPath != nil {
     infos.AppendSymbols(info)
    }
   case app:
    if fi.providers != nil && fi.providers.appInfo != nil {
     appInfo := fi.providers.appInfo
     // The following logic comes from java.GetJniSymbolInfos
     for _, install := range java.JNISymbolsInstalls(appInfo.JniLibs, moduleDir.String()) {
      info := &cc.SymbolInfo{
       Name:                 fi.providers.commonInfo.BaseModuleName,
       ModuleDir:            filepath.Dir(install.To),
       Uninstallable:        fi.providers.commonInfo.SkipInstall || !fi.providers.javaInfo.Installable || fi.providers.commonInfo.NoFullInstall,
       UnstrippedBinaryPath: install.From,
       InstalledStem:        filepath.Base(install.To),
      }
      infos.AppendSymbols(info)
     }
    }
   }
  }

  cc.CopySymbolsAndSetSymbolsInfoProvider(ctx, infos)
 }
}

func (a *apexBundle) setProguardInfosProvider(ctx android.ModuleContext) {
 var proguardInfos java.ProguardInfos
 ctx.VisitDirectDepsProxy(func(child android.ModuleProxy) {
  tag := ctx.OtherModuleDependencyTag(child)
  if tag == androidAppTag || tag == bcpfTag || tag == sscpfTag || tag == javaLibTag {
   if infos, ok := android.OtherModuleProvider(ctx, child, java.ProguardProvider); ok {
    proguardInfos = append(proguardInfos, infos...)
   }
  }
 })

 if len(proguardInfos) > 0 {
  android.SetProvider(ctx, java.ProguardProvider, proguardInfos)
 }
}