diff options
Diffstat (limited to 'java/java.go')
| -rw-r--r-- | java/java.go | 763 |
1 files changed, 458 insertions, 305 deletions
diff --git a/java/java.go b/java/java.go index 88b31b586..64bc9599c 100644 --- a/java/java.go +++ b/java/java.go @@ -26,9 +26,9 @@ import ( "strings" "android/soong/remoteexec" - "android/soong/testing" "github.com/google/blueprint" + "github.com/google/blueprint/depset" "github.com/google/blueprint/proptools" "android/soong/android" @@ -70,9 +70,9 @@ func registerJavaBuildComponents(ctx android.RegistrationContext) { // established, to not get the dependencies split into the wrong variants and // to support the checks in dexpreoptDisabled(). ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) { - ctx.BottomUp("dexpreopt_tool_deps", dexpreoptToolDepsMutator).Parallel() + ctx.BottomUp("dexpreopt_tool_deps", dexpreoptToolDepsMutator) // needs access to ApexInfoProvider which is available after variant creation - ctx.BottomUp("jacoco_deps", jacocoDepsMutator).Parallel() + ctx.BottomUp("jacoco_deps", jacocoDepsMutator) }) ctx.RegisterParallelSingletonType("kythe_java_extract", kytheExtractJavaFactory) @@ -226,9 +226,9 @@ var ( // Rule for generating device binary default wrapper deviceBinaryWrapper = pctx.StaticRule("deviceBinaryWrapper", blueprint.RuleParams{ - Command: `echo -e '#!/system/bin/sh\n` + + Command: `printf '#!/system/bin/sh\n` + `export CLASSPATH=/system/framework/$jar_name\n` + - `exec app_process /$partition/bin $main_class "$$@"'> ${out}`, + `exec app_process /$partition/bin $main_class "$$@"\n'> ${out}`, Description: "Generating device binary wrapper ${jar_name}", }, "jar_name", "partition", "main_class") ) @@ -242,10 +242,10 @@ type ProguardSpecInfo struct { // TransitiveDepsProguardSpecFiles is a depset of paths to proguard flags files that are exported from // all transitive deps. This list includes all proguard flags files from transitive static dependencies, // and all proguard flags files from transitive libs dependencies which set `export_proguard_spec: true`. - ProguardFlagsFiles *android.DepSet[android.Path] + ProguardFlagsFiles depset.DepSet[android.Path] // implementation detail to store transitive proguard flags files from exporting shared deps - UnconditionallyExportedProguardFlags *android.DepSet[android.Path] + UnconditionallyExportedProguardFlags depset.DepSet[android.Path] } var ProguardSpecInfoProvider = blueprint.NewProvider[ProguardSpecInfo]() @@ -254,27 +254,40 @@ var ProguardSpecInfoProvider = blueprint.NewProvider[ProguardSpecInfo]() type JavaInfo struct { // HeaderJars is a list of jars that can be passed as the javac classpath in order to link // against this module. If empty, ImplementationJars should be used instead. + // Unlike LocalHeaderJars, HeaderJars includes classes from static dependencies. HeaderJars android.Paths RepackagedHeaderJars android.Paths // set of header jars for all transitive libs deps - TransitiveLibsHeaderJars *android.DepSet[android.Path] + TransitiveLibsHeaderJarsForR8 depset.DepSet[android.Path] // set of header jars for all transitive static libs deps - TransitiveStaticLibsHeaderJars *android.DepSet[android.Path] + TransitiveStaticLibsHeaderJarsForR8 depset.DepSet[android.Path] + + // depset of header jars for this module and all transitive static dependencies + TransitiveStaticLibsHeaderJars depset.DepSet[android.Path] + + // depset of implementation jars for this module and all transitive static dependencies + TransitiveStaticLibsImplementationJars depset.DepSet[android.Path] + + // depset of resource jars for this module and all transitive static dependencies + TransitiveStaticLibsResourceJars depset.DepSet[android.Path] // ImplementationAndResourceJars is a list of jars that contain the implementations of classes // in the module as well as any resources included in the module. ImplementationAndResourcesJars android.Paths // ImplementationJars is a list of jars that contain the implementations of classes in the - //module. + // module. ImplementationJars android.Paths // ResourceJars is a list of jars that contain the resources included in the module. ResourceJars android.Paths + // LocalHeaderJars is a list of jars that contain classes from this module, but not from any static dependencies. + LocalHeaderJars android.Paths + // AidlIncludeDirs is a list of directories that should be passed to the aidl tool when // depending on this module. AidlIncludeDirs android.Paths @@ -287,7 +300,7 @@ type JavaInfo struct { SrcJarDeps android.Paths // The source files of this module and all its transitive static dependencies. - TransitiveSrcFiles *android.DepSet[android.Path] + TransitiveSrcFiles depset.DepSet[android.Path] // ExportedPlugins is a list of paths that should be used as annotation processors for any // module that depends on this module. @@ -313,16 +326,18 @@ type JavaInfo struct { // AconfigIntermediateCacheOutputPaths is a path to the cache files collected from the // java_aconfig_library modules that are statically linked to this module. AconfigIntermediateCacheOutputPaths android.Paths + + SdkVersion android.SdkSpec } -var JavaInfoProvider = blueprint.NewProvider[JavaInfo]() +var JavaInfoProvider = blueprint.NewProvider[*JavaInfo]() // SyspropPublicStubInfo contains info about the sysprop public stub library that corresponds to // the sysprop implementation library. type SyspropPublicStubInfo struct { // JavaInfo is the JavaInfoProvider of the sysprop public stub library that corresponds to // the sysprop implementation library. - JavaInfo JavaInfo + JavaInfo *JavaInfo } var SyspropPublicStubInfoProvider = blueprint.NewProvider[SyspropPublicStubInfo]() @@ -343,12 +358,17 @@ type UsesLibraryDependency interface { // TODO(jungjw): Move this to kythe.go once it's created. type xref interface { XrefJavaFiles() android.Paths + XrefKotlinFiles() android.Paths } func (j *Module) XrefJavaFiles() android.Paths { return j.kytheFiles } +func (j *Module) XrefKotlinFiles() android.Paths { + return j.kytheKotlinFiles +} + func (d dependencyTag) PropagateAconfigValidation() bool { return d.static } @@ -421,8 +441,6 @@ var ( bootClasspathTag = dependencyTag{name: "bootclasspath", runtimeLinked: true} systemModulesTag = dependencyTag{name: "system modules", runtimeLinked: true} frameworkResTag = dependencyTag{name: "framework-res"} - kotlinStdlibTag = dependencyTag{name: "kotlin-stdlib", runtimeLinked: true} - kotlinAnnotationsTag = dependencyTag{name: "kotlin-annotations", runtimeLinked: true} kotlinPluginTag = dependencyTag{name: "kotlin-plugin", toolchain: true} proguardRaiseTag = dependencyTag{name: "proguard-raise"} certificateTag = dependencyTag{name: "certificate"} @@ -432,10 +450,8 @@ var ( r8LibraryJarTag = dependencyTag{name: "r8-libraryjar", runtimeLinked: true} syspropPublicStubDepTag = dependencyTag{name: "sysprop public stub"} javaApiContributionTag = dependencyTag{name: "java-api-contribution"} - depApiSrcsTag = dependencyTag{name: "dep-api-srcs"} aconfigDeclarationTag = dependencyTag{name: "aconfig-declaration"} jniInstallTag = dependencyTag{name: "jni install", runtimeLinked: true, installable: true} - binaryInstallTag = dependencyTag{name: "binary install", runtimeLinked: true, installable: true} usesLibReqTag = makeUsesLibraryDependencyTag(dexpreopt.AnySdkVersion, false) usesLibOptTag = makeUsesLibraryDependencyTag(dexpreopt.AnySdkVersion, true) usesLibCompat28OptTag = makeUsesLibraryDependencyTag(28, true) @@ -443,6 +459,28 @@ var ( usesLibCompat30OptTag = makeUsesLibraryDependencyTag(30, true) ) +// A list of tags for deps used for compiling a module. +// Any dependency tags that modifies the following properties of `deps` in `Module.collectDeps` should be +// added to this list: +// - bootClasspath +// - classpath +// - java9Classpath +// - systemModules +// - kotlin deps... +var ( + compileDependencyTags = []blueprint.DependencyTag{ + sdkLibTag, + libTag, + staticLibTag, + bootClasspathTag, + systemModulesTag, + java9LibTag, + kotlinPluginTag, + syspropPublicStubDepTag, + instrumentationForTag, + } +) + func IsLibDepTag(depTag blueprint.DependencyTag) bool { return depTag == libTag || depTag == sdkLibTag } @@ -534,7 +572,7 @@ type deps struct { // are provided by systemModules. java9Classpath classpath - processorPath classpath + processorPath classpath `` errorProneProcessorPath classpath processorClasses []string staticJars android.Paths @@ -545,12 +583,14 @@ type deps struct { srcJars android.Paths systemModules *systemModules aidlPreprocess android.OptionalPath - kotlinStdlib android.Paths - kotlinAnnotations android.Paths kotlinPlugins android.Paths aconfigProtoFiles android.Paths disableTurbine bool + + transitiveStaticLibsHeaderJars []depset.DepSet[android.Path] + transitiveStaticLibsImplementationJars []depset.DepSet[android.Path] + transitiveStaticLibsResourceJars []depset.DepSet[android.Path] } func checkProducesJars(ctx android.ModuleContext, dep android.SourceFileProducer) { @@ -568,10 +608,8 @@ func getJavaVersion(ctx android.ModuleContext, javaVersion string, sdkContext an } else if ctx.Device() { return defaultJavaLanguageVersion(ctx, sdkContext.SdkVersion(ctx)) } else if ctx.Config().TargetsJava21() { - // Temporary experimental flag to be able to try and build with - // java version 21 options. The flag, if used, just sets Java - // 21 as the default version, leaving any components that - // target an older version intact. + // Build flag that controls whether Java 21 is used as the default + // target version, or Java 17. return JAVA_VERSION_21 } else { return JAVA_VERSION_17 @@ -906,6 +944,7 @@ func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) { // Even though the source javalib is not used, we need to hide it to prevent duplicate installation rules. // TODO (b/331665856): Implement a principled solution for this. j.HideFromMake() + j.SkipInstall() } j.provideHiddenAPIPropertyInfo(ctx) @@ -963,15 +1002,9 @@ func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) { j.dexpreopter.disableDexpreopt() } } - j.compile(ctx, nil, nil, nil) + j.compile(ctx, nil, nil, nil, nil) - // If this module is an impl library created from java_sdk_library, - // install the files under the java_sdk_library module outdir instead of this module outdir. - if j.SdkLibraryName() != nil && strings.HasSuffix(j.Name(), ".impl") { - j.setInstallRules(ctx, proptools.String(j.SdkLibraryName())) - } else { - j.setInstallRules(ctx, ctx.ModuleName()) - } + j.setInstallRules(ctx) android.SetProvider(ctx, android.TestOnlyProviderKey, android.TestModuleInformation{ TestOnly: Bool(j.sourceProperties.Test_only), @@ -981,7 +1014,27 @@ func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) { setOutputFiles(ctx, j.Module) } -func (j *Library) setInstallRules(ctx android.ModuleContext, installModuleName string) { +func (j *Library) getJarInstallDir(ctx android.ModuleContext) android.InstallPath { + var installDir android.InstallPath + if ctx.InstallInTestcases() { + var archDir string + if !ctx.Host() { + archDir = ctx.DeviceConfig().DeviceArch() + } + installModuleName := ctx.ModuleName() + // If this module is an impl library created from java_sdk_library, + // install the files under the java_sdk_library module outdir instead of this module outdir. + if j.SdkLibraryName() != nil && strings.HasSuffix(j.Name(), ".impl") { + installModuleName = proptools.String(j.SdkLibraryName()) + } + installDir = android.PathForModuleInstall(ctx, installModuleName, archDir) + } else { + installDir = android.PathForModuleInstall(ctx, "framework") + } + return installDir +} + +func (j *Library) setInstallRules(ctx android.ModuleContext) { apexInfo, _ := android.ModuleProvider(ctx, android.ApexInfoProvider) if (Bool(j.properties.Installable) || ctx.Host()) && apexInfo.IsForPlatform() { @@ -991,21 +1044,11 @@ func (j *Library) setInstallRules(ctx android.ModuleContext, installModuleName s } hostDexNeeded := Bool(j.deviceProperties.Hostdex) && !ctx.Host() if hostDexNeeded { - j.hostdexInstallFile = ctx.InstallFile( + j.hostdexInstallFile = ctx.InstallFileWithoutCheckbuild( android.PathForHostDexInstall(ctx, "framework"), j.Stem()+"-hostdex.jar", j.outputFile) } - var installDir android.InstallPath - if ctx.InstallInTestcases() { - var archDir string - if !ctx.Host() { - archDir = ctx.DeviceConfig().DeviceArch() - } - installDir = android.PathForModuleInstall(ctx, installModuleName, archDir) - } else { - installDir = android.PathForModuleInstall(ctx, "framework") - } - j.installFile = ctx.InstallFile(installDir, j.Stem()+".jar", j.outputFile, extraInstallDeps...) + j.installFile = ctx.InstallFileWithoutCheckbuild(j.getJarInstallDir(ctx), j.Stem()+".jar", j.outputFile, extraInstallDeps...) } } @@ -1249,6 +1292,22 @@ type testProperties struct { // the test Data []string `android:"path"` + // Same as data, but will add dependencies on modules using the device's os variation and + // the common arch variation. Useful for a host test that wants to embed a module built for + // device. + Device_common_data []string `android:"path_device_common"` + + // same as data, but adds dependencies using the device's os variation and the device's first + // architecture's variation. Can be used to add a module built for device to the data of a + // host test. + Device_first_data []string `android:"path_device_first"` + + // same as data, but adds dependencies using the device's os variation and the device's first + // 32-bit architecture's variation. If a 32-bit arch doesn't exist for this device, it will use + // a 64 bit arch instead. Can be used to add a module built for device to the data of a + // host test. + Device_first_prefer32_data []string `android:"path_device_first_prefer32"` + // Flag to indicate whether or not to create test config automatically. If AndroidTest.xml // doesn't exist next to the Android.bp, this attribute doesn't need to be set to true // explicitly. @@ -1262,7 +1321,7 @@ type testProperties struct { Test_options TestOptions // Names of modules containing JNI libraries that should be installed alongside the test. - Jni_libs []string + Jni_libs proptools.Configurable[[]string] // Install the test into a folder named for the module in all test suites. Per_testcase_directory *bool @@ -1446,10 +1505,11 @@ func (j *TestHost) DepsMutator(ctx android.BottomUpMutatorContext) { } } - if len(j.testProperties.Jni_libs) > 0 { + jniLibs := j.testProperties.Jni_libs.GetOrDefault(ctx, nil) + if len(jniLibs) > 0 { for _, target := range ctx.MultiTargets() { sharedLibVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"}) - ctx.AddFarVariationDependencies(sharedLibVariations, jniLibTag, j.testProperties.Jni_libs...) + ctx.AddFarVariationDependencies(sharedLibVariations, jniLibTag, jniLibs...) } } @@ -1498,23 +1558,23 @@ func (j *TestHost) GenerateAndroidBuildActions(ctx android.ModuleContext) { } j.Test.generateAndroidBuildActionsWithConfig(ctx, configs) - android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{}) android.SetProvider(ctx, tradefed.BaseTestProviderKey, tradefed.BaseTestProviderData{ - InstalledFiles: j.data, - OutputFile: j.outputFile, - TestConfig: j.testConfig, - RequiredModuleNames: j.RequiredModuleNames(ctx), - TestSuites: j.testProperties.Test_suites, - IsHost: true, - LocalSdkVersion: j.sdkVersion.String(), - IsUnitTest: Bool(j.testProperties.Test_options.Unit_test), + TestcaseRelDataFiles: testcaseRel(j.data), + OutputFile: j.outputFile, + TestConfig: j.testConfig, + RequiredModuleNames: j.RequiredModuleNames(ctx), + TestSuites: j.testProperties.Test_suites, + IsHost: true, + LocalSdkVersion: j.sdkVersion.String(), + IsUnitTest: Bool(j.testProperties.Test_options.Unit_test), + MkInclude: "$(BUILD_SYSTEM)/soong_java_prebuilt.mk", + MkAppClass: "JAVA_LIBRARIES", }) } func (j *Test) GenerateAndroidBuildActions(ctx android.ModuleContext) { checkMinSdkVersionMts(ctx, j.MinSdkVersion(ctx)) j.generateAndroidBuildActionsWithConfig(ctx, nil) - android.SetProvider(ctx, testing.TestModuleProviderKey, testing.TestModuleProviderData{}) } func (j *Test) generateAndroidBuildActionsWithConfig(ctx android.ModuleContext, configs []tradefed.Config) { @@ -1538,6 +1598,9 @@ func (j *Test) generateAndroidBuildActionsWithConfig(ctx android.ModuleContext, }) j.data = android.PathsForModuleSrc(ctx, j.testProperties.Data) + j.data = append(j.data, android.PathsForModuleSrc(ctx, j.testProperties.Device_common_data)...) + j.data = append(j.data, android.PathsForModuleSrc(ctx, j.testProperties.Device_first_data)...) + j.data = append(j.data, android.PathsForModuleSrc(ctx, j.testProperties.Device_first_prefer32_data)...) j.extraTestConfigs = android.PathsForModuleSrc(ctx, j.testProperties.Test_options.Extra_test_configs) @@ -1549,6 +1612,8 @@ func (j *Test) generateAndroidBuildActionsWithConfig(ctx android.ModuleContext, j.data = append(j.data, android.OutputFileForModule(ctx, dep, "")) }) + var directImplementationDeps android.Paths + var transitiveImplementationDeps []depset.DepSet[android.Path] ctx.VisitDirectDepsWithTag(jniLibTag, func(dep android.Module) { sharedLibInfo, _ := android.OtherModuleProvider(ctx, dep, cc.SharedLibraryInfoProvider) if sharedLibInfo.SharedLibrary != nil { @@ -1567,11 +1632,20 @@ func (j *Test) generateAndroidBuildActionsWithConfig(ctx android.ModuleContext, Output: relocatedLib, }) j.data = append(j.data, relocatedLib) + + directImplementationDeps = append(directImplementationDeps, android.OutputFileForModule(ctx, dep, "")) + if info, ok := android.OtherModuleProvider(ctx, dep, cc.ImplementationDepInfoProvider); ok { + transitiveImplementationDeps = append(transitiveImplementationDeps, info.ImplementationDeps) + } } else { ctx.PropertyErrorf("jni_libs", "%q of type %q is not supported", dep.Name(), ctx.OtherModuleType(dep)) } }) + android.SetProvider(ctx, cc.ImplementationDepInfoProvider, &cc.ImplementationDepInfo{ + ImplementationDeps: depset.New(depset.PREORDER, directImplementationDeps, transitiveImplementationDeps), + }) + j.Library.GenerateAndroidBuildActions(ctx) } @@ -1755,8 +1829,7 @@ type binaryProperties struct { // Name of the class containing main to be inserted into the manifest as Main-Class. Main_class *string - // Names of modules containing JNI libraries that should be installed alongside the host - // variant of the binary. + // Names of modules containing JNI libraries that should be installed alongside the binary. Jni_libs []string `android:"arch_variant"` } @@ -1765,10 +1838,10 @@ type Binary struct { binaryProperties binaryProperties - isWrapperVariant bool - wrapperFile android.Path binaryFile android.InstallPath + + androidMkNamesOfJniLibs []string } func (j *Binary) HostToolPath() android.OptionalPath { @@ -1778,82 +1851,94 @@ func (j *Binary) HostToolPath() android.OptionalPath { func (j *Binary) GenerateAndroidBuildActions(ctx android.ModuleContext) { j.stem = proptools.StringDefault(j.overridableProperties.Stem, ctx.ModuleName()) - if ctx.Arch().ArchType == android.Common { - // Compile the jar - if j.binaryProperties.Main_class != nil { - if j.properties.Manifest != nil { - ctx.PropertyErrorf("main_class", "main_class cannot be used when manifest is set") - } - manifestFile := android.PathForModuleOut(ctx, "manifest.txt") - GenerateMainClassManifest(ctx, manifestFile, String(j.binaryProperties.Main_class)) - j.overrideManifest = android.OptionalPathForPath(manifestFile) - } - - j.Library.GenerateAndroidBuildActions(ctx) + // Handle the binary wrapper. This comes before compiling the jar so that the wrapper + // is the first PackagingSpec + if j.binaryProperties.Wrapper != nil { + j.wrapperFile = android.PathForModuleSrc(ctx, *j.binaryProperties.Wrapper) } else { - // Handle the binary wrapper - j.isWrapperVariant = true - - if j.binaryProperties.Wrapper != nil { - j.wrapperFile = android.PathForModuleSrc(ctx, *j.binaryProperties.Wrapper) - } else { - if ctx.Windows() { - ctx.PropertyErrorf("wrapper", "wrapper is required for Windows") - } + if ctx.Windows() { + ctx.PropertyErrorf("wrapper", "wrapper is required for Windows") + } - if ctx.Device() { - // device binary should have a main_class property if it does not - // have a specific wrapper, so that a default wrapper can - // be generated for it. - if j.binaryProperties.Main_class == nil { - ctx.PropertyErrorf("main_class", "main_class property "+ - "is required for device binary if no default wrapper is assigned") - } else { - wrapper := android.PathForModuleOut(ctx, ctx.ModuleName()+".sh") - jarName := j.Stem() + ".jar" - partition := j.PartitionTag(ctx.DeviceConfig()) - ctx.Build(pctx, android.BuildParams{ - Rule: deviceBinaryWrapper, - Output: wrapper, - Args: map[string]string{ - "jar_name": jarName, - "partition": partition, - "main_class": String(j.binaryProperties.Main_class), - }, - }) - j.wrapperFile = wrapper - } + if ctx.Device() { + // device binary should have a main_class property if it does not + // have a specific wrapper, so that a default wrapper can + // be generated for it. + if j.binaryProperties.Main_class == nil { + ctx.PropertyErrorf("main_class", "main_class property "+ + "is required for device binary if no default wrapper is assigned") } else { - j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh") + wrapper := android.PathForModuleOut(ctx, ctx.ModuleName()+".sh") + jarName := j.Stem() + ".jar" + partition := j.PartitionTag(ctx.DeviceConfig()) + ctx.Build(pctx, android.BuildParams{ + Rule: deviceBinaryWrapper, + Output: wrapper, + Args: map[string]string{ + "jar_name": jarName, + "partition": partition, + "main_class": String(j.binaryProperties.Main_class), + }, + }) + j.wrapperFile = wrapper } + } else { + j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh") } + } - ext := "" - if ctx.Windows() { - ext = ".bat" + ext := "" + if ctx.Windows() { + ext = ".bat" + } + + // The host installation rules make the installed wrapper depend on all the dependencies + // of the wrapper variant, which will include the common variant's jar file and any JNI + // libraries. This is verified by TestBinary. Also make it depend on the jar file so that + // the binary file timestamp will update when the jar file timestamp does. The jar file is + // built later on, in j.Library.GenerateAndroidBuildActions, so we have to create an identical + // installpath representing it here. + j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"), + ctx.ModuleName()+ext, j.wrapperFile, j.getJarInstallDir(ctx).Join(ctx, j.Stem()+".jar")) + + // Set the jniLibs of this binary. + // These will be added to `LOCAL_REQUIRED_MODULES`, and the kati packaging system will + // install these alongside the java binary. + ctx.VisitDirectDepsWithTag(jniInstallTag, func(jni android.Module) { + // Use the BaseModuleName of the dependency (without any prebuilt_ prefix) + bmn, _ := jni.(interface{ BaseModuleName() string }) + j.androidMkNamesOfJniLibs = append(j.androidMkNamesOfJniLibs, bmn.BaseModuleName()+":"+jni.Target().Arch.ArchType.Bitness()) + }) + // Check that native libraries are not listed in `required`. Prompt users to use `jni_libs` instead. + ctx.VisitDirectDepsWithTag(android.RequiredDepTag, func(dep android.Module) { + if _, hasSharedLibraryInfo := android.OtherModuleProvider(ctx, dep, cc.SharedLibraryInfoProvider); hasSharedLibraryInfo { + ctx.ModuleErrorf("cc_library %s is no longer supported in `required` of java_binary modules. Please use jni_libs instead.", dep.Name()) } + }) - // The host installation rules make the installed wrapper depend on all the dependencies - // of the wrapper variant, which will include the common variant's jar file and any JNI - // libraries. This is verified by TestBinary. - j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"), - ctx.ModuleName()+ext, j.wrapperFile) - - setOutputFiles(ctx, j.Library.Module) + // Compile the jar + if j.binaryProperties.Main_class != nil { + if j.properties.Manifest != nil { + ctx.PropertyErrorf("main_class", "main_class cannot be used when manifest is set") + } + manifestFile := android.PathForModuleOut(ctx, "manifest.txt") + GenerateMainClassManifest(ctx, manifestFile, String(j.binaryProperties.Main_class)) + j.overrideManifest = android.OptionalPathForPath(manifestFile) } + + j.Library.GenerateAndroidBuildActions(ctx) } func (j *Binary) DepsMutator(ctx android.BottomUpMutatorContext) { - if ctx.Arch().ArchType == android.Common { - j.deps(ctx) - } - if ctx.Arch().ArchType != android.Common { - // These dependencies ensure the host installation rules will install the jar file and - // the jni libraries when the wrapper is installed. - ctx.AddVariationDependencies(nil, jniInstallTag, j.binaryProperties.Jni_libs...) - ctx.AddVariationDependencies( - []blueprint.Variation{{Mutator: "arch", Variation: android.CommonArch.String()}}, - binaryInstallTag, ctx.ModuleName()) + j.deps(ctx) + // These dependencies ensure the installation rules will install the jar file when the + // wrapper is installed, and the jni libraries when the wrapper is installed. + if ctx.Os().Class == android.Host { + ctx.AddVariationDependencies(ctx.Config().BuildOSTarget.Variations(), jniInstallTag, j.binaryProperties.Jni_libs...) + } else if ctx.Os().Class == android.Device { + ctx.AddVariationDependencies(ctx.Config().AndroidFirstDeviceTarget.Variations(), jniInstallTag, j.binaryProperties.Jni_libs...) + } else { + ctx.ModuleErrorf("Unknown os class") } } @@ -1873,7 +1958,7 @@ func BinaryFactory() android.Module { module.Module.properties.Installable = proptools.BoolPtr(true) - android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommonFirst) + android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) android.InitDefaultableModule(module) return module @@ -1891,7 +1976,7 @@ func BinaryHostFactory() android.Module { module.Module.properties.Installable = proptools.BoolPtr(true) - android.InitAndroidArchModule(module, android.HostSupported, android.MultilibCommonFirst) + android.InitAndroidArchModule(module, android.HostSupported, android.MultilibCommon) android.InitDefaultableModule(module) return module } @@ -1975,17 +2060,11 @@ type JavaApiLibraryProperties struct { // List of shared java libs that this module has dependencies to and // should be passed as classpath in javac invocation - Libs []string + Libs proptools.Configurable[[]string] // List of java libs that this module has static dependencies to and will be // merge zipped after metalava invocation - Static_libs []string - - // Java Api library to provide the full API surface stub jar file. - // If this property is set, the stub jar of this module is created by - // extracting the compiled class files provided by the - // full_api_surface_stub module. - Full_api_surface_stub *string + Static_libs proptools.Configurable[[]string] // Version of previously released API file for compatibility check. Previous_api *string `android:"path"` @@ -2015,12 +2094,26 @@ type JavaApiLibraryProperties struct { // List of aconfig_declarations module names that the stubs generated in this module // depend on. Aconfig_declarations []string + + // List of hard coded filegroups containing Metalava config files that are passed to every + // Metalava invocation that this module performs. See addMetalavaConfigFilesToCmd. + ConfigFiles []string `android:"path" blueprint:"mutated"` + + // If not blank, set to the version of the sdk to compile against. + // Defaults to an empty string, which compiles the module against the private platform APIs. + // Values are of one of the following forms: + // 1) numerical API level, "current", "none", or "core_platform" + // 2) An SDK kind with an API level: "<sdk kind>_<API level>" + // See build/soong/android/sdk_version.go for the complete and up to date list of SDK kinds. + // If the SDK kind is empty, it will be set to public. + Sdk_version *string } func ApiLibraryFactory() android.Module { module := &ApiLibrary{} - android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibCommon) module.AddProperties(&module.properties) + module.properties.ConfigFiles = getMetalavaConfigFilegroupReference() + android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibCommon) module.initModuleAndImport(module) android.InitDefaultableModule(module) return module @@ -2036,7 +2129,7 @@ func (al *ApiLibrary) StubsJar() android.Path { func metalavaStubCmd(ctx android.ModuleContext, rule *android.RuleBuilder, srcs android.Paths, homeDir android.WritablePath, - classpath android.Paths) *android.RuleBuilderCommand { + classpath android.Paths, configFiles android.Paths) *android.RuleBuilderCommand { rule.Command().Text("rm -rf").Flag(homeDir.String()) rule.Command().Text("mkdir -p").Flag(homeDir.String()) @@ -2075,6 +2168,8 @@ func metalavaStubCmd(ctx android.ModuleContext, rule *android.RuleBuilder, FlagWithArg("--hide ", "InvalidNullabilityOverride"). FlagWithArg("--hide ", "ChangedDefault") + addMetalavaConfigFilesToCmd(cmd, configFiles) + if len(classpath) == 0 { // The main purpose of the `--api-class-resolution api` option is to force metalava to ignore // classes on the classpath when an API file contains missing classes. However, as this command @@ -2110,40 +2205,6 @@ func (al *ApiLibrary) addValidation(ctx android.ModuleContext, cmd *android.Rule } } -// This method extracts the stub class files from the stub jar file provided -// from full_api_surface_stub module instead of compiling the srcjar generated from invoking metalava. -// This method is used because metalava can generate compilable from-text stubs only when -// the codebase encompasses all classes listed in the input API text file, and a class can extend -// a class that is not within the same API domain. -func (al *ApiLibrary) extractApiSrcs(ctx android.ModuleContext, rule *android.RuleBuilder, stubsDir android.OptionalPath, fullApiSurfaceStubJar android.Path) { - classFilesList := android.PathForModuleOut(ctx, "metalava", "classes.txt") - unzippedSrcJarDir := android.PathForModuleOut(ctx, "metalava", "unzipDir") - - rule.Command(). - BuiltTool("list_files"). - Text(stubsDir.String()). - FlagWithOutput("--out ", classFilesList). - FlagWithArg("--extensions ", ".java"). - FlagWithArg("--root ", unzippedSrcJarDir.String()). - Flag("--classes") - - rule.Command(). - Text("unzip"). - Flag("-q"). - Input(fullApiSurfaceStubJar). - FlagWithArg("-d ", unzippedSrcJarDir.String()) - - rule.Command(). - BuiltTool("soong_zip"). - Flag("-jar"). - Flag("-write_if_changed"). - Flag("-ignore_missing_files"). - Flag("-quiet"). - FlagWithArg("-C ", unzippedSrcJarDir.String()). - FlagWithInput("-l ", classFilesList). - FlagWithOutput("-o ", al.stubsJarWithoutStaticLibs) -} - func (al *ApiLibrary) DepsMutator(ctx android.BottomUpMutatorContext) { apiContributions := al.properties.Api_contributions addValidations := !ctx.Config().IsEnvTrue("DISABLE_STUB_VALIDATION") && @@ -2170,14 +2231,18 @@ func (al *ApiLibrary) DepsMutator(ctx android.BottomUpMutatorContext) { } } } - ctx.AddVariationDependencies(nil, libTag, al.properties.Libs...) - ctx.AddVariationDependencies(nil, staticLibTag, al.properties.Static_libs...) - if al.properties.Full_api_surface_stub != nil { - ctx.AddVariationDependencies(nil, depApiSrcsTag, String(al.properties.Full_api_surface_stub)) - } - if al.properties.System_modules != nil { - ctx.AddVariationDependencies(nil, systemModulesTag, String(al.properties.System_modules)) + if ctx.Device() { + sdkDep := decodeSdkDep(ctx, android.SdkContext(al)) + if sdkDep.useModule { + ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules) + ctx.AddVariationDependencies(nil, libTag, sdkDep.classpath...) + ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.bootclasspath...) + + } } + ctx.AddVariationDependencies(nil, libTag, al.properties.Libs.GetOrDefault(ctx, nil)...) + ctx.AddVariationDependencies(nil, staticLibTag, al.properties.Static_libs.GetOrDefault(ctx, nil)...) + for _, aconfigDeclarationsName := range al.properties.Aconfig_declarations { ctx.AddDependency(ctx.Module(), aconfigDeclarationTag, aconfigDeclarationsName) } @@ -2233,8 +2298,8 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { var srcFilesInfo []JavaApiImportInfo var classPaths android.Paths + var bootclassPaths android.Paths var staticLibs android.Paths - var depApiSrcsStubsJar android.Path var systemModulesPaths android.Paths ctx.VisitDirectDeps(func(dep android.Module) { tag := ctx.OtherModuleDependencyTag(dep) @@ -2246,17 +2311,24 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { } srcFilesInfo = append(srcFilesInfo, provider) case libTag: - provider, _ := android.OtherModuleProvider(ctx, dep, JavaInfoProvider) - classPaths = append(classPaths, provider.HeaderJars...) + if provider, ok := android.OtherModuleProvider(ctx, dep, JavaInfoProvider); ok { + classPaths = append(classPaths, provider.HeaderJars...) + al.aconfigProtoFiles = append(al.aconfigProtoFiles, provider.AconfigIntermediateCacheOutputPaths...) + } + case bootClasspathTag: + if provider, ok := android.OtherModuleProvider(ctx, dep, JavaInfoProvider); ok { + bootclassPaths = append(bootclassPaths, provider.HeaderJars...) + al.aconfigProtoFiles = append(al.aconfigProtoFiles, provider.AconfigIntermediateCacheOutputPaths...) + } case staticLibTag: - provider, _ := android.OtherModuleProvider(ctx, dep, JavaInfoProvider) - staticLibs = append(staticLibs, provider.HeaderJars...) - case depApiSrcsTag: - provider, _ := android.OtherModuleProvider(ctx, dep, JavaInfoProvider) - depApiSrcsStubsJar = provider.HeaderJars[0] + if provider, ok := android.OtherModuleProvider(ctx, dep, JavaInfoProvider); ok { + staticLibs = append(staticLibs, provider.HeaderJars...) + al.aconfigProtoFiles = append(al.aconfigProtoFiles, provider.AconfigIntermediateCacheOutputPaths...) + } case systemModulesTag: - module := dep.(SystemModulesProvider) - systemModulesPaths = append(systemModulesPaths, module.HeaderJars()...) + if sm, ok := android.OtherModuleProvider(ctx, dep, SystemModulesProvider); ok { + systemModulesPaths = append(systemModulesPaths, sm.HeaderJars...) + } case metalavaCurrentApiTimestampTag: if currentApiTimestampProvider, ok := dep.(currentApiTimestampProvider); ok { al.validationPaths = append(al.validationPaths, currentApiTimestampProvider.CurrentApiTimestamp()) @@ -2286,7 +2358,12 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { ctx.ModuleErrorf("Error: %s has an empty api file.", ctx.ModuleName()) } - cmd := metalavaStubCmd(ctx, rule, srcFiles, homeDir, systemModulesPaths) + configFiles := android.PathsForModuleSrc(ctx, al.properties.ConfigFiles) + + combinedPaths := append(([]android.Path)(nil), systemModulesPaths...) + combinedPaths = append(combinedPaths, classPaths...) + combinedPaths = append(combinedPaths, bootclassPaths...) + cmd := metalavaStubCmd(ctx, rule, srcFiles, homeDir, combinedPaths, configFiles) al.stubsFlags(ctx, cmd, stubsDir) @@ -2304,9 +2381,6 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { al.stubsJarWithoutStaticLibs = android.PathForModuleOut(ctx, "metalava", "stubs.jar") al.stubsJar = android.PathForModuleOut(ctx, ctx.ModuleName(), fmt.Sprintf("%s.jar", ctx.ModuleName())) - if depApiSrcsStubsJar != nil { - al.extractApiSrcs(ctx, rule, stubsDir, depApiSrcsStubsJar) - } rule.Command(). BuiltTool("soong_zip"). Flag("-write_if_changed"). @@ -2317,18 +2391,17 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { rule.Build("metalava", "metalava merged text") - if depApiSrcsStubsJar == nil { - var flags javaBuilderFlags - flags.javaVersion = getStubsJavaVersion() - flags.javacFlags = strings.Join(al.properties.Javacflags, " ") - flags.classpath = classpath(classPaths) - flags.bootClasspath = classpath(systemModulesPaths) + javacFlags := javaBuilderFlags{ + javaVersion: getStubsJavaVersion(), + javacFlags: strings.Join(al.properties.Javacflags, " "), + classpath: classpath(classPaths), + bootClasspath: classpath(append(systemModulesPaths, bootclassPaths...)), + } - annoSrcJar := android.PathForModuleOut(ctx, ctx.ModuleName(), "anno.srcjar") + annoSrcJar := android.PathForModuleOut(ctx, ctx.ModuleName(), "anno.srcjar") - TransformJavaToClasses(ctx, al.stubsJarWithoutStaticLibs, 0, android.Paths{}, - android.Paths{al.stubsSrcJar}, annoSrcJar, flags, android.Paths{}) - } + TransformJavaToClasses(ctx, al.stubsJarWithoutStaticLibs, 0, android.Paths{}, + android.Paths{al.stubsSrcJar}, annoSrcJar, javacFlags, android.Paths{}) builder := android.NewRuleBuilder(pctx, ctx) builder.Command(). @@ -2340,7 +2413,7 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { // compile stubs to .dex for hiddenapi processing dexParams := &compileDexParams{ - flags: javaBuilderFlags{}, + flags: javacFlags, sdkVersion: al.SdkVersion(ctx), minSdkVersion: al.MinSdkVersion(ctx), classesJar: al.stubsJar, @@ -2354,12 +2427,15 @@ func (al *ApiLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) { ctx.Phony(ctx.ModuleName(), al.stubsJar) - android.SetProvider(ctx, JavaInfoProvider, JavaInfo{ - HeaderJars: android.PathsIfNonNil(al.stubsJar), - ImplementationAndResourcesJars: android.PathsIfNonNil(al.stubsJar), - ImplementationJars: android.PathsIfNonNil(al.stubsJar), - AidlIncludeDirs: android.Paths{}, - StubsLinkType: Stubs, + android.SetProvider(ctx, JavaInfoProvider, &JavaInfo{ + HeaderJars: android.PathsIfNonNil(al.stubsJar), + LocalHeaderJars: android.PathsIfNonNil(al.stubsJar), + TransitiveStaticLibsHeaderJars: depset.New(depset.PREORDER, android.PathsIfNonNil(al.stubsJar), nil), + TransitiveStaticLibsImplementationJars: depset.New(depset.PREORDER, android.PathsIfNonNil(al.stubsJar), nil), + ImplementationAndResourcesJars: android.PathsIfNonNil(al.stubsJar), + ImplementationJars: android.PathsIfNonNil(al.stubsJar), + AidlIncludeDirs: android.Paths{}, + StubsLinkType: Stubs, // No aconfig libraries on api libraries }) } @@ -2376,19 +2452,56 @@ func (al *ApiLibrary) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap { return nil } -// java_api_library constitutes the sdk, and does not build against one +// Most java_api_library constitues the sdk, but there are some java_api_library that +// does not contribute to the api surface. Such modules are allowed to set sdk_version +// other than "none" func (al *ApiLibrary) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec { - return android.SdkSpecNone + return android.SdkSpecFrom(ctx, proptools.String(al.properties.Sdk_version)) } // java_api_library is always at "current". Return FutureApiLevel func (al *ApiLibrary) MinSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { - return android.FutureApiLevel + return al.SdkVersion(ctx).ApiLevel +} + +func (al *ApiLibrary) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.ApiLevel { + return al.SdkVersion(ctx).ApiLevel +} + +func (al *ApiLibrary) SystemModules() string { + return proptools.String(al.properties.System_modules) +} + +func (al *ApiLibrary) TargetSdkVersion(ctx android.EarlyModuleContext) android.ApiLevel { + return al.SdkVersion(ctx).ApiLevel +} + +func (al *ApiLibrary) IDEInfo(ctx android.BaseModuleContext, i *android.IdeInfo) { + i.Deps = append(i.Deps, al.ideDeps(ctx)...) + i.Libs = append(i.Libs, al.properties.Libs.GetOrDefault(ctx, nil)...) + i.Static_libs = append(i.Static_libs, al.properties.Static_libs.GetOrDefault(ctx, nil)...) + i.SrcJars = append(i.SrcJars, al.stubsSrcJar.String()) +} + +// deps of java_api_library for module_bp_java_deps.json +func (al *ApiLibrary) ideDeps(ctx android.BaseModuleContext) []string { + ret := []string{} + ret = append(ret, al.properties.Libs.GetOrDefault(ctx, nil)...) + ret = append(ret, al.properties.Static_libs.GetOrDefault(ctx, nil)...) + if proptools.StringDefault(al.properties.System_modules, "none") != "none" { + ret = append(ret, proptools.String(al.properties.System_modules)) + } + // Other non java_library dependencies like java_api_contribution are ignored for now. + return ret } // implement the following interfaces for hiddenapi processing var _ hiddenAPIModule = (*ApiLibrary)(nil) var _ UsesLibraryDependency = (*ApiLibrary)(nil) +var _ android.SdkContext = (*ApiLibrary)(nil) + +// implement the following interface for IDE completion. +var _ android.IDEInfo = (*ApiLibrary)(nil) // // Java prebuilts @@ -2418,7 +2531,7 @@ type ImportProperties struct { Libs []string // List of static java libs that this module has dependencies to - Static_libs []string + Static_libs proptools.Configurable[[]string] // List of files to remove from the jar file(s) Exclude_files []string @@ -2546,20 +2659,9 @@ func (a *Import) JacocoReportClassesFile() android.Path { return nil } -func (j *Import) LintDepSets() LintDepSets { - return LintDepSets{} -} - -func (j *Import) getStrictUpdatabilityLinting() bool { - return false -} - -func (j *Import) setStrictUpdatabilityLinting(bool) { -} - func (j *Import) DepsMutator(ctx android.BottomUpMutatorContext) { ctx.AddVariationDependencies(nil, libTag, j.properties.Libs...) - ctx.AddVariationDependencies(nil, staticLibTag, j.properties.Static_libs...) + ctx.AddVariationDependencies(nil, staticLibTag, j.properties.Static_libs.GetOrDefault(ctx, nil)...) if ctx.Device() && Bool(j.dexProperties.Compile_dex) { sdkDeps(ctx, android.SdkContext(j), j.dexer) @@ -2593,8 +2695,15 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { var flags javaBuilderFlags - j.collectTransitiveHeaderJars(ctx) + var transitiveClasspathHeaderJars []depset.DepSet[android.Path] + var transitiveBootClasspathHeaderJars []depset.DepSet[android.Path] + var transitiveStaticLibsHeaderJars []depset.DepSet[android.Path] + var transitiveStaticLibsImplementationJars []depset.DepSet[android.Path] + var transitiveStaticLibsResourceJars []depset.DepSet[android.Path] + + j.collectTransitiveHeaderJarsForR8(ctx) var staticJars android.Paths + var staticResourceJars android.Paths var staticHeaderJars android.Paths ctx.VisitDirectDeps(func(module android.Module) { tag := ctx.OtherModuleDependencyTag(module) @@ -2603,107 +2712,146 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { case libTag, sdkLibTag: flags.classpath = append(flags.classpath, dep.HeaderJars...) flags.dexClasspath = append(flags.dexClasspath, dep.HeaderJars...) + transitiveClasspathHeaderJars = append(transitiveClasspathHeaderJars, dep.TransitiveStaticLibsHeaderJars) case staticLibTag: flags.classpath = append(flags.classpath, dep.HeaderJars...) - staticJars = append(staticJars, dep.ImplementationAndResourcesJars...) + staticJars = append(staticJars, dep.ImplementationJars...) + staticResourceJars = append(staticResourceJars, dep.ResourceJars...) staticHeaderJars = append(staticHeaderJars, dep.HeaderJars...) + transitiveClasspathHeaderJars = append(transitiveClasspathHeaderJars, dep.TransitiveStaticLibsHeaderJars) + transitiveStaticLibsHeaderJars = append(transitiveStaticLibsHeaderJars, dep.TransitiveStaticLibsHeaderJars) + transitiveStaticLibsImplementationJars = append(transitiveStaticLibsImplementationJars, dep.TransitiveStaticLibsImplementationJars) + transitiveStaticLibsResourceJars = append(transitiveStaticLibsResourceJars, dep.TransitiveStaticLibsResourceJars) case bootClasspathTag: flags.bootClasspath = append(flags.bootClasspath, dep.HeaderJars...) + transitiveBootClasspathHeaderJars = append(transitiveBootClasspathHeaderJars, dep.TransitiveStaticLibsHeaderJars) } - } else if dep, ok := module.(SdkLibraryDependency); ok { + } else if _, ok := android.OtherModuleProvider(ctx, module, SdkLibraryInfoProvider); ok { switch tag { case libTag, sdkLibTag: - flags.classpath = append(flags.classpath, dep.SdkHeaderJars(ctx, j.SdkVersion(ctx))...) + sdkInfo, _ := android.OtherModuleProvider(ctx, module, SdkLibraryInfoProvider) + generatingLibsString := android.PrettyConcat( + getGeneratingLibs(ctx, j.SdkVersion(ctx), module.Name(), sdkInfo), true, "or") + ctx.ModuleErrorf("cannot depend directly on java_sdk_library %q; try depending on %s instead", module.Name(), generatingLibsString) } } addCLCFromDep(ctx, module, j.classLoaderContexts) }) - jars := android.PathsForModuleSrc(ctx, j.properties.Jars) + localJars := android.PathsForModuleSrc(ctx, j.properties.Jars) jarName := j.Stem() + ".jar" + // Combine only the local jars together for use in transitive classpaths. + // Always pass input jar through TransformJarsToJar to strip module-info.class from prebuilts. + localCombinedHeaderJar := android.PathForModuleOut(ctx, "local-combined", jarName) + TransformJarsToJar(ctx, localCombinedHeaderJar, "combine local prebuilt implementation jars", localJars, android.OptionalPath{}, + false, j.properties.Exclude_files, j.properties.Exclude_dirs) + localStrippedJars := android.Paths{localCombinedHeaderJar} + + completeStaticLibsHeaderJars := depset.New(depset.PREORDER, localStrippedJars, transitiveStaticLibsHeaderJars) + completeStaticLibsImplementationJars := depset.New(depset.PREORDER, localStrippedJars, transitiveStaticLibsImplementationJars) + completeStaticLibsResourceJars := depset.New(depset.PREORDER, nil, transitiveStaticLibsResourceJars) + // Always pass the input jars to TransformJarsToJar, even if there is only a single jar, we need the output // file of the module to be named jarName. - outputFile := android.PathForModuleOut(ctx, "combined", jarName) - implementationJars := append(slices.Clone(jars), staticJars...) - TransformJarsToJar(ctx, outputFile, "combine prebuilt implementation jars", implementationJars, android.OptionalPath{}, + var outputFile android.Path + combinedImplementationJar := android.PathForModuleOut(ctx, "combined", jarName) + var implementationJars android.Paths + if ctx.Config().UseTransitiveJarsInClasspath() { + implementationJars = completeStaticLibsImplementationJars.ToList() + } else { + implementationJars = append(slices.Clone(localJars), staticJars...) + } + TransformJarsToJar(ctx, combinedImplementationJar, "combine prebuilt implementation jars", implementationJars, android.OptionalPath{}, false, j.properties.Exclude_files, j.properties.Exclude_dirs) + outputFile = combinedImplementationJar // If no dependencies have separate header jars then there is no need to create a separate // header jar for this module. reuseImplementationJarAsHeaderJar := slices.Equal(staticJars, staticHeaderJars) - var headerOutputFile android.ModuleOutPath + var resourceJarFile android.Path + if len(staticResourceJars) > 1 { + combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName) + TransformJarsToJar(ctx, combinedJar, "for resources", staticResourceJars, android.OptionalPath{}, + false, nil, nil) + resourceJarFile = combinedJar + } else if len(staticResourceJars) == 1 { + resourceJarFile = staticResourceJars[0] + } + + var headerJar android.Path if reuseImplementationJarAsHeaderJar { - headerOutputFile = outputFile + headerJar = outputFile } else { - headerJars := append(slices.Clone(jars), staticHeaderJars...) - headerOutputFile = android.PathForModuleOut(ctx, "turbine-combined", jarName) + var headerJars android.Paths + if ctx.Config().UseTransitiveJarsInClasspath() { + headerJars = completeStaticLibsHeaderJars.ToList() + } else { + headerJars = append(slices.Clone(localJars), staticHeaderJars...) + } + headerOutputFile := android.PathForModuleOut(ctx, "turbine-combined", jarName) TransformJarsToJar(ctx, headerOutputFile, "combine prebuilt header jars", headerJars, android.OptionalPath{}, false, j.properties.Exclude_files, j.properties.Exclude_dirs) + headerJar = headerOutputFile } if Bool(j.properties.Jetifier) { - inputFile := outputFile - outputFile = android.PathForModuleOut(ctx, "jetifier", jarName) - TransformJetifier(ctx, outputFile, inputFile) + jetifierOutputFile := android.PathForModuleOut(ctx, "jetifier", jarName) + TransformJetifier(ctx, jetifierOutputFile, outputFile) + outputFile = jetifierOutputFile if !reuseImplementationJarAsHeaderJar { - headerInputFile := headerOutputFile - headerOutputFile = android.PathForModuleOut(ctx, "jetifier-headers", jarName) - TransformJetifier(ctx, headerOutputFile, headerInputFile) + jetifierHeaderJar := android.PathForModuleOut(ctx, "jetifier-headers", jarName) + TransformJetifier(ctx, jetifierHeaderJar, headerJar) + headerJar = jetifierHeaderJar } else { - headerOutputFile = outputFile + headerJar = outputFile } + + // Enabling jetifier requires modifying classes from transitive dependencies, disable transitive + // classpath and use the combined header jar instead. + completeStaticLibsHeaderJars = depset.New(depset.PREORDER, android.Paths{headerJar}, nil) + completeStaticLibsImplementationJars = depset.New(depset.PREORDER, android.Paths{outputFile}, nil) + } + + implementationJarFile := outputFile + + // merge implementation jar with resources if necessary + if resourceJarFile != nil { + jars := android.Paths{resourceJarFile, outputFile} + combinedJar := android.PathForModuleOut(ctx, "withres", jarName) + TransformJarsToJar(ctx, combinedJar, "for resources", jars, android.OptionalPath{}, + false, nil, nil) + outputFile = combinedJar } // Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource. // Also strip the relative path from the header output file so that the reuseImplementationJarAsHeaderJar check // in a module that depends on this module considers them equal. - j.combinedHeaderFile = headerOutputFile.WithoutRel() + j.combinedHeaderFile = headerJar.WithoutRel() j.combinedImplementationFile = outputFile.WithoutRel() j.maybeInstall(ctx, jarName, outputFile) j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.properties.Aidl.Export_include_dirs) + if ctx.Config().UseTransitiveJarsInClasspath() { + ctx.CheckbuildFile(localJars...) + } else { + ctx.CheckbuildFile(outputFile) + } + if ctx.Device() { - // If this is a variant created for a prebuilt_apex then use the dex implementation jar - // obtained from the associated deapexer module. + // Shared libraries deapexed from prebuilt apexes are no longer supported. + // Set the dexJarBuildPath to a fake path. + // This allows soong analysis pass, but will be an error during ninja execution if there are + // any rdeps. ai, _ := android.ModuleProvider(ctx, android.ApexInfoProvider) if ai.ForPrebuiltApex { - // Get the path of the dex implementation jar from the `deapexer` module. - di, err := android.FindDeapexerProviderForModule(ctx) - if err != nil { - // An error was found, possibly due to multiple apexes in the tree that export this library - // Defer the error till a client tries to call DexJarBuildPath - j.dexJarFileErr = err - j.initHiddenAPIError(err) - return - } - dexJarFileApexRootRelative := ApexRootRelativePathToJavaLib(j.BaseModuleName()) - if dexOutputPath := di.PrebuiltExportPath(dexJarFileApexRootRelative); dexOutputPath != nil { - dexJarFile := makeDexJarPathFromPath(dexOutputPath) - j.dexJarFile = dexJarFile - installPath := android.PathForModuleInPartitionInstall(ctx, "apex", ai.ApexVariationName, ApexRootRelativePathToJavaLib(j.BaseModuleName())) - j.dexJarInstallFile = installPath - - j.dexpreopter.installPath = j.dexpreopter.getInstallPath(ctx, android.RemoveOptionalPrebuiltPrefix(ctx.ModuleName()), installPath) - setUncompressDex(ctx, &j.dexpreopter, &j.dexer) - j.dexpreopter.uncompressedDex = *j.dexProperties.Uncompress_dex - - if profilePath := di.PrebuiltExportPath(dexJarFileApexRootRelative + ".prof"); profilePath != nil { - j.dexpreopter.inputProfilePathOnHost = profilePath - } - - // Initialize the hiddenapi structure. - j.initHiddenAPI(ctx, dexJarFile, outputFile, j.dexProperties.Uncompress_dex) - } else { - // This should never happen as a variant for a prebuilt_apex is only created if the - // prebuilt_apex has been configured to export the java library dex file. - ctx.ModuleErrorf("internal error: no dex implementation jar available from prebuilt APEX %s", di.ApexModuleName()) - } + j.dexJarFile = makeDexJarPathFromPath(android.PathForModuleInstall(ctx, "intentionally_no_longer_supported")) + j.initHiddenAPI(ctx, j.dexJarFile, outputFile, j.dexProperties.Uncompress_dex) } else if Bool(j.dexProperties.Compile_dex) { sdkDep := decodeSdkDep(ctx, android.SdkContext(j)) if sdkDep.invalidVersion { @@ -2721,7 +2869,7 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { setUncompressDex(ctx, &j.dexpreopter, &j.dexer) j.dexpreopter.uncompressedDex = *j.dexProperties.Uncompress_dex - var dexOutputFile android.OutputPath + var dexOutputFile android.Path dexParams := &compileDexParams{ flags: flags, sdkVersion: j.SdkVersion(ctx), @@ -2734,6 +2882,7 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { if ctx.Failed() { return } + ctx.CheckbuildFile(dexOutputFile) // Initialize the hiddenapi structure. j.initHiddenAPI(ctx, makeDexJarPathFromPath(dexOutputFile), outputFile, j.dexProperties.Uncompress_dex) @@ -2746,14 +2895,19 @@ func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) { } } - android.SetProvider(ctx, JavaInfoProvider, JavaInfo{ - HeaderJars: android.PathsIfNonNil(j.combinedHeaderFile), - TransitiveLibsHeaderJars: j.transitiveLibsHeaderJars, - TransitiveStaticLibsHeaderJars: j.transitiveStaticLibsHeaderJars, - ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedImplementationFile), - ImplementationJars: android.PathsIfNonNil(j.combinedImplementationFile), - AidlIncludeDirs: j.exportAidlIncludeDirs, - StubsLinkType: j.stubsLinkType, + android.SetProvider(ctx, JavaInfoProvider, &JavaInfo{ + HeaderJars: android.PathsIfNonNil(j.combinedHeaderFile), + LocalHeaderJars: android.PathsIfNonNil(j.combinedHeaderFile), + TransitiveLibsHeaderJarsForR8: j.transitiveLibsHeaderJarsForR8, + TransitiveStaticLibsHeaderJarsForR8: j.transitiveStaticLibsHeaderJarsForR8, + TransitiveStaticLibsHeaderJars: completeStaticLibsHeaderJars, + TransitiveStaticLibsImplementationJars: completeStaticLibsImplementationJars, + TransitiveStaticLibsResourceJars: completeStaticLibsResourceJars, + ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedImplementationFile), + ImplementationJars: android.PathsIfNonNil(implementationJarFile.WithoutRel()), + ResourceJars: android.PathsIfNonNil(resourceJarFile), + AidlIncludeDirs: j.exportAidlIncludeDirs, + StubsLinkType: j.stubsLinkType, // TODO(b/289117800): LOCAL_ACONFIG_FILES for prebuilts }) @@ -2805,8 +2959,8 @@ func (j *Import) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap { var _ android.ApexModule = (*Import)(nil) // Implements android.ApexModule -func (j *Import) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool { - return j.depIsInSameApex(ctx, dep) +func (j *Import) OutgoingDepIsInSameApex(tag blueprint.DependencyTag) bool { + return j.depIsInSameApex(tag) } // Implements android.ApexModule @@ -2865,8 +3019,8 @@ var _ android.IDECustomizedModuleName = (*Import)(nil) // Collect information for opening IDE project files in java/jdeps.go. -func (j *Import) IDEInfo(dpInfo *android.IdeInfo) { - dpInfo.Jars = append(dpInfo.Jars, j.PrebuiltSrcs()...) +func (j *Import) IDEInfo(ctx android.BaseModuleContext, dpInfo *android.IdeInfo) { + dpInfo.Jars = append(dpInfo.Jars, j.combinedHeaderFile.String()) } func (j *Import) IDECustomizedModuleName() string { @@ -2970,21 +3124,10 @@ func (a *DexImport) JacocoReportClassesFile() android.Path { return nil } -func (a *DexImport) LintDepSets() LintDepSets { - return LintDepSets{} -} - func (j *DexImport) IsInstallable() bool { return true } -func (j *DexImport) getStrictUpdatabilityLinting() bool { - return false -} - -func (j *DexImport) setStrictUpdatabilityLinting(bool) { -} - func (j *DexImport) GenerateAndroidBuildActions(ctx android.ModuleContext) { if len(j.properties.Jars) != 1 { ctx.PropertyErrorf("jars", "exactly one jar must be provided") @@ -3139,6 +3282,7 @@ func DefaultsFactory() android.Module { &JavaApiLibraryProperties{}, &bootclasspathFragmentProperties{}, &SourceOnlyBootclasspathProperties{}, + &ravenwoodTestProperties{}, ) android.InitDefaultsModule(module) @@ -3154,15 +3298,20 @@ type kytheExtractJavaSingleton struct { func (ks *kytheExtractJavaSingleton) GenerateBuildActions(ctx android.SingletonContext) { var xrefTargets android.Paths + var xrefKotlinTargets android.Paths ctx.VisitAllModules(func(module android.Module) { if javaModule, ok := module.(xref); ok { xrefTargets = append(xrefTargets, javaModule.XrefJavaFiles()...) + xrefKotlinTargets = append(xrefKotlinTargets, javaModule.XrefKotlinFiles()...) } }) // TODO(asmundak): perhaps emit a rule to output a warning if there were no xrefTargets if len(xrefTargets) > 0 { ctx.Phony("xref_java", xrefTargets...) } + if len(xrefKotlinTargets) > 0 { + ctx.Phony("xref_kotlin", xrefKotlinTargets...) + } } var Bool = proptools.Bool @@ -3182,9 +3331,13 @@ func addCLCFromDep(ctx android.ModuleContext, depModule android.Module, depName := android.RemoveOptionalPrebuiltPrefix(ctx.OtherModuleName(depModule)) var sdkLib *string - if lib, ok := depModule.(SdkLibraryDependency); ok && lib.sharedLibrary() { + if lib, ok := android.OtherModuleProvider(ctx, depModule, SdkLibraryInfoProvider); ok && lib.SharedLibrary { // A shared SDK library. This should be added as a top-level CLC element. sdkLib = &depName + } else if lib, ok := depModule.(SdkLibraryComponentDependency); ok && lib.OptionalSdkLibraryImplementation() != nil { + if depModule.Name() == proptools.String(lib.OptionalSdkLibraryImplementation())+".impl" { + sdkLib = lib.OptionalSdkLibraryImplementation() + } } else if ulib, ok := depModule.(ProvidesUsesLib); ok { // A non-SDK library disguised as an SDK library by the means of `provides_uses_lib` // property. This should be handled in the same way as a shared SDK library. @@ -3215,7 +3368,7 @@ func addCLCFromDep(ctx android.ModuleContext, depModule android.Module, if sdkLib != nil { optional := false if module, ok := ctx.Module().(ModuleWithUsesLibrary); ok { - if android.InList(*sdkLib, module.UsesLibrary().usesLibraryProperties.Optional_uses_libs) { + if android.InList(*sdkLib, module.UsesLibrary().usesLibraryProperties.Optional_uses_libs.GetOrDefault(ctx, nil)) { optional = true } } |