blob: f4ec04ef42b30f6f5bd92f66fca7f4e0d4baae2f [file] [log] [blame]
Colin Cross2fe66872015-03-30 17:20:39 -07001// Copyright 2015 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package java
16
17// This file contains the module types for compiling Java for Android, and converts the properties
Colin Cross46c9b8b2017-06-22 16:51:17 -070018// into the flags and filenames necessary to pass to the Module. The final creation of the rules
Colin Cross2fe66872015-03-30 17:20:39 -070019// is handled in builder.go
20
21import (
Colin Crossf19b9bb2018-03-26 14:42:44 -070022 "fmt"
Colin Crossfc3674a2017-09-18 17:41:52 -070023 "path/filepath"
Wei Libafb6d62021-12-10 03:14:59 -080024 "strings"
Colin Cross2fe66872015-03-30 17:20:39 -070025
Wei Libafb6d62021-12-10 03:14:59 -080026 "android/soong/bazel"
Sam Delmerico277795c2022-02-25 17:04:37 +000027 "android/soong/bazel/cquery"
Sam Delmerico4e272292022-01-06 20:03:51 +000028
Colin Cross2fe66872015-03-30 17:20:39 -070029 "github.com/google/blueprint"
Colin Cross76b5f0c2017-08-29 16:02:06 -070030 "github.com/google/blueprint/proptools"
Colin Cross2fe66872015-03-30 17:20:39 -070031
Colin Cross635c3b02016-05-18 15:37:25 -070032 "android/soong/android"
Colin Crossf8d9c492021-01-26 11:01:43 -080033 "android/soong/cc"
Ulya Trafimovich31e444e2020-08-14 17:32:16 +010034 "android/soong/dexpreopt"
Colin Cross3e3e72d2017-06-22 17:20:19 -070035 "android/soong/java/config"
Colin Cross303e21f2018-08-07 16:49:25 -070036 "android/soong/tradefed"
Colin Cross2fe66872015-03-30 17:20:39 -070037)
38
Colin Cross463a90e2015-06-17 14:20:06 -070039func init() {
Paul Duffin535e0a12021-03-30 23:34:32 +010040 registerJavaBuildComponents(android.InitRegistrationContext)
Paul Duffin255f18e2019-12-13 11:22:16 +000041
Jaewoong Jungbc15e3a2021-03-10 17:02:43 -080042 RegisterJavaSdkMemberTypes()
43}
44
Paul Duffin535e0a12021-03-30 23:34:32 +010045func registerJavaBuildComponents(ctx android.RegistrationContext) {
Jaewoong Jungbc15e3a2021-03-10 17:02:43 -080046 ctx.RegisterModuleType("java_defaults", DefaultsFactory)
47
48 ctx.RegisterModuleType("java_library", LibraryFactory)
49 ctx.RegisterModuleType("java_library_static", LibraryStaticFactory)
50 ctx.RegisterModuleType("java_library_host", LibraryHostFactory)
51 ctx.RegisterModuleType("java_binary", BinaryFactory)
52 ctx.RegisterModuleType("java_binary_host", BinaryHostFactory)
53 ctx.RegisterModuleType("java_test", TestFactory)
54 ctx.RegisterModuleType("java_test_helper_library", TestHelperLibraryFactory)
55 ctx.RegisterModuleType("java_test_host", TestHostFactory)
56 ctx.RegisterModuleType("java_test_import", JavaTestImportFactory)
57 ctx.RegisterModuleType("java_import", ImportFactory)
58 ctx.RegisterModuleType("java_import_host", ImportFactoryHost)
59 ctx.RegisterModuleType("java_device_for_host", DeviceForHostFactory)
60 ctx.RegisterModuleType("java_host_for_device", HostForDeviceFactory)
61 ctx.RegisterModuleType("dex_import", DexImportFactory)
62
Martin Stjernholm0e4cceb2021-05-13 02:38:35 +010063 // This mutator registers dependencies on dex2oat for modules that should be
64 // dexpreopted. This is done late when the final variants have been
65 // established, to not get the dependencies split into the wrong variants and
66 // to support the checks in dexpreoptDisabled().
Jaewoong Jungbc15e3a2021-03-10 17:02:43 -080067 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
68 ctx.BottomUp("dexpreopt_tool_deps", dexpreoptToolDepsMutator).Parallel()
69 })
70
71 ctx.RegisterSingletonType("logtags", LogtagsSingleton)
72 ctx.RegisterSingletonType("kythe_java_extract", kytheExtractJavaFactory)
73}
74
75func RegisterJavaSdkMemberTypes() {
Paul Duffin255f18e2019-12-13 11:22:16 +000076 // Register sdk member types.
Paul Duffin7b81f5e2020-01-13 21:03:22 +000077 android.RegisterSdkMemberType(javaHeaderLibsSdkMemberType)
Paul Duffin2da04242021-04-23 19:43:28 +010078 android.RegisterSdkMemberType(javaLibsSdkMemberType)
79 android.RegisterSdkMemberType(javaBootLibsSdkMemberType)
Jiakai Zhangea180332021-09-26 08:58:02 +000080 android.RegisterSdkMemberType(javaSystemserverLibsSdkMemberType)
Paul Duffin2da04242021-04-23 19:43:28 +010081 android.RegisterSdkMemberType(javaTestSdkMemberType)
82}
83
84var (
85 // Supports adding java header libraries to module_exports and sdk.
86 javaHeaderLibsSdkMemberType = &librarySdkMemberType{
87 android.SdkMemberTypeBase{
88 PropertyName: "java_header_libs",
89 SupportsSdk: true,
90 },
91 func(_ android.SdkMemberContext, j *Library) android.Path {
92 headerJars := j.HeaderJars()
93 if len(headerJars) != 1 {
94 panic(fmt.Errorf("there must be only one header jar from %q", j.Name()))
95 }
96
97 return headerJars[0]
98 },
99 sdkSnapshotFilePathForJar,
100 copyEverythingToSnapshot,
101 }
Paul Duffin255f18e2019-12-13 11:22:16 +0000102
Paul Duffin22ff0aa2021-02-04 11:15:34 +0000103 // Export implementation classes jar as part of the sdk.
Paul Duffin2da04242021-04-23 19:43:28 +0100104 exportImplementationClassesJar = func(_ android.SdkMemberContext, j *Library) android.Path {
Paul Duffin22ff0aa2021-02-04 11:15:34 +0000105 implementationJars := j.ImplementationAndResourcesJars()
106 if len(implementationJars) != 1 {
107 panic(fmt.Errorf("there must be only one implementation jar from %q", j.Name()))
108 }
109 return implementationJars[0]
110 }
111
Paul Duffin2da04242021-04-23 19:43:28 +0100112 // Supports adding java implementation libraries to module_exports but not sdk.
113 javaLibsSdkMemberType = &librarySdkMemberType{
Paul Duffinf5c0a9c2020-02-28 14:39:53 +0000114 android.SdkMemberTypeBase{
115 PropertyName: "java_libs",
116 },
Paul Duffin22ff0aa2021-02-04 11:15:34 +0000117 exportImplementationClassesJar,
Paul Duffindb170e42020-12-08 17:48:25 +0000118 sdkSnapshotFilePathForJar,
119 copyEverythingToSnapshot,
Paul Duffin2da04242021-04-23 19:43:28 +0100120 }
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000121
Paul Duffin13648912022-07-15 13:12:35 +0000122 snapshotRequiresImplementationJar = func(ctx android.SdkMemberContext) bool {
123 // In the S build the build will break if updatable-media does not provide a full implementation
124 // jar. That issue was fixed in Tiramisu by b/229932396.
125 if ctx.IsTargetBuildBeforeTiramisu() && ctx.Name() == "updatable-media" {
126 return true
127 }
128
129 return false
130 }
131
Paul Duffin2da04242021-04-23 19:43:28 +0100132 // Supports adding java boot libraries to module_exports and sdk.
Paul Duffindb170e42020-12-08 17:48:25 +0000133 //
134 // The build has some implicit dependencies (via the boot jars configuration) on a number of
135 // modules, e.g. core-oj, apache-xml, that are part of the java boot class path and which are
136 // provided by mainline modules (e.g. art, conscrypt, runtime-i18n) but which are not otherwise
137 // used outside those mainline modules.
138 //
139 // As they are not needed outside the mainline modules adding them to the sdk/module-exports as
140 // either java_libs, or java_header_libs would end up exporting more information than was strictly
141 // necessary. The java_boot_libs property to allow those modules to be exported as part of the
142 // sdk/module_exports without exposing any unnecessary information.
Paul Duffin2da04242021-04-23 19:43:28 +0100143 javaBootLibsSdkMemberType = &librarySdkMemberType{
Paul Duffindb170e42020-12-08 17:48:25 +0000144 android.SdkMemberTypeBase{
145 PropertyName: "java_boot_libs",
146 SupportsSdk: true,
147 },
Paul Duffin5c211452021-07-15 12:42:44 +0100148 func(ctx android.SdkMemberContext, j *Library) android.Path {
Paul Duffin13648912022-07-15 13:12:35 +0000149 if snapshotRequiresImplementationJar(ctx) {
150 return exportImplementationClassesJar(ctx, j)
151 }
152
Paul Duffin5c211452021-07-15 12:42:44 +0100153 // Java boot libs are only provided in the SDK to provide access to their dex implementation
154 // jar for use by dexpreopting and boot jars package check. They do not need to provide an
155 // actual implementation jar but the java_import will need a file that exists so just copy an
156 // empty file. Any attempt to use that file as a jar will cause a build error.
157 return ctx.SnapshotBuilder().EmptyFile()
158 },
Paul Duffin13648912022-07-15 13:12:35 +0000159 func(ctx android.SdkMemberContext, osPrefix, name string) string {
160 if snapshotRequiresImplementationJar(ctx) {
161 return sdkSnapshotFilePathForJar(ctx, osPrefix, name)
162 }
163
Paul Duffin5c211452021-07-15 12:42:44 +0100164 // Create a special name for the implementation jar to try and provide some useful information
165 // to a developer that attempts to compile against this.
166 // TODO(b/175714559): Provide a proper error message in Soong not ninja.
167 return filepath.Join(osPrefix, "java_boot_libs", "snapshot", "jars", "are", "invalid", name+jarFileSuffix)
168 },
Paul Duffindb170e42020-12-08 17:48:25 +0000169 onlyCopyJarToSnapshot,
Paul Duffin2da04242021-04-23 19:43:28 +0100170 }
Paul Duffindb170e42020-12-08 17:48:25 +0000171
Jiakai Zhangea180332021-09-26 08:58:02 +0000172 // Supports adding java systemserver libraries to module_exports and sdk.
173 //
174 // The build has some implicit dependencies (via the systemserver jars configuration) on a number
175 // of modules that are part of the java systemserver classpath and which are provided by mainline
176 // modules but which are not otherwise used outside those mainline modules.
177 //
178 // As they are not needed outside the mainline modules adding them to the sdk/module-exports as
179 // either java_libs, or java_header_libs would end up exporting more information than was strictly
180 // necessary. The java_systemserver_libs property to allow those modules to be exported as part of
181 // the sdk/module_exports without exposing any unnecessary information.
182 javaSystemserverLibsSdkMemberType = &librarySdkMemberType{
183 android.SdkMemberTypeBase{
184 PropertyName: "java_systemserver_libs",
185 SupportsSdk: true,
Paul Duffinf861df72022-07-01 15:56:06 +0000186
187 // This was only added in Tiramisu.
188 SupportedBuildReleaseSpecification: "Tiramisu+",
Jiakai Zhangea180332021-09-26 08:58:02 +0000189 },
190 func(ctx android.SdkMemberContext, j *Library) android.Path {
191 // Java systemserver libs are only provided in the SDK to provide access to their dex
192 // implementation jar for use by dexpreopting. They do not need to provide an actual
193 // implementation jar but the java_import will need a file that exists so just copy an empty
194 // file. Any attempt to use that file as a jar will cause a build error.
195 return ctx.SnapshotBuilder().EmptyFile()
196 },
Paul Duffin13648912022-07-15 13:12:35 +0000197 func(_ android.SdkMemberContext, osPrefix, name string) string {
Jiakai Zhangea180332021-09-26 08:58:02 +0000198 // Create a special name for the implementation jar to try and provide some useful information
199 // to a developer that attempts to compile against this.
200 // TODO(b/175714559): Provide a proper error message in Soong not ninja.
201 return filepath.Join(osPrefix, "java_systemserver_libs", "snapshot", "jars", "are", "invalid", name+jarFileSuffix)
202 },
203 onlyCopyJarToSnapshot,
204 }
205
Paul Duffin2da04242021-04-23 19:43:28 +0100206 // Supports adding java test libraries to module_exports but not sdk.
207 javaTestSdkMemberType = &testSdkMemberType{
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000208 SdkMemberTypeBase: android.SdkMemberTypeBase{
209 PropertyName: "java_tests",
210 },
Paul Duffin2da04242021-04-23 19:43:28 +0100211 }
212)
Jeongik Cha538c0d02019-07-11 15:54:27 +0900213
Colin Crossdcf71b22021-02-01 13:59:03 -0800214// JavaInfo contains information about a java module for use by modules that depend on it.
215type JavaInfo struct {
216 // HeaderJars is a list of jars that can be passed as the javac classpath in order to link
217 // against this module. If empty, ImplementationJars should be used instead.
218 HeaderJars android.Paths
219
220 // ImplementationAndResourceJars is a list of jars that contain the implementations of classes
221 // in the module as well as any resources included in the module.
222 ImplementationAndResourcesJars android.Paths
223
224 // ImplementationJars is a list of jars that contain the implementations of classes in the
225 //module.
226 ImplementationJars android.Paths
227
228 // ResourceJars is a list of jars that contain the resources included in the module.
229 ResourceJars android.Paths
230
231 // AidlIncludeDirs is a list of directories that should be passed to the aidl tool when
232 // depending on this module.
233 AidlIncludeDirs android.Paths
234
235 // SrcJarArgs is a list of arguments to pass to soong_zip to package the sources of this
236 // module.
237 SrcJarArgs []string
238
239 // SrcJarDeps is a list of paths to depend on when packaging the sources of this module.
240 SrcJarDeps android.Paths
241
242 // ExportedPlugins is a list of paths that should be used as annotation processors for any
243 // module that depends on this module.
244 ExportedPlugins android.Paths
245
246 // ExportedPluginClasses is a list of classes that should be run as annotation processors for
247 // any module that depends on this module.
248 ExportedPluginClasses []string
249
250 // ExportedPluginDisableTurbine is true if this module's annotation processors generate APIs,
251 // requiring disbling turbine for any modules that depend on it.
252 ExportedPluginDisableTurbine bool
253
254 // JacocoReportClassesFile is the path to a jar containing uninstrumented classes that will be
255 // instrumented by jacoco.
256 JacocoReportClassesFile android.Path
257}
258
259var JavaInfoProvider = blueprint.NewProvider(JavaInfo{})
260
Colin Cross75ce9ec2021-02-26 16:20:32 -0800261// SyspropPublicStubInfo contains info about the sysprop public stub library that corresponds to
262// the sysprop implementation library.
263type SyspropPublicStubInfo struct {
264 // JavaInfo is the JavaInfoProvider of the sysprop public stub library that corresponds to
265 // the sysprop implementation library.
266 JavaInfo JavaInfo
267}
268
269var SyspropPublicStubInfoProvider = blueprint.NewProvider(SyspropPublicStubInfo{})
270
Paul Duffin44b481b2020-06-17 16:59:43 +0100271// Methods that need to be implemented for a module that is added to apex java_libs property.
272type ApexDependency interface {
Nan Zhanged19fc32017-10-19 13:06:22 -0700273 HeaderJars() android.Paths
Paul Duffin44b481b2020-06-17 16:59:43 +0100274 ImplementationAndResourcesJars() android.Paths
275}
276
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100277// Provides build path and install path to DEX jars.
278type UsesLibraryDependency interface {
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +0100279 DexJarBuildPath() OptionalDexJarPath
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +0100280 DexJarInstallPath() android.Path
Ulya Trafimovichdbf31662020-12-17 12:07:54 +0000281 ClassLoaderContexts() dexpreopt.ClassLoaderContextMap
Ulya Trafimovich31e444e2020-08-14 17:32:16 +0100282}
283
Jaewoong Jung26342642021-03-17 15:56:23 -0700284// TODO(jungjw): Move this to kythe.go once it's created.
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800285type xref interface {
286 XrefJavaFiles() android.Paths
287}
288
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800289func (j *Module) XrefJavaFiles() android.Paths {
290 return j.kytheFiles
291}
292
Colin Crossbe1da472017-07-07 15:59:46 -0700293type dependencyTag struct {
294 blueprint.BaseDependencyTag
295 name string
Colin Cross65cb3142021-12-10 23:05:02 +0000296
297 // True if the dependency is relinked at runtime.
298 runtimeLinked bool
Colin Crossce564252022-01-12 11:13:32 -0800299
300 // True if the dependency is a toolchain, for example an annotation processor.
301 toolchain bool
Colin Cross2fe66872015-03-30 17:20:39 -0700302}
303
Colin Crosse9fe2942020-11-10 18:12:15 -0800304// installDependencyTag is a dependency tag that is annotated to cause the installed files of the
305// dependency to be installed when the parent module is installed.
306type installDependencyTag struct {
307 blueprint.BaseDependencyTag
308 android.InstallAlwaysNeededDependencyTag
309 name string
310}
311
Colin Cross65cb3142021-12-10 23:05:02 +0000312func (d dependencyTag) LicenseAnnotations() []android.LicenseAnnotation {
313 if d.runtimeLinked {
314 return []android.LicenseAnnotation{android.LicenseAnnotationSharedDependency}
Colin Crossce564252022-01-12 11:13:32 -0800315 } else if d.toolchain {
316 return []android.LicenseAnnotation{android.LicenseAnnotationToolchain}
Colin Cross65cb3142021-12-10 23:05:02 +0000317 }
318 return nil
319}
320
321var _ android.LicenseAnnotationsDependencyTag = dependencyTag{}
322
Ulya Trafimovichb5218112020-10-07 15:11:32 +0100323type usesLibraryDependencyTag struct {
324 dependencyTag
Ulya Trafimovichf5d91bb2022-05-04 12:00:02 +0100325 sdkVersion int // SDK version in which the library appared as a standalone library.
326 optional bool // If the dependency is optional or required.
Ulya Trafimovichb5218112020-10-07 15:11:32 +0100327}
328
Ulya Trafimovichf5d91bb2022-05-04 12:00:02 +0100329func makeUsesLibraryDependencyTag(sdkVersion int, optional bool) usesLibraryDependencyTag {
Ulya Trafimovichb5218112020-10-07 15:11:32 +0100330 return usesLibraryDependencyTag{
Colin Cross65cb3142021-12-10 23:05:02 +0000331 dependencyTag: dependencyTag{
332 name: fmt.Sprintf("uses-library-%d", sdkVersion),
333 runtimeLinked: true,
334 },
335 sdkVersion: sdkVersion,
336 optional: optional,
Ulya Trafimovichb5218112020-10-07 15:11:32 +0100337 }
338}
339
Jiyong Park8be103b2019-11-08 15:53:48 +0900340func IsJniDepTag(depTag blueprint.DependencyTag) bool {
Colin Crossde78d132020-10-09 18:59:49 -0700341 return depTag == jniLibTag
Jiyong Park8be103b2019-11-08 15:53:48 +0900342}
343
Colin Crossbe1da472017-07-07 15:59:46 -0700344var (
Colin Cross75ce9ec2021-02-26 16:20:32 -0800345 dataNativeBinsTag = dependencyTag{name: "dataNativeBins"}
Sam Delmericob3342ce2022-01-20 21:10:28 +0000346 dataDeviceBinsTag = dependencyTag{name: "dataDeviceBins"}
Colin Cross75ce9ec2021-02-26 16:20:32 -0800347 staticLibTag = dependencyTag{name: "staticlib"}
Colin Cross65cb3142021-12-10 23:05:02 +0000348 libTag = dependencyTag{name: "javalib", runtimeLinked: true}
349 java9LibTag = dependencyTag{name: "java9lib", runtimeLinked: true}
Colin Crossce564252022-01-12 11:13:32 -0800350 pluginTag = dependencyTag{name: "plugin", toolchain: true}
351 errorpronePluginTag = dependencyTag{name: "errorprone-plugin", toolchain: true}
352 exportedPluginTag = dependencyTag{name: "exported-plugin", toolchain: true}
Colin Cross65cb3142021-12-10 23:05:02 +0000353 bootClasspathTag = dependencyTag{name: "bootclasspath", runtimeLinked: true}
354 systemModulesTag = dependencyTag{name: "system modules", runtimeLinked: true}
Colin Cross75ce9ec2021-02-26 16:20:32 -0800355 frameworkResTag = dependencyTag{name: "framework-res"}
Colin Cross65cb3142021-12-10 23:05:02 +0000356 kotlinStdlibTag = dependencyTag{name: "kotlin-stdlib", runtimeLinked: true}
357 kotlinAnnotationsTag = dependencyTag{name: "kotlin-annotations", runtimeLinked: true}
Colin Crossce564252022-01-12 11:13:32 -0800358 kotlinPluginTag = dependencyTag{name: "kotlin-plugin", toolchain: true}
Colin Cross75ce9ec2021-02-26 16:20:32 -0800359 proguardRaiseTag = dependencyTag{name: "proguard-raise"}
360 certificateTag = dependencyTag{name: "certificate"}
361 instrumentationForTag = dependencyTag{name: "instrumentation_for"}
Colin Crossce564252022-01-12 11:13:32 -0800362 extraLintCheckTag = dependencyTag{name: "extra-lint-check", toolchain: true}
Colin Cross65cb3142021-12-10 23:05:02 +0000363 jniLibTag = dependencyTag{name: "jnilib", runtimeLinked: true}
Colin Cross75ce9ec2021-02-26 16:20:32 -0800364 syspropPublicStubDepTag = dependencyTag{name: "sysprop public stub"}
365 jniInstallTag = installDependencyTag{name: "jni install"}
366 binaryInstallTag = installDependencyTag{name: "binary install"}
Ulya Trafimovichf5d91bb2022-05-04 12:00:02 +0100367 usesLibReqTag = makeUsesLibraryDependencyTag(dexpreopt.AnySdkVersion, false)
368 usesLibOptTag = makeUsesLibraryDependencyTag(dexpreopt.AnySdkVersion, true)
369 usesLibCompat28OptTag = makeUsesLibraryDependencyTag(28, true)
370 usesLibCompat29ReqTag = makeUsesLibraryDependencyTag(29, false)
371 usesLibCompat30OptTag = makeUsesLibraryDependencyTag(30, true)
Colin Crossbe1da472017-07-07 15:59:46 -0700372)
Colin Cross2fe66872015-03-30 17:20:39 -0700373
Jiyong Park83dc74b2020-01-14 18:38:44 +0900374func IsLibDepTag(depTag blueprint.DependencyTag) bool {
375 return depTag == libTag
376}
377
378func IsStaticLibDepTag(depTag blueprint.DependencyTag) bool {
379 return depTag == staticLibTag
380}
381
Colin Crossfc3674a2017-09-18 17:41:52 -0700382type sdkDep struct {
Pete Gilline3d44b22020-06-29 11:28:51 +0100383 useModule, useFiles, invalidVersion bool
Colin Cross47ff2522017-10-02 14:22:08 -0700384
Colin Cross6cef4812019-10-17 14:23:50 -0700385 // The modules that will be added to the bootclasspath when targeting 1.8 or lower
386 bootclasspath []string
Paul Duffine25c6442019-10-11 13:50:28 +0100387
388 // The default system modules to use. Will be an empty string if no system
389 // modules are to be used.
Colin Cross1369cdb2017-09-29 17:58:17 -0700390 systemModules string
391
Pete Gilline3d44b22020-06-29 11:28:51 +0100392 // The modules that will be added to the classpath regardless of the Java language level targeted
393 classpath []string
394
Colin Cross6cef4812019-10-17 14:23:50 -0700395 // The modules that will be added ot the classpath when targeting 1.9 or higher
Pete Gilline3d44b22020-06-29 11:28:51 +0100396 // (normally these will be on the bootclasspath when targeting 1.8 or lower)
Colin Cross6cef4812019-10-17 14:23:50 -0700397 java9Classpath []string
398
Colin Crossa97c5d32018-03-28 14:58:31 -0700399 frameworkResModule string
400
Colin Cross86a60ae2018-05-29 14:44:55 -0700401 jars android.Paths
Colin Cross3047fa22019-04-18 10:56:44 -0700402 aidl android.OptionalPath
Paul Duffin250e6192019-06-07 10:44:37 +0100403
404 noStandardLibs, noFrameworksLibs bool
405}
406
407func (s sdkDep) hasStandardLibs() bool {
408 return !s.noStandardLibs
409}
410
411func (s sdkDep) hasFrameworkLibs() bool {
412 return !s.noStandardLibs && !s.noFrameworksLibs
Colin Cross1369cdb2017-09-29 17:58:17 -0700413}
414
Colin Crossa4f08812018-10-02 22:03:40 -0700415type jniLib struct {
Colin Cross403cc152020-07-06 14:15:24 -0700416 name string
417 path android.Path
418 target android.Target
419 coverageFile android.OptionalPath
420 unstrippedFile android.Path
Colin Crossa4f08812018-10-02 22:03:40 -0700421}
422
Jiyong Parkf1691d22021-03-29 20:11:58 +0900423func sdkDeps(ctx android.BottomUpMutatorContext, sdkContext android.SdkContext, d dexer) {
Liz Kammerd6c31d22020-08-05 15:40:41 -0700424 sdkDep := decodeSdkDep(ctx, sdkContext)
425 if sdkDep.useModule {
426 ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.bootclasspath...)
427 ctx.AddVariationDependencies(nil, java9LibTag, sdkDep.java9Classpath...)
428 ctx.AddVariationDependencies(nil, libTag, sdkDep.classpath...)
429 if d.effectiveOptimizeEnabled() && sdkDep.hasStandardLibs() {
430 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.LegacyCorePlatformBootclasspathLibraries...)
431 }
432 if d.effectiveOptimizeEnabled() && sdkDep.hasFrameworkLibs() {
433 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.FrameworkLibraries...)
434 }
435 }
436 if sdkDep.systemModules != "" {
437 ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
438 }
439}
440
Colin Cross32f676a2017-09-06 13:41:06 -0700441type deps struct {
Colin Cross9bb9bfb2022-03-17 11:12:32 -0700442 // bootClasspath is the list of jars that form the boot classpath (generally the java.* and
443 // android.* classes) for tools that still use it. javac targeting 1.9 or higher uses
444 // systemModules and java9Classpath instead.
445 bootClasspath classpath
446
447 // classpath is the list of jars that form the classpath for javac and kotlinc rules. It
448 // contains header jars for all static and non-static dependencies.
449 classpath classpath
450
451 // dexClasspath is the list of jars that form the classpath for d8 and r8 rules. It contains
452 // header jars for all non-static dependencies. Static dependencies have already been
453 // combined into the program jar.
454 dexClasspath classpath
455
456 // java9Classpath is the list of jars that will be added to the classpath when targeting
457 // 1.9 or higher. It generally contains the android.* classes, while the java.* classes
458 // are provided by systemModules.
459 java9Classpath classpath
460
Colin Cross748b2d82020-11-19 13:52:06 -0800461 processorPath classpath
462 errorProneProcessorPath classpath
463 processorClasses []string
464 staticJars android.Paths
465 staticHeaderJars android.Paths
466 staticResourceJars android.Paths
467 aidlIncludeDirs android.Paths
468 srcs android.Paths
469 srcJars android.Paths
470 systemModules *systemModules
471 aidlPreprocess android.OptionalPath
472 kotlinStdlib android.Paths
473 kotlinAnnotations android.Paths
Colin Crossa1ff7c62021-09-17 14:11:52 -0700474 kotlinPlugins android.Paths
Colin Crossbe9cdb82019-01-21 21:37:16 -0800475
476 disableTurbine bool
Colin Cross32f676a2017-09-06 13:41:06 -0700477}
Colin Cross2fe66872015-03-30 17:20:39 -0700478
Colin Cross54250902017-12-05 09:28:08 -0800479func checkProducesJars(ctx android.ModuleContext, dep android.SourceFileProducer) {
480 for _, f := range dep.Srcs() {
481 if f.Ext() != ".jar" {
482 ctx.ModuleErrorf("genrule %q must generate files ending with .jar to be used as a libs or static_libs dependency",
483 ctx.OtherModuleName(dep.(blueprint.Module)))
484 }
485 }
486}
487
Jiyong Parkf1691d22021-03-29 20:11:58 +0900488func getJavaVersion(ctx android.ModuleContext, javaVersion string, sdkContext android.SdkContext) javaVersion {
Nan Zhang357466b2018-04-17 17:38:36 -0700489 if javaVersion != "" {
Colin Cross1e743852019-10-28 11:37:20 -0700490 return normalizeJavaVersion(ctx, javaVersion)
Colin Cross17dec172020-05-14 18:05:32 -0700491 } else if ctx.Device() {
Jiyong Park92315372021-04-02 08:45:46 +0900492 return defaultJavaLanguageVersion(ctx, sdkContext.SdkVersion(ctx))
Sorin Bascace720c32022-05-24 12:13:50 +0100493 } else if ctx.Config().TargetsJava17() {
494 // Temporary experimental flag to be able to try and build with
495 // java version 17 options. The flag, if used, just sets Java
496 // 17 as the default version, leaving any components that
497 // target an older version intact.
498 return JAVA_VERSION_17
Sorin Basca8d3e0bb2022-01-20 15:21:51 +0000499 } else {
Sorin Basca18ecf612022-01-23 09:01:07 +0000500 return JAVA_VERSION_11
Nan Zhang357466b2018-04-17 17:38:36 -0700501 }
Nan Zhang357466b2018-04-17 17:38:36 -0700502}
503
Colin Cross1e743852019-10-28 11:37:20 -0700504type javaVersion int
505
506const (
507 JAVA_VERSION_UNSUPPORTED = 0
508 JAVA_VERSION_6 = 6
509 JAVA_VERSION_7 = 7
510 JAVA_VERSION_8 = 8
511 JAVA_VERSION_9 = 9
Sorin Bascac0244da2021-11-26 17:26:33 +0000512 JAVA_VERSION_11 = 11
Sorin Bascace720c32022-05-24 12:13:50 +0100513 JAVA_VERSION_17 = 17
Colin Cross1e743852019-10-28 11:37:20 -0700514)
515
516func (v javaVersion) String() string {
517 switch v {
518 case JAVA_VERSION_6:
519 return "1.6"
520 case JAVA_VERSION_7:
521 return "1.7"
522 case JAVA_VERSION_8:
523 return "1.8"
524 case JAVA_VERSION_9:
525 return "1.9"
Sorin Bascac0244da2021-11-26 17:26:33 +0000526 case JAVA_VERSION_11:
527 return "11"
Sorin Bascace720c32022-05-24 12:13:50 +0100528 case JAVA_VERSION_17:
529 return "17"
Colin Cross1e743852019-10-28 11:37:20 -0700530 default:
531 return "unsupported"
532 }
533}
534
Cole Faustd96eebf2022-06-28 14:41:27 -0700535func (v javaVersion) StringForKotlinc() string {
536 // $ ./external/kotlinc/bin/kotlinc -jvm-target foo
537 // error: unknown JVM target version: foo
538 // Supported versions: 1.6, 1.8, 9, 10, 11, 12, 13, 14, 15, 16, 17
539 switch v {
540 case JAVA_VERSION_7:
541 return "1.6"
542 case JAVA_VERSION_9:
543 return "9"
544 default:
545 return v.String()
546 }
547}
548
Colin Cross1e743852019-10-28 11:37:20 -0700549// Returns true if javac targeting this version uses system modules instead of a bootclasspath.
550func (v javaVersion) usesJavaModules() bool {
551 return v >= 9
552}
553
554func normalizeJavaVersion(ctx android.BaseModuleContext, javaVersion string) javaVersion {
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100555 switch javaVersion {
556 case "1.6", "6":
Colin Cross1e743852019-10-28 11:37:20 -0700557 return JAVA_VERSION_6
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100558 case "1.7", "7":
Colin Cross1e743852019-10-28 11:37:20 -0700559 return JAVA_VERSION_7
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100560 case "1.8", "8":
Colin Cross1e743852019-10-28 11:37:20 -0700561 return JAVA_VERSION_8
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100562 case "1.9", "9":
Colin Cross1e743852019-10-28 11:37:20 -0700563 return JAVA_VERSION_9
Sorin Bascac0244da2021-11-26 17:26:33 +0000564 case "11":
565 return JAVA_VERSION_11
Sorin Bascace720c32022-05-24 12:13:50 +0100566 case "17":
Sorin Basca5938fed2022-06-22 12:53:51 +0100567 return JAVA_VERSION_17
Sorin Bascace720c32022-05-24 12:13:50 +0100568 case "10", "12", "13", "14", "15", "16":
569 ctx.PropertyErrorf("java_version", "Java language level %s is not supported", javaVersion)
Colin Cross1e743852019-10-28 11:37:20 -0700570 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100571 default:
572 ctx.PropertyErrorf("java_version", "Unrecognized Java language level")
Colin Cross1e743852019-10-28 11:37:20 -0700573 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +0100574 }
575}
576
Colin Cross2fe66872015-03-30 17:20:39 -0700577//
578// Java libraries (.jar file)
579//
580
Colin Crossf506d872017-07-19 15:53:04 -0700581type Library struct {
Colin Cross46c9b8b2017-06-22 16:51:17 -0700582 Module
Colin Crossf0f2e2c2019-10-15 16:36:40 -0700583
584 InstallMixin func(ctx android.ModuleContext, installPath android.Path) (extraInstallDeps android.Paths)
Colin Cross2fe66872015-03-30 17:20:39 -0700585}
586
Jiyong Park45bf82e2020-12-15 22:29:02 +0900587var _ android.ApexModule = (*Library)(nil)
588
satayevd604b212021-07-21 14:23:52 +0100589// Provides access to the list of permitted packages from apex boot jars.
Paul Duffine739f1e2020-05-29 11:24:51 +0100590type PermittedPackagesForUpdatableBootJars interface {
591 PermittedPackagesForUpdatableBootJars() []string
592}
593
594var _ PermittedPackagesForUpdatableBootJars = (*Library)(nil)
595
596func (j *Library) PermittedPackagesForUpdatableBootJars() []string {
597 return j.properties.Permitted_packages
598}
599
Colin Cross42be7612019-02-21 18:12:14 -0800600func shouldUncompressDex(ctx android.ModuleContext, dexpreopter *dexpreopter) bool {
Ulya Trafimovichf491dde2020-01-24 12:19:45 +0000601 // Store uncompressed (and aligned) any dex files from jars in APEXes.
Colin Cross56a83212020-09-15 18:30:11 -0700602 if apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo); !apexInfo.IsForPlatform() {
Ulya Trafimovichf491dde2020-01-24 12:19:45 +0000603 return true
604 }
605
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +0000606 // Store uncompressed (and do not strip) dex files from boot class path jars.
607 if inList(ctx.ModuleName(), ctx.Config().BootJars()) {
608 return true
609 }
610
611 // Store uncompressed dex files that are preopted on /system.
Jiakai Zhang519c5c82021-09-16 06:15:39 +0000612 if !dexpreopter.dexpreoptDisabled(ctx) && (ctx.Host() || !dexpreopter.odexOnSystemOther(ctx, dexpreopter.installPath)) {
Vladimir Markoe8b00d62018-12-21 15:54:16 +0000613 return true
614 }
Colin Cross083a2aa2019-02-06 16:37:12 -0800615 if ctx.Config().UncompressPrivAppDex() &&
616 inList(ctx.ModuleName(), ctx.Config().ModulesLoadedByPrivilegedModules()) {
617 return true
618 }
619
Colin Cross2fc72f62018-12-21 12:59:54 -0800620 return false
621}
622
Jiakai Zhang22450f22021-10-11 03:05:20 +0000623// Sets `dexer.dexProperties.Uncompress_dex` to the proper value.
624func setUncompressDex(ctx android.ModuleContext, dexpreopter *dexpreopter, dexer *dexer) {
625 if dexer.dexProperties.Uncompress_dex == nil {
626 // If the value was not force-set by the user, use reasonable default based on the module.
627 dexer.dexProperties.Uncompress_dex = proptools.BoolPtr(shouldUncompressDex(ctx, dexpreopter))
628 }
629}
630
Colin Crossf506d872017-07-19 15:53:04 -0700631func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Jiyong Park92315372021-04-02 08:45:46 +0900632 j.sdkVersion = j.SdkVersion(ctx)
633 j.minSdkVersion = j.MinSdkVersion(ctx)
satayev0a420e72021-11-29 17:25:52 +0000634 j.maxSdkVersion = j.MaxSdkVersion(ctx)
Jiyong Park92315372021-04-02 08:45:46 +0900635
Colin Cross56a83212020-09-15 18:30:11 -0700636 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
637 if !apexInfo.IsForPlatform() {
638 j.hideApexVariantFromMake = true
639 }
640
Artur Satayev2db1c3f2020-04-08 19:09:30 +0100641 j.checkSdkVersions(ctx)
Colin Cross61df14a2021-12-01 13:04:46 -0800642 if ctx.Device() {
643 j.dexpreopter.installPath = j.dexpreopter.getInstallPath(
644 ctx, android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar"))
645 j.dexpreopter.isSDKLibrary = j.deviceProperties.IsSDKLibrary
646 setUncompressDex(ctx, &j.dexpreopter, &j.dexer)
647 j.dexpreopter.uncompressedDex = *j.dexProperties.Uncompress_dex
648 j.classLoaderContexts = j.usesLibrary.classLoaderContextForUsesLibDeps(ctx)
649 }
Jaewoong Junga24af3b2019-05-13 09:23:20 -0700650 j.compile(ctx, nil)
Colin Crossb7a63242015-04-16 14:09:14 -0700651
bralee1fbf4402020-05-21 10:11:59 +0800652 // Collect the module directory for IDE info in java/jdeps.go.
653 j.modulePaths = append(j.modulePaths, ctx.ModuleDir())
654
Colin Cross56a83212020-09-15 18:30:11 -0700655 exclusivelyForApex := !apexInfo.IsForPlatform()
Jiyong Park7f7766d2019-07-25 22:02:35 +0900656 if (Bool(j.properties.Installable) || ctx.Host()) && !exclusivelyForApex {
Colin Crossf0f2e2c2019-10-15 16:36:40 -0700657 var extraInstallDeps android.Paths
658 if j.InstallMixin != nil {
659 extraInstallDeps = j.InstallMixin(ctx, j.outputFile)
660 }
Colin Cross1d0eb7a2021-11-03 14:08:20 -0700661 hostDexNeeded := Bool(j.deviceProperties.Hostdex) && !ctx.Host()
662 if hostDexNeeded {
Colin Cross3108ce12021-11-10 14:38:50 -0800663 j.hostdexInstallFile = ctx.InstallFile(
664 android.PathForHostDexInstall(ctx, "framework"),
Colin Cross1d0eb7a2021-11-03 14:08:20 -0700665 j.Stem()+"-hostdex.jar", j.outputFile)
666 }
667 var installDir android.InstallPath
668 if ctx.InstallInTestcases() {
669 var archDir string
670 if !ctx.Host() {
671 archDir = ctx.DeviceConfig().DeviceArch()
672 }
673 installDir = android.PathForModuleInstall(ctx, ctx.ModuleName(), archDir)
674 } else {
675 installDir = android.PathForModuleInstall(ctx, "framework")
676 }
677 j.installFile = ctx.InstallFile(installDir, j.Stem()+".jar", j.outputFile, extraInstallDeps...)
Colin Cross2c429dc2017-08-31 16:45:16 -0700678 }
Colin Crossb7a63242015-04-16 14:09:14 -0700679}
680
Colin Crossf506d872017-07-19 15:53:04 -0700681func (j *Library) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross46c9b8b2017-06-22 16:51:17 -0700682 j.deps(ctx)
Ulya Trafimoviche4432872021-08-18 16:57:11 +0100683 j.usesLibrary.deps(ctx, false)
Colin Cross46c9b8b2017-06-22 16:51:17 -0700684}
685
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000686const (
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000687 aidlIncludeDir = "aidl"
688 javaDir = "java"
689 jarFileSuffix = ".jar"
690 testConfigSuffix = "-AndroidTest.xml"
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000691)
692
Paul Duffina0dbf432019-12-05 11:25:53 +0000693// path to the jar file of a java library. Relative to <sdk_root>/<api_dir>
Paul Duffin13648912022-07-15 13:12:35 +0000694func sdkSnapshotFilePathForJar(_ android.SdkMemberContext, osPrefix, name string) string {
Paul Duffina04c1072020-03-02 10:16:35 +0000695 return sdkSnapshotFilePathForMember(osPrefix, name, jarFileSuffix)
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000696}
697
Paul Duffina04c1072020-03-02 10:16:35 +0000698func sdkSnapshotFilePathForMember(osPrefix, name string, suffix string) string {
699 return filepath.Join(javaDir, osPrefix, name+suffix)
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000700}
701
Paul Duffin13879572019-11-28 14:31:38 +0000702type librarySdkMemberType struct {
Paul Duffin255f18e2019-12-13 11:22:16 +0000703 android.SdkMemberTypeBase
Paul Duffinf5c0a9c2020-02-28 14:39:53 +0000704
705 // Function to retrieve the appropriate output jar (implementation or header) from
706 // the library.
Paul Duffindb170e42020-12-08 17:48:25 +0000707 jarToExportGetter func(ctx android.SdkMemberContext, j *Library) android.Path
708
709 // Function to compute the snapshot relative path to which the named library's
710 // jar should be copied.
Paul Duffin13648912022-07-15 13:12:35 +0000711 snapshotPathGetter func(ctx android.SdkMemberContext, osPrefix, name string) string
Paul Duffindb170e42020-12-08 17:48:25 +0000712
713 // True if only the jar should be copied to the snapshot, false if the jar plus any additional
714 // files like aidl files should also be copied.
715 onlyCopyJarToSnapshot bool
Paul Duffin13879572019-11-28 14:31:38 +0000716}
717
Paul Duffindb170e42020-12-08 17:48:25 +0000718const (
719 onlyCopyJarToSnapshot = true
720 copyEverythingToSnapshot = false
721)
722
Paul Duffin296701e2021-07-14 10:29:36 +0100723func (mt *librarySdkMemberType) AddDependencies(ctx android.SdkDependencyContext, dependencyTag blueprint.DependencyTag, names []string) {
724 ctx.AddVariationDependencies(nil, dependencyTag, names...)
Paul Duffin13879572019-11-28 14:31:38 +0000725}
726
727func (mt *librarySdkMemberType) IsInstance(module android.Module) bool {
728 _, ok := module.(*Library)
729 return ok
730}
731
Paul Duffin3a4eb502020-03-19 16:11:18 +0000732func (mt *librarySdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
733 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_import")
Paul Duffin14eb4672020-03-02 11:33:02 +0000734}
Paul Duffina0dbf432019-12-05 11:25:53 +0000735
Paul Duffin14eb4672020-03-02 11:33:02 +0000736func (mt *librarySdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
Paul Duffina551a1c2020-03-17 21:04:24 +0000737 return &librarySdkMemberProperties{}
Paul Duffin14eb4672020-03-02 11:33:02 +0000738}
739
740type librarySdkMemberProperties struct {
741 android.SdkMemberPropertiesBase
742
Paul Duffin864e1b42020-05-06 10:23:19 +0100743 JarToExport android.Path `android:"arch_variant"`
Paul Duffina551a1c2020-03-17 21:04:24 +0000744 AidlIncludeDirs android.Paths
Paul Duffin869de142021-07-15 14:14:41 +0100745
746 // The list of permitted packages that need to be passed to the prebuilts as they are used to
747 // create the updatable-bcp-packages.txt file.
748 PermittedPackages []string
Paul Duffin14eb4672020-03-02 11:33:02 +0000749}
750
Paul Duffin3a4eb502020-03-19 16:11:18 +0000751func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffin13879572019-11-28 14:31:38 +0000752 j := variant.(*Library)
753
Paul Duffindb170e42020-12-08 17:48:25 +0000754 p.JarToExport = ctx.MemberType().(*librarySdkMemberType).jarToExportGetter(ctx, j)
755
Paul Duffina551a1c2020-03-17 21:04:24 +0000756 p.AidlIncludeDirs = j.AidlIncludeDirs()
Paul Duffin869de142021-07-15 14:14:41 +0100757
758 p.PermittedPackages = j.PermittedPackagesForUpdatableBootJars()
Paul Duffin14eb4672020-03-02 11:33:02 +0000759}
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000760
Paul Duffin3a4eb502020-03-19 16:11:18 +0000761func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffina551a1c2020-03-17 21:04:24 +0000762 builder := ctx.SnapshotBuilder()
Paul Duffin3a4eb502020-03-19 16:11:18 +0000763
Paul Duffindb170e42020-12-08 17:48:25 +0000764 memberType := ctx.MemberType().(*librarySdkMemberType)
765
Paul Duffina551a1c2020-03-17 21:04:24 +0000766 exportedJar := p.JarToExport
767 if exportedJar != nil {
Paul Duffindb170e42020-12-08 17:48:25 +0000768 // Delegate the creation of the snapshot relative path to the member type.
Paul Duffin13648912022-07-15 13:12:35 +0000769 snapshotRelativeJavaLibPath := memberType.snapshotPathGetter(ctx, p.OsPrefix(), ctx.Name())
Paul Duffindb170e42020-12-08 17:48:25 +0000770
771 // Copy the exported jar to the snapshot.
Paul Duffin14eb4672020-03-02 11:33:02 +0000772 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
773
Paul Duffina551a1c2020-03-17 21:04:24 +0000774 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
775 }
776
Paul Duffin869de142021-07-15 14:14:41 +0100777 if len(p.PermittedPackages) > 0 {
778 propertySet.AddProperty("permitted_packages", p.PermittedPackages)
779 }
780
Paul Duffindb170e42020-12-08 17:48:25 +0000781 // Do not copy anything else to the snapshot.
782 if memberType.onlyCopyJarToSnapshot {
783 return
784 }
785
Paul Duffina551a1c2020-03-17 21:04:24 +0000786 aidlIncludeDirs := p.AidlIncludeDirs
787 if len(aidlIncludeDirs) != 0 {
788 sdkModuleContext := ctx.SdkModuleContext()
789 for _, dir := range aidlIncludeDirs {
Paul Duffin14eb4672020-03-02 11:33:02 +0000790 // TODO(jiyong): copy parcelable declarations only
791 aidlFiles, _ := sdkModuleContext.GlobWithDeps(dir.String()+"/**/*.aidl", nil)
792 for _, file := range aidlFiles {
793 builder.CopyToSnapshot(android.PathForSource(sdkModuleContext, file), filepath.Join(aidlIncludeDir, file))
794 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000795 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000796
Paul Duffina551a1c2020-03-17 21:04:24 +0000797 // TODO(b/151933053) - add aidl include dirs property
Paul Duffin14eb4672020-03-02 11:33:02 +0000798 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +0000799}
800
Colin Cross1b16b0e2019-02-12 14:41:32 -0800801// java_library builds and links sources into a `.jar` file for the device, and possibly for the host as well.
802//
803// By default, a java_library has a single variant that produces a `.jar` file containing `.class` files that were
804// compiled against the device bootclasspath. This jar is not suitable for installing on a device, but can be used
805// as a `static_libs` dependency of another module.
806//
807// Specifying `installable: true` will product a `.jar` file containing `classes.dex` files, suitable for installing on
808// a device.
809//
810// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
811// compiled against the host bootclasspath.
Colin Cross9ae1b922018-06-26 17:59:05 -0700812func LibraryFactory() android.Module {
813 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -0700814
Colin Crossce6734e2020-06-15 16:09:53 -0700815 module.addHostAndDeviceProperties()
Colin Cross2fe66872015-03-30 17:20:39 -0700816
Paul Duffin71b33cc2021-06-23 11:39:47 +0100817 module.initModuleAndImport(module)
Paul Duffin859fe962020-05-15 10:20:31 +0100818
Jiyong Park7f7766d2019-07-25 22:02:35 +0900819 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +0900820 android.InitSdkAwareModule(module)
Wei Libafb6d62021-12-10 03:14:59 -0800821 android.InitBazelModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +0900822 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross9ae1b922018-06-26 17:59:05 -0700823 return module
Colin Cross2fe66872015-03-30 17:20:39 -0700824}
825
Colin Cross1b16b0e2019-02-12 14:41:32 -0800826// java_library_static is an obsolete alias for java_library.
827func LibraryStaticFactory() android.Module {
828 return LibraryFactory()
829}
830
831// java_library_host builds and links sources into a `.jar` file for the host.
832//
833// A java_library_host has a single variant that produces a `.jar` file containing `.class` files that were
834// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -0700835func LibraryHostFactory() android.Module {
836 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -0700837
Colin Crossce6734e2020-06-15 16:09:53 -0700838 module.addHostProperties()
Colin Cross36242852017-06-23 15:06:31 -0700839
Colin Cross9ae1b922018-06-26 17:59:05 -0700840 module.Module.properties.Installable = proptools.BoolPtr(true)
841
Jiyong Park7f7766d2019-07-25 22:02:35 +0900842 android.InitApexModule(module)
Paul Duffinb6b89a42021-05-06 16:33:43 +0100843 android.InitSdkAwareModule(module)
Wei Libafb6d62021-12-10 03:14:59 -0800844 android.InitBazelModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +0900845 InitJavaModule(module, android.HostSupported)
Colin Cross36242852017-06-23 15:06:31 -0700846 return module
Colin Cross2fe66872015-03-30 17:20:39 -0700847}
848
849//
Colin Crossb628ea52018-08-14 16:42:33 -0700850// Java Tests
Colin Cross05638fc2018-04-09 18:40:24 -0700851//
852
Dan Shi95d19422020-08-15 12:24:26 -0700853// Test option struct.
854type TestOptions struct {
855 // a list of extra test configuration files that should be installed with the module.
856 Extra_test_configs []string `android:"path,arch_variant"`
Dan Shid79572f2020-11-13 14:33:46 -0800857
858 // If the test is a hostside(no device required) unittest that shall be run during presubmit check.
859 Unit_test *bool
Dan Shi95d19422020-08-15 12:24:26 -0700860}
861
Colin Cross05638fc2018-04-09 18:40:24 -0700862type testProperties struct {
Colin Cross05638fc2018-04-09 18:40:24 -0700863 // list of compatibility suites (for example "cts", "vts") that the module should be
864 // installed into.
865 Test_suites []string `android:"arch_variant"`
Julien Despreze146e392018-08-02 15:00:46 -0700866
867 // the name of the test configuration (for example "AndroidTest.xml") that should be
868 // installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -0800869 Test_config *string `android:"path,arch_variant"`
Colin Crossd96ca352018-08-10 16:06:24 -0700870
Jack He33338892018-09-19 02:21:28 -0700871 // the name of the test configuration template (for example "AndroidTestTemplate.xml") that
872 // should be installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -0800873 Test_config_template *string `android:"path,arch_variant"`
Jack He33338892018-09-19 02:21:28 -0700874
Colin Crossd96ca352018-08-10 16:06:24 -0700875 // list of files or filegroup modules that provide data that should be installed alongside
876 // the test
Jiyong Park2b0e4902021-02-16 06:52:39 +0900877 Data []string `android:"path"`
Dan Shi6ffaaa82019-09-26 11:41:36 -0700878
879 // Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
880 // doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
881 // explicitly.
882 Auto_gen_config *bool
easoncylee5bcff5d2020-04-30 14:57:06 +0800883
884 // Add parameterized mainline modules to auto generated test config. The options will be
885 // handled by TradeFed to do downloading and installing the specified modules on the device.
886 Test_mainline_modules []string
Dan Shi95d19422020-08-15 12:24:26 -0700887
888 // Test options.
889 Test_options TestOptions
Colin Crossf8d9c492021-01-26 11:01:43 -0800890
891 // Names of modules containing JNI libraries that should be installed alongside the test.
892 Jni_libs []string
Colin Crosscfb0f5e2021-09-24 15:47:17 -0700893
894 // Install the test into a folder named for the module in all test suites.
895 Per_testcase_directory *bool
Colin Cross05638fc2018-04-09 18:40:24 -0700896}
897
Liz Kammerdd849a82020-06-12 16:38:45 -0700898type hostTestProperties struct {
899 // list of native binary modules that should be installed alongside the test
900 Data_native_bins []string `android:"arch_variant"`
Sam Delmericob3342ce2022-01-20 21:10:28 +0000901
902 // list of device binary modules that should be installed alongside the test
Sam Delmericocc271e22022-06-01 15:45:02 +0000903 // This property only adds the first variant of the dependency
904 Data_device_bins_first []string `android:"arch_variant"`
905
906 // list of device binary modules that should be installed alongside the test
907 // This property adds 64bit AND 32bit variants of the dependency
908 Data_device_bins_both []string `android:"arch_variant"`
909
910 // list of device binary modules that should be installed alongside the test
911 // This property only adds 64bit variants of the dependency
912 Data_device_bins_64 []string `android:"arch_variant"`
913
914 // list of device binary modules that should be installed alongside the test
915 // This property adds 32bit variants of the dependency if available, or else
916 // defaults to the 64bit variant
917 Data_device_bins_prefer32 []string `android:"arch_variant"`
918
919 // list of device binary modules that should be installed alongside the test
920 // This property only adds 32bit variants of the dependency
921 Data_device_bins_32 []string `android:"arch_variant"`
Liz Kammerdd849a82020-06-12 16:38:45 -0700922}
923
Paul Duffin42df1442019-03-20 12:45:53 +0000924type testHelperLibraryProperties struct {
925 // list of compatibility suites (for example "cts", "vts") that the module should be
926 // installed into.
927 Test_suites []string `android:"arch_variant"`
Colin Crosscfb0f5e2021-09-24 15:47:17 -0700928
929 // Install the test into a folder named for the module in all test suites.
930 Per_testcase_directory *bool
Paul Duffin42df1442019-03-20 12:45:53 +0000931}
932
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000933type prebuiltTestProperties struct {
934 // list of compatibility suites (for example "cts", "vts") that the module should be
935 // installed into.
936 Test_suites []string `android:"arch_variant"`
937
938 // the name of the test configuration (for example "AndroidTest.xml") that should be
939 // installed with the module.
940 Test_config *string `android:"path,arch_variant"`
941}
942
Colin Cross05638fc2018-04-09 18:40:24 -0700943type Test struct {
944 Library
945
946 testProperties testProperties
Colin Cross303e21f2018-08-07 16:49:25 -0700947
Dan Shi95d19422020-08-15 12:24:26 -0700948 testConfig android.Path
949 extraTestConfigs android.Paths
950 data android.Paths
Colin Cross303e21f2018-08-07 16:49:25 -0700951}
952
Liz Kammerdd849a82020-06-12 16:38:45 -0700953type TestHost struct {
954 Test
955
956 testHostProperties hostTestProperties
957}
958
Paul Duffin42df1442019-03-20 12:45:53 +0000959type TestHelperLibrary struct {
960 Library
961
962 testHelperLibraryProperties testHelperLibraryProperties
963}
964
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000965type JavaTestImport struct {
966 Import
967
968 prebuiltTestProperties prebuiltTestProperties
969
970 testConfig android.Path
Liz Kammerd6c31d22020-08-05 15:40:41 -0700971 dexJarFile android.Path
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000972}
973
Colin Cross24cc4be62021-11-03 14:09:41 -0700974func (j *Test) InstallInTestcases() bool {
975 // Host java tests install into $(HOST_OUT_JAVA_LIBRARIES), and then are copied into
976 // testcases by base_rules.mk.
977 return !j.Host()
978}
979
980func (j *TestHelperLibrary) InstallInTestcases() bool {
981 return true
982}
983
984func (j *JavaTestImport) InstallInTestcases() bool {
985 return true
986}
987
Sam Delmericocc271e22022-06-01 15:45:02 +0000988func (j *TestHost) addDataDeviceBinsDeps(ctx android.BottomUpMutatorContext) {
989 if len(j.testHostProperties.Data_device_bins_first) > 0 {
990 deviceVariations := ctx.Config().AndroidFirstDeviceTarget.Variations()
991 ctx.AddFarVariationDependencies(deviceVariations, dataDeviceBinsTag, j.testHostProperties.Data_device_bins_first...)
992 }
993
994 var maybeAndroid32Target *android.Target
995 var maybeAndroid64Target *android.Target
996 android32TargetList := android.FirstTarget(ctx.Config().Targets[android.Android], "lib32")
997 android64TargetList := android.FirstTarget(ctx.Config().Targets[android.Android], "lib64")
998 if len(android32TargetList) > 0 {
999 maybeAndroid32Target = &android32TargetList[0]
1000 }
1001 if len(android64TargetList) > 0 {
1002 maybeAndroid64Target = &android64TargetList[0]
1003 }
1004
1005 if len(j.testHostProperties.Data_device_bins_both) > 0 {
1006 if maybeAndroid32Target == nil && maybeAndroid64Target == nil {
1007 ctx.PropertyErrorf("data_device_bins_both", "no device targets available. Targets: %q", ctx.Config().Targets)
1008 return
1009 }
1010 if maybeAndroid32Target != nil {
1011 ctx.AddFarVariationDependencies(
1012 maybeAndroid32Target.Variations(),
1013 dataDeviceBinsTag,
1014 j.testHostProperties.Data_device_bins_both...,
1015 )
1016 }
1017 if maybeAndroid64Target != nil {
1018 ctx.AddFarVariationDependencies(
1019 maybeAndroid64Target.Variations(),
1020 dataDeviceBinsTag,
1021 j.testHostProperties.Data_device_bins_both...,
1022 )
1023 }
1024 }
1025
1026 if len(j.testHostProperties.Data_device_bins_prefer32) > 0 {
1027 if maybeAndroid32Target != nil {
1028 ctx.AddFarVariationDependencies(
1029 maybeAndroid32Target.Variations(),
1030 dataDeviceBinsTag,
1031 j.testHostProperties.Data_device_bins_prefer32...,
1032 )
1033 } else {
1034 if maybeAndroid64Target == nil {
1035 ctx.PropertyErrorf("data_device_bins_prefer32", "no device targets available. Targets: %q", ctx.Config().Targets)
1036 return
1037 }
1038 ctx.AddFarVariationDependencies(
1039 maybeAndroid64Target.Variations(),
1040 dataDeviceBinsTag,
1041 j.testHostProperties.Data_device_bins_prefer32...,
1042 )
1043 }
1044 }
1045
1046 if len(j.testHostProperties.Data_device_bins_32) > 0 {
1047 if maybeAndroid32Target == nil {
1048 ctx.PropertyErrorf("data_device_bins_32", "cannot find 32bit device target. Targets: %q", ctx.Config().Targets)
1049 return
1050 }
1051 deviceVariations := maybeAndroid32Target.Variations()
1052 ctx.AddFarVariationDependencies(deviceVariations, dataDeviceBinsTag, j.testHostProperties.Data_device_bins_32...)
1053 }
1054
1055 if len(j.testHostProperties.Data_device_bins_64) > 0 {
1056 if maybeAndroid64Target == nil {
1057 ctx.PropertyErrorf("data_device_bins_64", "cannot find 64bit device target. Targets: %q", ctx.Config().Targets)
1058 return
1059 }
1060 deviceVariations := maybeAndroid64Target.Variations()
1061 ctx.AddFarVariationDependencies(deviceVariations, dataDeviceBinsTag, j.testHostProperties.Data_device_bins_64...)
1062 }
1063}
1064
Liz Kammerdd849a82020-06-12 16:38:45 -07001065func (j *TestHost) DepsMutator(ctx android.BottomUpMutatorContext) {
1066 if len(j.testHostProperties.Data_native_bins) > 0 {
1067 for _, target := range ctx.MultiTargets() {
1068 ctx.AddVariationDependencies(target.Variations(), dataNativeBinsTag, j.testHostProperties.Data_native_bins...)
1069 }
1070 }
1071
Colin Crossf8d9c492021-01-26 11:01:43 -08001072 if len(j.testProperties.Jni_libs) > 0 {
1073 for _, target := range ctx.MultiTargets() {
1074 sharedLibVariations := append(target.Variations(), blueprint.Variation{Mutator: "link", Variation: "shared"})
1075 ctx.AddFarVariationDependencies(sharedLibVariations, jniLibTag, j.testProperties.Jni_libs...)
1076 }
1077 }
1078
Sam Delmericocc271e22022-06-01 15:45:02 +00001079 j.addDataDeviceBinsDeps(ctx)
1080
Liz Kammerdd849a82020-06-12 16:38:45 -07001081 j.deps(ctx)
1082}
1083
Yuexi Ma627263f2021-03-04 13:47:56 -08001084func (j *TestHost) AddExtraResource(p android.Path) {
1085 j.extraResources = append(j.extraResources, p)
1086}
1087
Sam Delmericocc271e22022-06-01 15:45:02 +00001088func (j *TestHost) dataDeviceBins() []string {
1089 ret := make([]string, 0,
1090 len(j.testHostProperties.Data_device_bins_first)+
1091 len(j.testHostProperties.Data_device_bins_both)+
1092 len(j.testHostProperties.Data_device_bins_prefer32)+
1093 len(j.testHostProperties.Data_device_bins_32)+
1094 len(j.testHostProperties.Data_device_bins_64),
1095 )
1096
1097 ret = append(ret, j.testHostProperties.Data_device_bins_first...)
1098 ret = append(ret, j.testHostProperties.Data_device_bins_both...)
1099 ret = append(ret, j.testHostProperties.Data_device_bins_prefer32...)
1100 ret = append(ret, j.testHostProperties.Data_device_bins_32...)
1101 ret = append(ret, j.testHostProperties.Data_device_bins_64...)
1102
1103 return ret
1104}
1105
Sam Delmericob3342ce2022-01-20 21:10:28 +00001106func (j *TestHost) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1107 var configs []tradefed.Config
Sam Delmericocc271e22022-06-01 15:45:02 +00001108 dataDeviceBins := j.dataDeviceBins()
1109 if len(dataDeviceBins) > 0 {
Sam Delmericob3342ce2022-01-20 21:10:28 +00001110 // add Tradefed configuration to push device bins to device for testing
1111 remoteDir := filepath.Join("/data/local/tests/unrestricted/", j.Name())
1112 options := []tradefed.Option{{Name: "cleanup", Value: "true"}}
Sam Delmericocc271e22022-06-01 15:45:02 +00001113 for _, bin := range dataDeviceBins {
Sam Delmericob3342ce2022-01-20 21:10:28 +00001114 fullPath := filepath.Join(remoteDir, bin)
1115 options = append(options, tradefed.Option{Name: "push-file", Key: bin, Value: fullPath})
1116 }
Sam Delmericocc271e22022-06-01 15:45:02 +00001117 configs = append(configs, tradefed.Object{
1118 Type: "target_preparer",
1119 Class: "com.android.tradefed.targetprep.PushFilePreparer",
1120 Options: options,
1121 })
Sam Delmericob3342ce2022-01-20 21:10:28 +00001122 }
1123
1124 j.Test.generateAndroidBuildActionsWithConfig(ctx, configs)
1125}
1126
Colin Cross303e21f2018-08-07 16:49:25 -07001127func (j *Test) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Sam Delmericob3342ce2022-01-20 21:10:28 +00001128 j.generateAndroidBuildActionsWithConfig(ctx, nil)
1129}
1130
1131func (j *Test) generateAndroidBuildActionsWithConfig(ctx android.ModuleContext, configs []tradefed.Config) {
Julien Desprezb2166612021-03-05 18:08:36 +00001132 if j.testProperties.Test_options.Unit_test == nil && ctx.Host() {
1133 // TODO(b/): Clean temporary heuristic to avoid unexpected onboarding.
Julien Desprezf666b152021-03-15 13:07:53 -07001134 defaultUnitTest := !inList("tradefed", j.properties.Libs) && !inList("cts", j.testProperties.Test_suites)
Julien Desprezb2166612021-03-05 18:08:36 +00001135 j.testProperties.Test_options.Unit_test = proptools.BoolPtr(defaultUnitTest)
1136 }
Sam Delmericob3342ce2022-01-20 21:10:28 +00001137
Dan Shi6ffaaa82019-09-26 11:41:36 -07001138 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.testProperties.Test_config, j.testProperties.Test_config_template,
Sam Delmericob3342ce2022-01-20 21:10:28 +00001139 j.testProperties.Test_suites, configs, j.testProperties.Auto_gen_config, j.testProperties.Test_options.Unit_test)
Liz Kammerdd849a82020-06-12 16:38:45 -07001140
Colin Cross8a497952019-03-05 22:25:09 -08001141 j.data = android.PathsForModuleSrc(ctx, j.testProperties.Data)
Colin Cross303e21f2018-08-07 16:49:25 -07001142
Dan Shi95d19422020-08-15 12:24:26 -07001143 j.extraTestConfigs = android.PathsForModuleSrc(ctx, j.testProperties.Test_options.Extra_test_configs)
1144
Liz Kammerdd849a82020-06-12 16:38:45 -07001145 ctx.VisitDirectDepsWithTag(dataNativeBinsTag, func(dep android.Module) {
1146 j.data = append(j.data, android.OutputFileForModule(ctx, dep, ""))
1147 })
1148
Sam Delmericob3342ce2022-01-20 21:10:28 +00001149 ctx.VisitDirectDepsWithTag(dataDeviceBinsTag, func(dep android.Module) {
1150 j.data = append(j.data, android.OutputFileForModule(ctx, dep, ""))
1151 })
1152
Colin Crossf8d9c492021-01-26 11:01:43 -08001153 ctx.VisitDirectDepsWithTag(jniLibTag, func(dep android.Module) {
1154 sharedLibInfo := ctx.OtherModuleProvider(dep, cc.SharedLibraryInfoProvider).(cc.SharedLibraryInfo)
1155 if sharedLibInfo.SharedLibrary != nil {
1156 // Copy to an intermediate output directory to append "lib[64]" to the path,
1157 // so that it's compatible with the default rpath values.
1158 var relPath string
1159 if sharedLibInfo.Target.Arch.ArchType.Multilib == "lib64" {
1160 relPath = filepath.Join("lib64", sharedLibInfo.SharedLibrary.Base())
1161 } else {
1162 relPath = filepath.Join("lib", sharedLibInfo.SharedLibrary.Base())
1163 }
1164 relocatedLib := android.PathForModuleOut(ctx, "relocated").Join(ctx, relPath)
1165 ctx.Build(pctx, android.BuildParams{
1166 Rule: android.Cp,
1167 Input: sharedLibInfo.SharedLibrary,
1168 Output: relocatedLib,
1169 })
1170 j.data = append(j.data, relocatedLib)
1171 } else {
1172 ctx.PropertyErrorf("jni_libs", "%q of type %q is not supported", dep.Name(), ctx.OtherModuleType(dep))
1173 }
1174 })
1175
Colin Cross303e21f2018-08-07 16:49:25 -07001176 j.Library.GenerateAndroidBuildActions(ctx)
Colin Cross05638fc2018-04-09 18:40:24 -07001177}
1178
Paul Duffin42df1442019-03-20 12:45:53 +00001179func (j *TestHelperLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1180 j.Library.GenerateAndroidBuildActions(ctx)
1181}
1182
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001183func (j *JavaTestImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1184 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.prebuiltTestProperties.Test_config, nil,
Sam Delmericob3342ce2022-01-20 21:10:28 +00001185 j.prebuiltTestProperties.Test_suites, nil, nil, nil)
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001186
1187 j.Import.GenerateAndroidBuildActions(ctx)
1188}
1189
1190type testSdkMemberType struct {
1191 android.SdkMemberTypeBase
1192}
1193
Paul Duffin296701e2021-07-14 10:29:36 +01001194func (mt *testSdkMemberType) AddDependencies(ctx android.SdkDependencyContext, dependencyTag blueprint.DependencyTag, names []string) {
1195 ctx.AddVariationDependencies(nil, dependencyTag, names...)
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001196}
1197
1198func (mt *testSdkMemberType) IsInstance(module android.Module) bool {
1199 _, ok := module.(*Test)
1200 return ok
1201}
1202
Paul Duffin3a4eb502020-03-19 16:11:18 +00001203func (mt *testSdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
1204 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_test_import")
Paul Duffin14eb4672020-03-02 11:33:02 +00001205}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001206
Paul Duffin14eb4672020-03-02 11:33:02 +00001207func (mt *testSdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
1208 return &testSdkMemberProperties{}
1209}
1210
1211type testSdkMemberProperties struct {
1212 android.SdkMemberPropertiesBase
1213
Paul Duffina551a1c2020-03-17 21:04:24 +00001214 JarToExport android.Path
1215 TestConfig android.Path
Paul Duffin14eb4672020-03-02 11:33:02 +00001216}
1217
Paul Duffin3a4eb502020-03-19 16:11:18 +00001218func (p *testSdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffin14eb4672020-03-02 11:33:02 +00001219 test := variant.(*Test)
1220
1221 implementationJars := test.ImplementationJars()
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001222 if len(implementationJars) != 1 {
Paul Duffin14eb4672020-03-02 11:33:02 +00001223 panic(fmt.Errorf("there must be only one implementation jar from %q", test.Name()))
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001224 }
1225
Paul Duffina551a1c2020-03-17 21:04:24 +00001226 p.JarToExport = implementationJars[0]
1227 p.TestConfig = test.testConfig
Paul Duffin14eb4672020-03-02 11:33:02 +00001228}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001229
Paul Duffin3a4eb502020-03-19 16:11:18 +00001230func (p *testSdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffina551a1c2020-03-17 21:04:24 +00001231 builder := ctx.SnapshotBuilder()
Paul Duffin3a4eb502020-03-19 16:11:18 +00001232
Paul Duffina551a1c2020-03-17 21:04:24 +00001233 exportedJar := p.JarToExport
1234 if exportedJar != nil {
Paul Duffin13648912022-07-15 13:12:35 +00001235 snapshotRelativeJavaLibPath := sdkSnapshotFilePathForJar(ctx, p.OsPrefix(), ctx.Name())
Paul Duffina551a1c2020-03-17 21:04:24 +00001236 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
Paul Duffin14eb4672020-03-02 11:33:02 +00001237
1238 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
Paul Duffina551a1c2020-03-17 21:04:24 +00001239 }
1240
1241 testConfig := p.TestConfig
1242 if testConfig != nil {
1243 snapshotRelativeTestConfigPath := sdkSnapshotFilePathForMember(p.OsPrefix(), ctx.Name(), testConfigSuffix)
1244 builder.CopyToSnapshot(testConfig, snapshotRelativeTestConfigPath)
Paul Duffin14eb4672020-03-02 11:33:02 +00001245 propertySet.AddProperty("test_config", snapshotRelativeTestConfigPath)
1246 }
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001247}
1248
Colin Cross1b16b0e2019-02-12 14:41:32 -08001249// java_test builds a and links sources into a `.jar` file for the device, and possibly for the host as well, and
1250// creates an `AndroidTest.xml` file to allow running the test with `atest` or a `TEST_MAPPING` file.
1251//
1252// By default, a java_test has a single variant that produces a `.jar` file containing `classes.dex` files that were
1253// compiled against the device bootclasspath.
1254//
1255// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
1256// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07001257func TestFactory() android.Module {
1258 module := &Test{}
1259
Colin Crossce6734e2020-06-15 16:09:53 -07001260 module.addHostAndDeviceProperties()
1261 module.AddProperties(&module.testProperties)
Colin Cross05638fc2018-04-09 18:40:24 -07001262
Colin Cross9ae1b922018-06-26 17:59:05 -07001263 module.Module.properties.Installable = proptools.BoolPtr(true)
Colin Crosse3026872019-01-05 22:30:13 -08001264 module.Module.dexpreopter.isTest = true
Colin Cross014489c2020-06-02 20:09:13 -07001265 module.Module.linter.test = true
Colin Cross9ae1b922018-06-26 17:59:05 -07001266
Paul Duffinb6b89a42021-05-06 16:33:43 +01001267 android.InitSdkAwareModule(module)
Colin Cross05638fc2018-04-09 18:40:24 -07001268 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross05638fc2018-04-09 18:40:24 -07001269 return module
1270}
1271
Paul Duffin42df1442019-03-20 12:45:53 +00001272// java_test_helper_library creates a java library and makes sure that it is added to the appropriate test suite.
1273func TestHelperLibraryFactory() android.Module {
1274 module := &TestHelperLibrary{}
1275
Colin Crossce6734e2020-06-15 16:09:53 -07001276 module.addHostAndDeviceProperties()
1277 module.AddProperties(&module.testHelperLibraryProperties)
Paul Duffin42df1442019-03-20 12:45:53 +00001278
Colin Cross9a4abed2019-04-24 13:19:28 -07001279 module.Module.properties.Installable = proptools.BoolPtr(true)
1280 module.Module.dexpreopter.isTest = true
Colin Cross014489c2020-06-02 20:09:13 -07001281 module.Module.linter.test = true
Colin Cross9a4abed2019-04-24 13:19:28 -07001282
Paul Duffin42df1442019-03-20 12:45:53 +00001283 InitJavaModule(module, android.HostAndDeviceSupported)
1284 return module
1285}
1286
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001287// java_test_import imports one or more `.jar` files into the build graph as if they were built by a java_test module
1288// and makes sure that it is added to the appropriate test suite.
1289//
1290// By default, a java_test_import has a single variant that expects a `.jar` file containing `.class` files that were
1291// compiled against an Android classpath.
1292//
1293// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
1294// for host modules.
1295func JavaTestImportFactory() android.Module {
1296 module := &JavaTestImport{}
1297
1298 module.AddProperties(
1299 &module.Import.properties,
1300 &module.prebuiltTestProperties)
1301
1302 module.Import.properties.Installable = proptools.BoolPtr(true)
1303
1304 android.InitPrebuiltModule(module, &module.properties.Jars)
1305 android.InitApexModule(module)
1306 android.InitSdkAwareModule(module)
1307 InitJavaModule(module, android.HostAndDeviceSupported)
1308 return module
1309}
1310
Colin Cross1b16b0e2019-02-12 14:41:32 -08001311// java_test_host builds a and links sources into a `.jar` file for the host, and creates an `AndroidTest.xml` file to
1312// allow running the test with `atest` or a `TEST_MAPPING` file.
1313//
1314// A java_test_host has a single variant that produces a `.jar` file containing `.class` files that were
1315// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07001316func TestHostFactory() android.Module {
Liz Kammerdd849a82020-06-12 16:38:45 -07001317 module := &TestHost{}
Colin Cross05638fc2018-04-09 18:40:24 -07001318
Colin Crossce6734e2020-06-15 16:09:53 -07001319 module.addHostProperties()
1320 module.AddProperties(&module.testProperties)
Liz Kammerdd849a82020-06-12 16:38:45 -07001321 module.AddProperties(&module.testHostProperties)
Colin Cross05638fc2018-04-09 18:40:24 -07001322
Yuexi Ma627263f2021-03-04 13:47:56 -08001323 InitTestHost(
1324 module,
1325 proptools.BoolPtr(true),
1326 nil,
1327 nil)
Colin Cross9ae1b922018-06-26 17:59:05 -07001328
Liz Kammerdd849a82020-06-12 16:38:45 -07001329 InitJavaModuleMultiTargets(module, android.HostSupported)
Julien Desprezb2166612021-03-05 18:08:36 +00001330
Colin Cross05638fc2018-04-09 18:40:24 -07001331 return module
1332}
1333
Yuexi Ma627263f2021-03-04 13:47:56 -08001334func InitTestHost(th *TestHost, installable *bool, testSuites []string, autoGenConfig *bool) {
1335 th.properties.Installable = installable
1336 th.testProperties.Auto_gen_config = autoGenConfig
1337 th.testProperties.Test_suites = testSuites
1338}
1339
Colin Cross05638fc2018-04-09 18:40:24 -07001340//
Colin Cross2fe66872015-03-30 17:20:39 -07001341// Java Binaries (.jar file plus wrapper script)
1342//
1343
Colin Crossf506d872017-07-19 15:53:04 -07001344type binaryProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -07001345 // installable script to execute the resulting jar
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001346 Wrapper *string `android:"path,arch_variant"`
Colin Cross094054a2018-10-17 15:10:48 -07001347
1348 // Name of the class containing main to be inserted into the manifest as Main-Class.
1349 Main_class *string
Colin Cross89226d92020-10-09 19:00:54 -07001350
1351 // Names of modules containing JNI libraries that should be installed alongside the host
1352 // variant of the binary.
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001353 Jni_libs []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -07001354}
1355
Colin Crossf506d872017-07-19 15:53:04 -07001356type Binary struct {
1357 Library
Colin Cross2fe66872015-03-30 17:20:39 -07001358
Colin Crossf506d872017-07-19 15:53:04 -07001359 binaryProperties binaryProperties
Colin Cross10a03492017-08-10 17:09:43 -07001360
Colin Cross6b4a32d2017-12-05 13:42:45 -08001361 isWrapperVariant bool
1362
Colin Crossc3315992017-12-08 19:12:36 -08001363 wrapperFile android.Path
Colin Cross70dda7e2019-10-01 22:05:35 -07001364 binaryFile android.InstallPath
Colin Cross2fe66872015-03-30 17:20:39 -07001365}
1366
Alex Light24237172017-10-26 09:46:21 -07001367func (j *Binary) HostToolPath() android.OptionalPath {
1368 return android.OptionalPathForPath(j.binaryFile)
1369}
1370
Colin Crossf506d872017-07-19 15:53:04 -07001371func (j *Binary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Cross6b4a32d2017-12-05 13:42:45 -08001372 if ctx.Arch().ArchType == android.Common {
1373 // Compile the jar
Colin Cross094054a2018-10-17 15:10:48 -07001374 if j.binaryProperties.Main_class != nil {
1375 if j.properties.Manifest != nil {
1376 ctx.PropertyErrorf("main_class", "main_class cannot be used when manifest is set")
1377 }
1378 manifestFile := android.PathForModuleOut(ctx, "manifest.txt")
1379 GenerateMainClassManifest(ctx, manifestFile, String(j.binaryProperties.Main_class))
1380 j.overrideManifest = android.OptionalPathForPath(manifestFile)
1381 }
1382
Colin Cross6b4a32d2017-12-05 13:42:45 -08001383 j.Library.GenerateAndroidBuildActions(ctx)
Nan Zhang3c807db2017-11-03 14:53:31 -07001384 } else {
Colin Cross6b4a32d2017-12-05 13:42:45 -08001385 // Handle the binary wrapper
1386 j.isWrapperVariant = true
1387
Colin Cross366938f2017-12-11 16:29:02 -08001388 if j.binaryProperties.Wrapper != nil {
Colin Cross8a497952019-03-05 22:25:09 -08001389 j.wrapperFile = android.PathForModuleSrc(ctx, *j.binaryProperties.Wrapper)
Colin Cross6b4a32d2017-12-05 13:42:45 -08001390 } else {
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001391 if ctx.Windows() {
1392 ctx.PropertyErrorf("wrapper", "wrapper is required for Windows")
1393 }
1394
Colin Cross6b4a32d2017-12-05 13:42:45 -08001395 j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh")
1396 }
1397
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001398 ext := ""
1399 if ctx.Windows() {
1400 ext = ".bat"
1401 }
1402
Colin Crossc179ea62020-10-09 10:54:15 -07001403 // The host installation rules make the installed wrapper depend on all the dependencies
Colin Cross89226d92020-10-09 19:00:54 -07001404 // of the wrapper variant, which will include the common variant's jar file and any JNI
1405 // libraries. This is verified by TestBinary.
Colin Cross6b4a32d2017-12-05 13:42:45 -08001406 j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"),
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001407 ctx.ModuleName()+ext, j.wrapperFile)
1408 }
Colin Cross2fe66872015-03-30 17:20:39 -07001409}
1410
Colin Crossf506d872017-07-19 15:53:04 -07001411func (j *Binary) DepsMutator(ctx android.BottomUpMutatorContext) {
Liz Kammer3bf97bd2022-04-26 09:38:20 -04001412 if ctx.Arch().ArchType == android.Common {
Colin Cross6b4a32d2017-12-05 13:42:45 -08001413 j.deps(ctx)
Liz Kammer356f7d42021-01-26 09:18:53 -05001414 }
Liz Kammer3bf97bd2022-04-26 09:38:20 -04001415 if ctx.Arch().ArchType != android.Common {
Colin Crosse9fe2942020-11-10 18:12:15 -08001416 // These dependencies ensure the host installation rules will install the jar file and
1417 // the jni libraries when the wrapper is installed.
1418 ctx.AddVariationDependencies(nil, jniInstallTag, j.binaryProperties.Jni_libs...)
1419 ctx.AddVariationDependencies(
1420 []blueprint.Variation{{Mutator: "arch", Variation: android.CommonArch.String()}},
1421 binaryInstallTag, ctx.ModuleName())
Colin Cross6b4a32d2017-12-05 13:42:45 -08001422 }
Colin Cross46c9b8b2017-06-22 16:51:17 -07001423}
1424
Colin Cross1b16b0e2019-02-12 14:41:32 -08001425// java_binary builds a `.jar` file and a shell script that executes it for the device, and possibly for the host
1426// as well.
1427//
1428// By default, a java_binary has a single variant that produces a `.jar` file containing `classes.dex` files that were
1429// compiled against the device bootclasspath.
1430//
1431// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
1432// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07001433func BinaryFactory() android.Module {
1434 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07001435
Colin Crossce6734e2020-06-15 16:09:53 -07001436 module.addHostAndDeviceProperties()
1437 module.AddProperties(&module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07001438
Colin Cross9ae1b922018-06-26 17:59:05 -07001439 module.Module.properties.Installable = proptools.BoolPtr(true)
1440
Colin Cross6b4a32d2017-12-05 13:42:45 -08001441 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommonFirst)
1442 android.InitDefaultableModule(module)
Wei Libafb6d62021-12-10 03:14:59 -08001443 android.InitBazelModule(module)
1444
Colin Cross36242852017-06-23 15:06:31 -07001445 return module
Colin Cross2fe66872015-03-30 17:20:39 -07001446}
1447
Colin Cross1b16b0e2019-02-12 14:41:32 -08001448// java_binary_host builds a `.jar` file and a shell script that executes it for the host.
1449//
1450// A java_binary_host has a single variant that produces a `.jar` file containing `.class` files that were
1451// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07001452func BinaryHostFactory() android.Module {
1453 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07001454
Colin Crossce6734e2020-06-15 16:09:53 -07001455 module.addHostProperties()
1456 module.AddProperties(&module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07001457
Colin Cross9ae1b922018-06-26 17:59:05 -07001458 module.Module.properties.Installable = proptools.BoolPtr(true)
1459
Colin Cross6b4a32d2017-12-05 13:42:45 -08001460 android.InitAndroidArchModule(module, android.HostSupported, android.MultilibCommonFirst)
1461 android.InitDefaultableModule(module)
Wei Libafb6d62021-12-10 03:14:59 -08001462 android.InitBazelModule(module)
Colin Cross36242852017-06-23 15:06:31 -07001463 return module
Colin Cross2fe66872015-03-30 17:20:39 -07001464}
1465
1466//
1467// Java prebuilts
1468//
1469
Colin Cross74d73e22017-08-02 11:05:49 -07001470type ImportProperties struct {
Paul Duffina04c1072020-03-02 10:16:35 +00001471 Jars []string `android:"path,arch_variant"`
Colin Cross461bd1a2017-10-20 13:59:18 -07001472
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001473 // The version of the SDK that the source prebuilt file was built against. Defaults to the
1474 // current version if not specified.
Nan Zhangea568a42017-11-08 21:20:04 -08001475 Sdk_version *string
Colin Cross535e2cf2017-10-20 17:57:49 -07001476
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001477 // The minimum version of the SDK that this module supports. Defaults to sdk_version if not
1478 // specified.
1479 Min_sdk_version *string
1480
William Loh5a082f92022-05-17 20:21:50 +00001481 // The max sdk version placeholder used to replace maxSdkVersion attributes on permission
1482 // and uses-permission tags in manifest_fixer.
1483 Replace_max_sdk_version_placeholder *string
1484
Colin Cross535e2cf2017-10-20 17:57:49 -07001485 Installable *bool
Jiyong Park1be96912018-05-28 18:02:19 +09001486
Paul Duffin869de142021-07-15 14:14:41 +01001487 // If not empty, classes are restricted to the specified packages and their sub-packages.
Paul Duffin869de142021-07-15 14:14:41 +01001488 Permitted_packages []string
1489
Jiyong Park1be96912018-05-28 18:02:19 +09001490 // List of shared java libs that this module has dependencies to
1491 Libs []string
Colin Cross37f6d792018-07-12 12:28:41 -07001492
1493 // List of files to remove from the jar file(s)
1494 Exclude_files []string
1495
1496 // List of directories to remove from the jar file(s)
1497 Exclude_dirs []string
Nan Zhang4c819fb2018-08-27 18:31:46 -07001498
1499 // if set to true, run Jetifier against .jar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -07001500 Jetifier *bool
Jiyong Park4c4c0242019-10-21 14:53:15 +09001501
1502 // set the name of the output
1503 Stem *string
Jiyong Park19604de2020-03-24 16:44:11 +09001504
1505 Aidl struct {
1506 // directories that should be added as include directories for any aidl sources of modules
1507 // that depend on this module, as well as to aidl for this module.
1508 Export_include_dirs []string
1509 }
Colin Cross74d73e22017-08-02 11:05:49 -07001510}
1511
1512type Import struct {
Colin Cross635c3b02016-05-18 15:37:25 -07001513 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -07001514 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09001515 android.ApexModuleBase
Romain Jobredeaux428a3662022-01-28 11:12:52 -05001516 android.BazelModuleBase
Colin Crossec7a0422017-07-07 14:47:12 -07001517 prebuilt android.Prebuilt
Jiyong Parkd1063c12019-07-17 20:08:41 +09001518 android.SdkBase
Colin Cross2fe66872015-03-30 17:20:39 -07001519
Paul Duffin0d3c2e12020-05-17 08:34:50 +01001520 // Functionality common to Module and Import.
1521 embeddableInModuleAndImport
1522
Liz Kammerd6c31d22020-08-05 15:40:41 -07001523 hiddenAPI
1524 dexer
Bill Peckhamff89ffa2020-12-23 16:13:04 -08001525 dexpreopter
Liz Kammerd6c31d22020-08-05 15:40:41 -07001526
Colin Cross74d73e22017-08-02 11:05:49 -07001527 properties ImportProperties
1528
Liz Kammerd6c31d22020-08-05 15:40:41 -07001529 // output file containing classes.dex and resources
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001530 dexJarFile OptionalDexJarPath
Jeongik Chad5fe8782021-07-08 01:13:11 +09001531 dexJarInstallFile android.Path
Liz Kammerd6c31d22020-08-05 15:40:41 -07001532
Colin Cross0a6e0072017-08-30 14:24:55 -07001533 combinedClasspathFile android.Path
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +01001534 classLoaderContexts dexpreopt.ClassLoaderContextMap
Jiyong Park19604de2020-03-24 16:44:11 +09001535 exportAidlIncludeDirs android.Paths
Colin Cross56a83212020-09-15 18:30:11 -07001536
1537 hideApexVariantFromMake bool
Jiyong Park92315372021-04-02 08:45:46 +09001538
1539 sdkVersion android.SdkSpec
1540 minSdkVersion android.SdkSpec
Colin Cross2fe66872015-03-30 17:20:39 -07001541}
1542
Paul Duffin630b11e2021-07-15 13:35:26 +01001543var _ PermittedPackagesForUpdatableBootJars = (*Import)(nil)
1544
1545func (j *Import) PermittedPackagesForUpdatableBootJars() []string {
1546 return j.properties.Permitted_packages
1547}
1548
Jiyong Park92315372021-04-02 08:45:46 +09001549func (j *Import) SdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
1550 return android.SdkSpecFrom(ctx, String(j.properties.Sdk_version))
Liz Kammer2d2fd852020-08-12 14:42:30 -07001551}
1552
Jiyong Parkf1691d22021-03-29 20:11:58 +09001553func (j *Import) SystemModules() string {
Liz Kammerd6c31d22020-08-05 15:40:41 -07001554 return "none"
1555}
1556
Jiyong Park92315372021-04-02 08:45:46 +09001557func (j *Import) MinSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001558 if j.properties.Min_sdk_version != nil {
Jiyong Park92315372021-04-02 08:45:46 +09001559 return android.SdkSpecFrom(ctx, *j.properties.Min_sdk_version)
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001560 }
Jiyong Park92315372021-04-02 08:45:46 +09001561 return j.SdkVersion(ctx)
Colin Cross83bb3162018-06-25 15:48:06 -07001562}
1563
William Loh5a082f92022-05-17 20:21:50 +00001564func (j *Import) ReplaceMaxSdkVersionPlaceholder(ctx android.EarlyModuleContext) android.SdkSpec {
1565 if j.properties.Replace_max_sdk_version_placeholder != nil {
1566 return android.SdkSpecFrom(ctx, *j.properties.Replace_max_sdk_version_placeholder)
1567 }
1568 return android.SdkSpecFrom(ctx, "")
1569}
1570
Jiyong Park92315372021-04-02 08:45:46 +09001571func (j *Import) TargetSdkVersion(ctx android.EarlyModuleContext) android.SdkSpec {
1572 return j.SdkVersion(ctx)
Artur Satayev480e25b2020-04-27 18:53:18 +01001573}
1574
Colin Cross74d73e22017-08-02 11:05:49 -07001575func (j *Import) Prebuilt() *android.Prebuilt {
Colin Crossec7a0422017-07-07 14:47:12 -07001576 return &j.prebuilt
1577}
1578
Colin Cross74d73e22017-08-02 11:05:49 -07001579func (j *Import) PrebuiltSrcs() []string {
1580 return j.properties.Jars
1581}
1582
1583func (j *Import) Name() string {
Colin Cross5ea9bcc2017-07-27 15:41:32 -07001584 return j.prebuilt.Name(j.ModuleBase.Name())
1585}
1586
Jiyong Park0b238752019-10-29 11:23:10 +09001587func (j *Import) Stem() string {
1588 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
1589}
1590
Jiyong Park618922e2020-01-08 13:35:43 +09001591func (a *Import) JacocoReportClassesFile() android.Path {
1592 return nil
1593}
1594
Bill Peckhama41a6962021-01-11 10:58:54 -08001595func (j *Import) LintDepSets() LintDepSets {
1596 return LintDepSets{}
1597}
1598
Jaewoong Jung476b9d62021-05-10 15:30:00 -07001599func (j *Import) getStrictUpdatabilityLinting() bool {
1600 return false
1601}
1602
1603func (j *Import) setStrictUpdatabilityLinting(bool) {
1604}
1605
Colin Cross74d73e22017-08-02 11:05:49 -07001606func (j *Import) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross42d48b72018-08-29 14:10:52 -07001607 ctx.AddVariationDependencies(nil, libTag, j.properties.Libs...)
Liz Kammerd6c31d22020-08-05 15:40:41 -07001608
1609 if ctx.Device() && Bool(j.dexProperties.Compile_dex) {
Jiyong Parkf1691d22021-03-29 20:11:58 +09001610 sdkDeps(ctx, android.SdkContext(j), j.dexer)
Liz Kammerd6c31d22020-08-05 15:40:41 -07001611 }
Colin Cross1e676be2016-10-12 14:38:15 -07001612}
1613
Sam Delmerico277795c2022-02-25 17:04:37 +00001614func (j *Import) commonBuildActions(ctx android.ModuleContext) {
1615 //TODO(b/231322772) these should come from Bazel once available
Jiyong Park92315372021-04-02 08:45:46 +09001616 j.sdkVersion = j.SdkVersion(ctx)
1617 j.minSdkVersion = j.MinSdkVersion(ctx)
1618
Colin Cross56a83212020-09-15 18:30:11 -07001619 if !ctx.Provider(android.ApexInfoProvider).(android.ApexInfo).IsForPlatform() {
1620 j.hideApexVariantFromMake = true
1621 }
1622
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001623 if ctx.Windows() {
1624 j.HideFromMake()
1625 }
Sam Delmerico277795c2022-02-25 17:04:37 +00001626}
1627
1628func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1629 j.commonBuildActions(ctx)
Dan Willemsen8e6b3712021-09-20 23:11:24 -07001630
Colin Cross8a497952019-03-05 22:25:09 -08001631 jars := android.PathsForModuleSrc(ctx, j.properties.Jars)
Colin Crosse1d62a82015-04-03 16:53:05 -07001632
Jiyong Park0b238752019-10-29 11:23:10 +09001633 jarName := j.Stem() + ".jar"
Nan Zhang4c819fb2018-08-27 18:31:46 -07001634 outputFile := android.PathForModuleOut(ctx, "combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07001635 TransformJarsToJar(ctx, outputFile, "for prebuilts", jars, android.OptionalPath{},
1636 false, j.properties.Exclude_files, j.properties.Exclude_dirs)
Colin Cross1001a792019-03-21 22:21:39 -07001637 if Bool(j.properties.Jetifier) {
Nan Zhang4c819fb2018-08-27 18:31:46 -07001638 inputFile := outputFile
1639 outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
1640 TransformJetifier(ctx, outputFile, inputFile)
1641 }
Colin Crosse9a275b2017-10-16 17:09:48 -07001642 j.combinedClasspathFile = outputFile
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +01001643 j.classLoaderContexts = make(dexpreopt.ClassLoaderContextMap)
Paul Duffin859fe962020-05-15 10:20:31 +01001644
Liz Kammerd6c31d22020-08-05 15:40:41 -07001645 var flags javaBuilderFlags
1646
Jiyong Park1be96912018-05-28 18:02:19 +09001647 ctx.VisitDirectDeps(func(module android.Module) {
Jiyong Park1be96912018-05-28 18:02:19 +09001648 tag := ctx.OtherModuleDependencyTag(module)
1649
Colin Crossdcf71b22021-02-01 13:59:03 -08001650 if ctx.OtherModuleHasProvider(module, JavaInfoProvider) {
1651 dep := ctx.OtherModuleProvider(module, JavaInfoProvider).(JavaInfo)
Jiyong Park1be96912018-05-28 18:02:19 +09001652 switch tag {
Colin Cross9bb9bfb2022-03-17 11:12:32 -07001653 case libTag:
1654 flags.classpath = append(flags.classpath, dep.HeaderJars...)
1655 flags.dexClasspath = append(flags.dexClasspath, dep.HeaderJars...)
1656 case staticLibTag:
Colin Crossdcf71b22021-02-01 13:59:03 -08001657 flags.classpath = append(flags.classpath, dep.HeaderJars...)
Liz Kammerd6c31d22020-08-05 15:40:41 -07001658 case bootClasspathTag:
Colin Crossdcf71b22021-02-01 13:59:03 -08001659 flags.bootClasspath = append(flags.bootClasspath, dep.HeaderJars...)
Jiyong Park1be96912018-05-28 18:02:19 +09001660 }
Colin Crossdcf71b22021-02-01 13:59:03 -08001661 } else if dep, ok := module.(SdkLibraryDependency); ok {
Jiyong Park1be96912018-05-28 18:02:19 +09001662 switch tag {
1663 case libTag:
Jiyong Park92315372021-04-02 08:45:46 +09001664 flags.classpath = append(flags.classpath, dep.SdkHeaderJars(ctx, j.SdkVersion(ctx))...)
Jiyong Park1be96912018-05-28 18:02:19 +09001665 }
1666 }
Ulya Trafimovich65b03192020-12-03 16:50:22 +00001667
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00001668 addCLCFromDep(ctx, module, j.classLoaderContexts)
Jiyong Park1be96912018-05-28 18:02:19 +09001669 })
1670
Sam Delmerico277795c2022-02-25 17:04:37 +00001671 j.maybeInstall(ctx, jarName, outputFile)
Jiyong Park19604de2020-03-24 16:44:11 +09001672
1673 j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.properties.Aidl.Export_include_dirs)
Liz Kammerd6c31d22020-08-05 15:40:41 -07001674
Paul Duffin064b70c2020-11-02 17:32:38 +00001675 if ctx.Device() {
1676 // If this is a variant created for a prebuilt_apex then use the dex implementation jar
1677 // obtained from the associated deapexer module.
1678 ai := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1679 if ai.ForPrebuiltApex {
Paul Duffin064b70c2020-11-02 17:32:38 +00001680 // Get the path of the dex implementation jar from the `deapexer` module.
Martin Stjernholm44825602021-09-17 01:44:12 +01001681 di := android.FindDeapexerProviderForModule(ctx)
1682 if di == nil {
1683 return // An error has been reported by FindDeapexerProviderForModule.
1684 }
Paul Duffinb4bbf2c2021-06-17 15:59:07 +01001685 if dexOutputPath := di.PrebuiltExportPath(apexRootRelativePathToJavaLib(j.BaseModuleName())); dexOutputPath != nil {
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001686 dexJarFile := makeDexJarPathFromPath(dexOutputPath)
1687 j.dexJarFile = dexJarFile
Jiakai Zhang5b24f722021-09-30 09:32:57 +00001688 installPath := android.PathForModuleInPartitionInstall(ctx, "apex", ai.ApexVariationName, apexRootRelativePathToJavaLib(j.BaseModuleName()))
1689 j.dexJarInstallFile = installPath
Paul Duffin74d18d12021-05-14 14:18:47 +01001690
Jiakai Zhang5b24f722021-09-30 09:32:57 +00001691 j.dexpreopter.installPath = j.dexpreopter.getInstallPath(ctx, installPath)
Jiakai Zhang22450f22021-10-11 03:05:20 +00001692 setUncompressDex(ctx, &j.dexpreopter, &j.dexer)
Jiakai Zhang5b24f722021-09-30 09:32:57 +00001693 j.dexpreopter.uncompressedDex = *j.dexProperties.Uncompress_dex
1694 j.dexpreopt(ctx, dexOutputPath)
Jiakai Zhang22450f22021-10-11 03:05:20 +00001695
1696 // Initialize the hiddenapi structure.
1697 j.initHiddenAPI(ctx, dexJarFile, outputFile, j.dexProperties.Uncompress_dex)
Paul Duffin9d67ca62021-02-03 20:06:33 +00001698 } else {
Paul Duffin064b70c2020-11-02 17:32:38 +00001699 // This should never happen as a variant for a prebuilt_apex is only created if the
1700 // prebuilt_apex has been configured to export the java library dex file.
Martin Stjernholm44825602021-09-17 01:44:12 +01001701 ctx.ModuleErrorf("internal error: no dex implementation jar available from prebuilt APEX %s", di.ApexModuleName())
Paul Duffin064b70c2020-11-02 17:32:38 +00001702 }
1703 } else if Bool(j.dexProperties.Compile_dex) {
Jiyong Parkf1691d22021-03-29 20:11:58 +09001704 sdkDep := decodeSdkDep(ctx, android.SdkContext(j))
Paul Duffin064b70c2020-11-02 17:32:38 +00001705 if sdkDep.invalidVersion {
1706 ctx.AddMissingDependencies(sdkDep.bootclasspath)
1707 ctx.AddMissingDependencies(sdkDep.java9Classpath)
1708 } else if sdkDep.useFiles {
1709 // sdkDep.jar is actually equivalent to turbine header.jar.
1710 flags.classpath = append(flags.classpath, sdkDep.jars...)
1711 }
1712
1713 // Dex compilation
1714
Jiakai Zhang519c5c82021-09-16 06:15:39 +00001715 j.dexpreopter.installPath = j.dexpreopter.getInstallPath(
1716 ctx, android.PathForModuleInstall(ctx, "framework", jarName))
Jiakai Zhang22450f22021-10-11 03:05:20 +00001717 setUncompressDex(ctx, &j.dexpreopter, &j.dexer)
Paul Duffin064b70c2020-11-02 17:32:38 +00001718 j.dexpreopter.uncompressedDex = *j.dexProperties.Uncompress_dex
1719
Paul Duffin612e6102021-02-02 13:38:13 +00001720 var dexOutputFile android.OutputPath
Jiyong Park92315372021-04-02 08:45:46 +09001721 dexOutputFile = j.dexer.compileDex(ctx, flags, j.MinSdkVersion(ctx), outputFile, jarName)
Paul Duffin064b70c2020-11-02 17:32:38 +00001722 if ctx.Failed() {
1723 return
1724 }
1725
Paul Duffin74d18d12021-05-14 14:18:47 +01001726 // Initialize the hiddenapi structure.
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001727 j.initHiddenAPI(ctx, makeDexJarPathFromPath(dexOutputFile), outputFile, j.dexProperties.Uncompress_dex)
Paul Duffinafaa47c2021-05-14 13:04:04 +01001728
1729 // Encode hidden API flags in dex file.
Paul Duffin1bbd0622021-05-14 15:52:25 +01001730 dexOutputFile = j.hiddenAPIEncodeDex(ctx, dexOutputFile)
Paul Duffin064b70c2020-11-02 17:32:38 +00001731
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001732 j.dexJarFile = makeDexJarPathFromPath(dexOutputFile)
Jeongik Chad5fe8782021-07-08 01:13:11 +09001733 j.dexJarInstallFile = android.PathForModuleInstall(ctx, "framework", jarName)
Liz Kammerd6c31d22020-08-05 15:40:41 -07001734 }
Liz Kammerd6c31d22020-08-05 15:40:41 -07001735 }
Colin Crossdcf71b22021-02-01 13:59:03 -08001736
1737 ctx.SetProvider(JavaInfoProvider, JavaInfo{
1738 HeaderJars: android.PathsIfNonNil(j.combinedClasspathFile),
1739 ImplementationAndResourcesJars: android.PathsIfNonNil(j.combinedClasspathFile),
1740 ImplementationJars: android.PathsIfNonNil(j.combinedClasspathFile),
1741 AidlIncludeDirs: j.exportAidlIncludeDirs,
1742 })
Colin Cross2fe66872015-03-30 17:20:39 -07001743}
1744
Sam Delmerico277795c2022-02-25 17:04:37 +00001745func (j *Import) maybeInstall(ctx android.ModuleContext, jarName string, outputFile android.Path) {
1746 if !Bool(j.properties.Installable) {
1747 return
1748 }
1749
1750 var installDir android.InstallPath
1751 if ctx.InstallInTestcases() {
1752 var archDir string
1753 if !ctx.Host() {
1754 archDir = ctx.DeviceConfig().DeviceArch()
1755 }
1756 installDir = android.PathForModuleInstall(ctx, ctx.ModuleName(), archDir)
1757 } else {
1758 installDir = android.PathForModuleInstall(ctx, "framework")
1759 }
1760 ctx.InstallFile(installDir, jarName, outputFile)
1761}
1762
Paul Duffinaa55f742020-10-06 17:20:13 +01001763func (j *Import) OutputFiles(tag string) (android.Paths, error) {
1764 switch tag {
Saeid Farivar Asanjan128fe5c2020-10-15 17:54:40 +00001765 case "", ".jar":
Paul Duffinaa55f742020-10-06 17:20:13 +01001766 return android.Paths{j.combinedClasspathFile}, nil
1767 default:
1768 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
1769 }
1770}
1771
1772var _ android.OutputFileProducer = (*Import)(nil)
1773
Nan Zhanged19fc32017-10-19 13:06:22 -07001774func (j *Import) HeaderJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001775 if j.combinedClasspathFile == nil {
1776 return nil
1777 }
Colin Cross37f6d792018-07-12 12:28:41 -07001778 return android.Paths{j.combinedClasspathFile}
Nan Zhanged19fc32017-10-19 13:06:22 -07001779}
1780
Colin Cross331a1212018-08-15 20:40:52 -07001781func (j *Import) ImplementationAndResourcesJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001782 if j.combinedClasspathFile == nil {
1783 return nil
1784 }
Colin Cross331a1212018-08-15 20:40:52 -07001785 return android.Paths{j.combinedClasspathFile}
1786}
1787
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001788func (j *Import) DexJarBuildPath() OptionalDexJarPath {
Liz Kammerd6c31d22020-08-05 15:40:41 -07001789 return j.dexJarFile
Colin Crossf24a22a2019-01-31 14:12:44 -08001790}
1791
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +01001792func (j *Import) DexJarInstallPath() android.Path {
Jeongik Chad5fe8782021-07-08 01:13:11 +09001793 return j.dexJarInstallFile
Ulya Trafimovich9f3052c2020-06-09 14:31:19 +01001794}
1795
Ulya Trafimovichb23d28c2020-10-08 12:53:58 +01001796func (j *Import) ClassLoaderContexts() dexpreopt.ClassLoaderContextMap {
1797 return j.classLoaderContexts
Jiyong Park1be96912018-05-28 18:02:19 +09001798}
1799
Jiyong Park45bf82e2020-12-15 22:29:02 +09001800var _ android.ApexModule = (*Import)(nil)
1801
1802// Implements android.ApexModule
Jiyong Park0f80c182020-01-31 02:49:53 +09001803func (j *Import) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Paul Duffin0d3c2e12020-05-17 08:34:50 +01001804 return j.depIsInSameApex(ctx, dep)
Jiyong Park0f80c182020-01-31 02:49:53 +09001805}
1806
Jiyong Park45bf82e2020-12-15 22:29:02 +09001807// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07001808func (j *Import) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
1809 sdkVersion android.ApiLevel) error {
Jiyong Park92315372021-04-02 08:45:46 +09001810 sdkSpec := j.MinSdkVersion(ctx)
Jiyong Parkf1691d22021-03-29 20:11:58 +09001811 if !sdkSpec.Specified() {
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001812 return fmt.Errorf("min_sdk_version is not specified")
1813 }
Jiyong Parkf1691d22021-03-29 20:11:58 +09001814 if sdkSpec.Kind == android.SdkCore {
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001815 return nil
1816 }
Jooyung Han4c4da062021-06-23 10:23:16 +09001817 if sdkSpec.ApiLevel.GreaterThan(sdkVersion) {
1818 return fmt.Errorf("newer SDK(%v)", sdkSpec.ApiLevel)
Jaewoong Jung56e12db2021-04-02 00:38:25 +00001819 }
Jooyung Han749dc692020-04-15 11:03:39 +09001820 return nil
1821}
1822
Paul Duffinfef55002021-06-17 14:56:05 +01001823// requiredFilesFromPrebuiltApexForImport returns information about the files that a java_import or
1824// java_sdk_library_import with the specified base module name requires to be exported from a
1825// prebuilt_apex/apex_set.
Paul Duffinb4bbf2c2021-06-17 15:59:07 +01001826func requiredFilesFromPrebuiltApexForImport(name string) []string {
1827 // Add the dex implementation jar to the set of exported files.
1828 return []string{
1829 apexRootRelativePathToJavaLib(name),
Paul Duffinfef55002021-06-17 14:56:05 +01001830 }
1831}
1832
Paul Duffinb4bbf2c2021-06-17 15:59:07 +01001833// apexRootRelativePathToJavaLib returns the path, relative to the root of the apex's contents, for
1834// the java library with the specified name.
1835func apexRootRelativePathToJavaLib(name string) string {
1836 return filepath.Join("javalib", name+".jar")
1837}
1838
Paul Duffinfef55002021-06-17 14:56:05 +01001839var _ android.RequiredFilesFromPrebuiltApex = (*Import)(nil)
1840
Paul Duffinb4bbf2c2021-06-17 15:59:07 +01001841func (j *Import) RequiredFilesFromPrebuiltApex(_ android.BaseModuleContext) []string {
Paul Duffinfef55002021-06-17 14:56:05 +01001842 name := j.BaseModuleName()
1843 return requiredFilesFromPrebuiltApexForImport(name)
1844}
1845
albaltai36ff7dc2018-12-25 14:35:23 +08001846// Add compile time check for interface implementation
1847var _ android.IDEInfo = (*Import)(nil)
1848var _ android.IDECustomizedModuleName = (*Import)(nil)
1849
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001850// Collect information for opening IDE project files in java/jdeps.go.
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001851
1852func (j *Import) IDEInfo(dpInfo *android.IdeInfo) {
1853 dpInfo.Jars = append(dpInfo.Jars, j.PrebuiltSrcs()...)
1854}
1855
1856func (j *Import) IDECustomizedModuleName() string {
1857 // TODO(b/113562217): Extract the base module name from the Import name, often the Import name
1858 // has a prefix "prebuilt_". Remove the prefix explicitly if needed until we find a better
1859 // solution to get the Import name.
Ulya Trafimovich497a0932021-07-14 16:35:33 +01001860 return android.RemoveOptionalPrebuiltPrefix(j.Name())
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001861}
1862
Colin Cross74d73e22017-08-02 11:05:49 -07001863var _ android.PrebuiltInterface = (*Import)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07001864
Bill Peckhamff89ffa2020-12-23 16:13:04 -08001865func (j *Import) IsInstallable() bool {
1866 return Bool(j.properties.Installable)
1867}
1868
Jiakai Zhang519c5c82021-09-16 06:15:39 +00001869var _ DexpreopterInterface = (*Import)(nil)
Bill Peckhamff89ffa2020-12-23 16:13:04 -08001870
Colin Cross1b16b0e2019-02-12 14:41:32 -08001871// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library module.
1872//
1873// By default, a java_import has a single variant that expects a `.jar` file containing `.class` files that were
1874// compiled against an Android classpath.
1875//
1876// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
1877// for host modules.
Colin Cross74d73e22017-08-02 11:05:49 -07001878func ImportFactory() android.Module {
1879 module := &Import{}
Colin Cross36242852017-06-23 15:06:31 -07001880
Liz Kammerd6c31d22020-08-05 15:40:41 -07001881 module.AddProperties(
1882 &module.properties,
1883 &module.dexer.dexProperties,
1884 )
Colin Cross74d73e22017-08-02 11:05:49 -07001885
Paul Duffin71b33cc2021-06-23 11:39:47 +01001886 module.initModuleAndImport(module)
Paul Duffin859fe962020-05-15 10:20:31 +01001887
Liz Kammerd6c31d22020-08-05 15:40:41 -07001888 module.dexProperties.Optimize.EnabledByDefault = false
1889
Colin Cross74d73e22017-08-02 11:05:49 -07001890 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09001891 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001892 android.InitSdkAwareModule(module)
Romain Jobredeaux428a3662022-01-28 11:12:52 -05001893 android.InitBazelModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09001894 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross36242852017-06-23 15:06:31 -07001895 return module
Colin Cross2fe66872015-03-30 17:20:39 -07001896}
1897
Colin Cross1b16b0e2019-02-12 14:41:32 -08001898// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library_host
1899// module.
1900//
1901// A java_import_host has a single variant that expects a `.jar` file containing `.class` files that were
1902// compiled against a host bootclasspath.
Colin Cross74d73e22017-08-02 11:05:49 -07001903func ImportFactoryHost() android.Module {
1904 module := &Import{}
1905
1906 module.AddProperties(&module.properties)
1907
1908 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09001909 android.InitApexModule(module)
Sam Delmerico5f83b492022-02-28 18:50:56 +00001910 android.InitBazelModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09001911 InitJavaModule(module, android.HostSupported)
Colin Cross74d73e22017-08-02 11:05:49 -07001912 return module
1913}
1914
Colin Cross42be7612019-02-21 18:12:14 -08001915// dex_import module
1916
1917type DexImportProperties struct {
Colin Cross5cfc70d2019-07-15 13:36:55 -07001918 Jars []string `android:"path"`
Jiyong Park4c4c0242019-10-21 14:53:15 +09001919
1920 // set the name of the output
1921 Stem *string
Colin Cross42be7612019-02-21 18:12:14 -08001922}
1923
1924type DexImport struct {
1925 android.ModuleBase
1926 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09001927 android.ApexModuleBase
Colin Cross42be7612019-02-21 18:12:14 -08001928 prebuilt android.Prebuilt
1929
1930 properties DexImportProperties
1931
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01001932 dexJarFile OptionalDexJarPath
Colin Cross42be7612019-02-21 18:12:14 -08001933
1934 dexpreopter
Colin Cross56a83212020-09-15 18:30:11 -07001935
1936 hideApexVariantFromMake bool
Colin Cross42be7612019-02-21 18:12:14 -08001937}
1938
1939func (j *DexImport) Prebuilt() *android.Prebuilt {
1940 return &j.prebuilt
1941}
1942
1943func (j *DexImport) PrebuiltSrcs() []string {
1944 return j.properties.Jars
1945}
1946
1947func (j *DexImport) Name() string {
1948 return j.prebuilt.Name(j.ModuleBase.Name())
1949}
1950
Jiyong Park0b238752019-10-29 11:23:10 +09001951func (j *DexImport) Stem() string {
1952 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
1953}
1954
Jiyong Park77acec62020-06-01 21:39:15 +09001955func (a *DexImport) JacocoReportClassesFile() android.Path {
1956 return nil
1957}
1958
Colin Cross08dca382020-07-21 20:31:17 -07001959func (a *DexImport) LintDepSets() LintDepSets {
1960 return LintDepSets{}
1961}
1962
Martin Stjernholm6d415272020-01-31 17:10:36 +00001963func (j *DexImport) IsInstallable() bool {
1964 return true
1965}
1966
Jaewoong Jung476b9d62021-05-10 15:30:00 -07001967func (j *DexImport) getStrictUpdatabilityLinting() bool {
1968 return false
1969}
1970
1971func (j *DexImport) setStrictUpdatabilityLinting(bool) {
1972}
1973
Colin Cross42be7612019-02-21 18:12:14 -08001974func (j *DexImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
1975 if len(j.properties.Jars) != 1 {
1976 ctx.PropertyErrorf("jars", "exactly one jar must be provided")
1977 }
1978
Colin Cross56a83212020-09-15 18:30:11 -07001979 apexInfo := ctx.Provider(android.ApexInfoProvider).(android.ApexInfo)
1980 if !apexInfo.IsForPlatform() {
1981 j.hideApexVariantFromMake = true
1982 }
1983
Jiakai Zhang519c5c82021-09-16 06:15:39 +00001984 j.dexpreopter.installPath = j.dexpreopter.getInstallPath(
1985 ctx, android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar"))
Colin Cross42be7612019-02-21 18:12:14 -08001986 j.dexpreopter.uncompressedDex = shouldUncompressDex(ctx, &j.dexpreopter)
1987
1988 inputJar := ctx.ExpandSource(j.properties.Jars[0], "jars")
1989 dexOutputFile := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar")
1990
1991 if j.dexpreopter.uncompressedDex {
Colin Crossf1a035e2020-11-16 17:32:30 -08001992 rule := android.NewRuleBuilder(pctx, ctx)
Colin Cross42be7612019-02-21 18:12:14 -08001993
1994 temporary := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar.unaligned")
1995 rule.Temporary(temporary)
1996
1997 // use zip2zip to uncompress classes*.dex files
1998 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08001999 BuiltTool("zip2zip").
Colin Cross42be7612019-02-21 18:12:14 -08002000 FlagWithInput("-i ", inputJar).
2001 FlagWithOutput("-o ", temporary).
2002 FlagWithArg("-0 ", "'classes*.dex'")
2003
2004 // use zipalign to align uncompressed classes*.dex files
2005 rule.Command().
Colin Crossf1a035e2020-11-16 17:32:30 -08002006 BuiltTool("zipalign").
Colin Cross42be7612019-02-21 18:12:14 -08002007 Flag("-f").
2008 Text("4").
2009 Input(temporary).
2010 Output(dexOutputFile)
2011
2012 rule.DeleteTemporaryFiles()
2013
Colin Crossf1a035e2020-11-16 17:32:30 -08002014 rule.Build("uncompress_dex", "uncompress dex")
Colin Cross42be7612019-02-21 18:12:14 -08002015 } else {
2016 ctx.Build(pctx, android.BuildParams{
2017 Rule: android.Cp,
2018 Input: inputJar,
2019 Output: dexOutputFile,
2020 })
2021 }
2022
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01002023 j.dexJarFile = makeDexJarPathFromPath(dexOutputFile)
Colin Cross42be7612019-02-21 18:12:14 -08002024
Jaewoong Jung4b97a562020-12-17 09:43:28 -08002025 j.dexpreopt(ctx, dexOutputFile)
Colin Cross42be7612019-02-21 18:12:14 -08002026
Colin Cross56a83212020-09-15 18:30:11 -07002027 if apexInfo.IsForPlatform() {
Jiyong Park01bca752020-06-08 19:24:09 +09002028 ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
2029 j.Stem()+".jar", dexOutputFile)
2030 }
Colin Cross42be7612019-02-21 18:12:14 -08002031}
2032
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01002033func (j *DexImport) DexJarBuildPath() OptionalDexJarPath {
Colin Cross42be7612019-02-21 18:12:14 -08002034 return j.dexJarFile
2035}
2036
Jiyong Park45bf82e2020-12-15 22:29:02 +09002037var _ android.ApexModule = (*DexImport)(nil)
2038
2039// Implements android.ApexModule
Dan Albertc8060532020-07-22 22:32:17 -07002040func (j *DexImport) ShouldSupportSdkVersion(ctx android.BaseModuleContext,
2041 sdkVersion android.ApiLevel) error {
Jooyung Han749dc692020-04-15 11:03:39 +09002042 // we don't check prebuilt modules for sdk_version
2043 return nil
2044}
2045
Colin Cross42be7612019-02-21 18:12:14 -08002046// dex_import imports a `.jar` file containing classes.dex files.
2047//
2048// A dex_import module cannot be used as a dependency of a java_* or android_* module, it can only be installed
2049// to the device.
2050func DexImportFactory() android.Module {
2051 module := &DexImport{}
2052
2053 module.AddProperties(&module.properties)
2054
2055 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002056 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002057 InitJavaModule(module, android.DeviceSupported)
Colin Cross42be7612019-02-21 18:12:14 -08002058 return module
2059}
2060
Colin Cross89536d42017-07-07 14:35:50 -07002061// Defaults
Colin Cross89536d42017-07-07 14:35:50 -07002062type Defaults struct {
2063 android.ModuleBase
2064 android.DefaultsModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002065 android.ApexModuleBase
Colin Cross89536d42017-07-07 14:35:50 -07002066}
2067
Colin Cross1b16b0e2019-02-12 14:41:32 -08002068// java_defaults provides a set of properties that can be inherited by other java or android modules.
2069//
2070// A module can use the properties from a java_defaults module using `defaults: ["defaults_module_name"]`. Each
2071// property in the defaults module that exists in the depending module will be prepended to the depending module's
2072// value for that property.
2073//
2074// Example:
2075//
Sam Delmerico277795c2022-02-25 17:04:37 +00002076// java_defaults {
2077// name: "example_defaults",
2078// srcs: ["common/**/*.java"],
2079// javacflags: ["-Xlint:all"],
2080// aaptflags: ["--auto-add-overlay"],
2081// }
Colin Cross1b16b0e2019-02-12 14:41:32 -08002082//
Sam Delmerico277795c2022-02-25 17:04:37 +00002083// java_library {
2084// name: "example",
2085// defaults: ["example_defaults"],
2086// srcs: ["example/**/*.java"],
2087// }
Colin Cross1b16b0e2019-02-12 14:41:32 -08002088//
2089// is functionally identical to:
2090//
Sam Delmerico277795c2022-02-25 17:04:37 +00002091// java_library {
2092// name: "example",
2093// srcs: [
2094// "common/**/*.java",
2095// "example/**/*.java",
2096// ],
2097// javacflags: ["-Xlint:all"],
2098// }
Paul Duffin47357662019-12-05 14:07:14 +00002099func DefaultsFactory() android.Module {
Colin Cross89536d42017-07-07 14:35:50 -07002100 module := &Defaults{}
2101
Colin Cross89536d42017-07-07 14:35:50 -07002102 module.AddProperties(
Jaewoong Jungbc15e3a2021-03-10 17:02:43 -08002103 &CommonProperties{},
2104 &DeviceProperties{},
Jooyung Han01d80d82022-01-08 12:16:32 +09002105 &OverridableDeviceProperties{},
Liz Kammera7a64f32020-07-09 15:16:41 -07002106 &DexProperties{},
Colin Cross43f08db2018-11-12 10:13:39 -08002107 &DexpreoptProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08002108 &android.ProtoProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002109 &aaptProperties{},
2110 &androidLibraryProperties{},
2111 &appProperties{},
2112 &appTestProperties{},
Jaewoong Jung525443a2019-02-28 15:35:54 -08002113 &overridableAppProperties{},
Roland Levillainb5b0ff32020-02-04 15:45:49 +00002114 &testProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002115 &ImportProperties{},
2116 &AARImportProperties{},
2117 &sdkLibraryProperties{},
Paul Duffin1b1e8062020-05-08 13:44:43 +01002118 &commonToSdkLibraryAndImportProperties{},
Colin Cross42be7612019-02-21 18:12:14 -08002119 &DexImportProperties{},
Jooyung Han18020ea2019-11-13 10:50:48 +09002120 &android.ApexProperties{},
Jaewoong Jungbf135462020-04-26 15:10:51 -07002121 &RuntimeResourceOverlayProperties{},
Colin Cross014489c2020-06-02 20:09:13 -07002122 &LintProperties{},
Colin Crosscbce0b02021-02-09 10:38:30 -08002123 &appTestHelperAppProperties{},
Colin Cross89536d42017-07-07 14:35:50 -07002124 )
2125
2126 android.InitDefaultsModule(module)
Colin Cross89536d42017-07-07 14:35:50 -07002127 return module
2128}
Nan Zhangea568a42017-11-08 21:20:04 -08002129
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002130func kytheExtractJavaFactory() android.Singleton {
2131 return &kytheExtractJavaSingleton{}
2132}
2133
2134type kytheExtractJavaSingleton struct {
2135}
2136
2137func (ks *kytheExtractJavaSingleton) GenerateBuildActions(ctx android.SingletonContext) {
2138 var xrefTargets android.Paths
2139 ctx.VisitAllModules(func(module android.Module) {
2140 if javaModule, ok := module.(xref); ok {
2141 xrefTargets = append(xrefTargets, javaModule.XrefJavaFiles()...)
2142 }
2143 })
2144 // TODO(asmundak): perhaps emit a rule to output a warning if there were no xrefTargets
2145 if len(xrefTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07002146 ctx.Phony("xref_java", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002147 }
2148}
2149
Nan Zhangea568a42017-11-08 21:20:04 -08002150var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07002151var BoolDefault = proptools.BoolDefault
Nan Zhangea568a42017-11-08 21:20:04 -08002152var String = proptools.String
Colin Cross0d0ba592018-02-20 13:33:42 -08002153var inList = android.InList
Ulya Trafimovich65b03192020-12-03 16:50:22 +00002154
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002155// Add class loader context (CLC) of a given dependency to the current CLC.
2156func addCLCFromDep(ctx android.ModuleContext, depModule android.Module,
2157 clcMap dexpreopt.ClassLoaderContextMap) {
2158
2159 dep, ok := depModule.(UsesLibraryDependency)
2160 if !ok {
2161 return
2162 }
2163
Ulya Trafimovich840efb62021-07-15 14:34:40 +01002164 depName := android.RemoveOptionalPrebuiltPrefix(ctx.OtherModuleName(depModule))
2165
2166 var sdkLib *string
2167 if lib, ok := depModule.(SdkLibraryDependency); ok && lib.sharedLibrary() {
2168 // A shared SDK library. This should be added as a top-level CLC element.
2169 sdkLib = &depName
2170 } else if ulib, ok := depModule.(ProvidesUsesLib); ok {
2171 // A non-SDK library disguised as an SDK library by the means of `provides_uses_lib`
2172 // property. This should be handled in the same way as a shared SDK library.
2173 sdkLib = ulib.ProvidesUsesLib()
Ulya Trafimovich65b03192020-12-03 16:50:22 +00002174 }
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002175
2176 depTag := ctx.OtherModuleDependencyTag(depModule)
Ulya Trafimovichfc0f6e32021-08-12 16:16:11 +01002177 if depTag == libTag {
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002178 // Ok, propagate <uses-library> through non-static library dependencies.
Ulya Trafimovichf5d91bb2022-05-04 12:00:02 +01002179 } else if tag, ok := depTag.(usesLibraryDependencyTag); ok && tag.sdkVersion == dexpreopt.AnySdkVersion {
2180 // Ok, propagate <uses-library> through non-compatibility <uses-library> dependencies.
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002181 } else if depTag == staticLibTag {
2182 // Propagate <uses-library> through static library dependencies, unless it is a component
2183 // library (such as stubs). Component libraries have a dependency on their SDK library,
2184 // which should not be pulled just because of a static component library.
Ulya Trafimovich840efb62021-07-15 14:34:40 +01002185 if sdkLib != nil {
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002186 return
2187 }
2188 } else {
2189 // Don't propagate <uses-library> for other dependency tags.
2190 return
2191 }
2192
Ulya Trafimovich840efb62021-07-15 14:34:40 +01002193 // If this is an SDK (or SDK-like) library, then it should be added as a node in the CLC tree,
2194 // and its CLC should be added as subtree of that node. Otherwise the library is not a
2195 // <uses_library> and should not be added to CLC, but the transitive <uses-library> dependencies
2196 // from its CLC should be added to the current CLC.
2197 if sdkLib != nil {
Ulya Trafimovichf5d91bb2022-05-04 12:00:02 +01002198 clcMap.AddContext(ctx, dexpreopt.AnySdkVersion, *sdkLib, false,
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01002199 dep.DexJarBuildPath().PathOrNil(), dep.DexJarInstallPath(), dep.ClassLoaderContexts())
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002200 } else {
Ulya Trafimovich88bb6f62020-12-16 16:16:11 +00002201 clcMap.AddContextMap(dep.ClassLoaderContexts(), depName)
2202 }
Ulya Trafimovich65b03192020-12-03 16:50:22 +00002203}
Wei Libafb6d62021-12-10 03:14:59 -08002204
Sam Delmerico79985812022-03-23 20:20:42 +00002205type javaResourcesAttributes struct {
2206 Resources bazel.LabelListAttribute
2207 Resource_strip_prefix *string
2208}
2209
2210func (m *Library) convertJavaResourcesAttributes(ctx android.TopDownMutatorContext) *javaResourcesAttributes {
2211 var resources bazel.LabelList
2212 var resourceStripPrefix *string
2213
2214 if m.properties.Java_resources != nil {
2215 resources.Append(android.BazelLabelForModuleSrc(ctx, m.properties.Java_resources))
2216 }
2217
2218 //TODO(b/179889880) handle case where glob includes files outside package
2219 resDeps := ResourceDirsToFiles(
2220 ctx,
2221 m.properties.Java_resource_dirs,
2222 m.properties.Exclude_java_resource_dirs,
2223 m.properties.Exclude_java_resources,
2224 )
2225
2226 for i, resDep := range resDeps {
2227 dir, files := resDep.dir, resDep.files
2228
2229 resources.Append(bazel.MakeLabelList(android.RootToModuleRelativePaths(ctx, files)))
2230
2231 // Bazel includes the relative path from the WORKSPACE root when placing the resource
2232 // inside the JAR file, so we need to remove that prefix
2233 resourceStripPrefix = proptools.StringPtr(dir.String())
2234 if i > 0 {
2235 // TODO(b/226423379) allow multiple resource prefixes
2236 ctx.ModuleErrorf("bp2build does not support more than one directory in java_resource_dirs (b/226423379)")
2237 }
2238 }
2239
2240 return &javaResourcesAttributes{
2241 Resources: bazel.MakeLabelListAttribute(resources),
2242 Resource_strip_prefix: resourceStripPrefix,
2243 }
2244}
2245
Sam Delmericoc0161432022-02-25 21:34:51 +00002246type javaCommonAttributes struct {
Sam Delmerico79985812022-03-23 20:20:42 +00002247 *javaResourcesAttributes
Wei Libafb6d62021-12-10 03:14:59 -08002248 Srcs bazel.LabelListAttribute
Sam Delmerico77267c72022-03-18 14:11:07 +00002249 Plugins bazel.LabelListAttribute
Wei Libafb6d62021-12-10 03:14:59 -08002250 Javacopts bazel.StringListAttribute
2251}
2252
Sam Delmericoc0161432022-02-25 21:34:51 +00002253type javaDependencyLabels struct {
2254 // Dependencies which DO NOT contribute to the API visible to upstream dependencies.
2255 Deps bazel.LabelListAttribute
2256 // Dependencies which DO contribute to the API visible to upstream dependencies.
2257 StaticDeps bazel.LabelListAttribute
2258}
2259
2260// convertLibraryAttrsBp2Build converts a few shared attributes from java_* modules
2261// and also separates dependencies into dynamic dependencies and static dependencies.
2262// Each corresponding Bazel target type, can have a different method for handling
2263// dynamic vs. static dependencies, and so these are returned to the calling function.
Sam Delmerico24da73c2022-03-16 20:36:54 +00002264type eventLogTagsAttributes struct {
2265 Srcs bazel.LabelListAttribute
2266}
2267
Sam Delmericoc0161432022-02-25 21:34:51 +00002268func (m *Library) convertLibraryAttrsBp2Build(ctx android.TopDownMutatorContext) (*javaCommonAttributes, *javaDependencyLabels) {
Sam Delmericoe91d0302022-02-23 15:28:33 +00002269 var srcs bazel.LabelListAttribute
2270 archVariantProps := m.GetArchVariantProperties(ctx, &CommonProperties{})
2271 for axis, configToProps := range archVariantProps {
2272 for config, _props := range configToProps {
2273 if archProps, ok := _props.(*CommonProperties); ok {
2274 archSrcs := android.BazelLabelForModuleSrcExcludes(ctx, archProps.Srcs, archProps.Exclude_srcs)
2275 srcs.SetSelectValue(axis, config, archSrcs)
2276 }
2277 }
2278 }
Sam Delmericoc7681022022-02-04 21:01:20 +00002279
2280 javaSrcPartition := "java"
2281 protoSrcPartition := "proto"
Sam Delmerico24da73c2022-03-16 20:36:54 +00002282 logtagSrcPartition := "logtag"
Sam Delmericoc7681022022-02-04 21:01:20 +00002283 srcPartitions := bazel.PartitionLabelListAttribute(ctx, &srcs, bazel.LabelPartitions{
Sam Delmerico24da73c2022-03-16 20:36:54 +00002284 javaSrcPartition: bazel.LabelPartition{Extensions: []string{".java"}, Keep_remainder: true},
2285 logtagSrcPartition: bazel.LabelPartition{Extensions: []string{".logtags", ".logtag"}},
2286 protoSrcPartition: android.ProtoSrcLabelPartition,
Sam Delmericoc7681022022-02-04 21:01:20 +00002287 })
2288
Sam Delmerico24da73c2022-03-16 20:36:54 +00002289 javaSrcs := srcPartitions[javaSrcPartition]
2290
2291 var logtagsSrcs bazel.LabelList
2292 if !srcPartitions[logtagSrcPartition].IsEmpty() {
2293 logtagsLibName := m.Name() + "_logtags"
2294 logtagsSrcs = bazel.MakeLabelList([]bazel.Label{{Label: ":" + logtagsLibName}})
2295 ctx.CreateBazelTargetModule(
2296 bazel.BazelTargetModuleProperties{
2297 Rule_class: "event_log_tags",
2298 Bzl_load_location: "//build/make/tools:event_log_tags.bzl",
2299 },
2300 android.CommonAttributes{Name: logtagsLibName},
2301 &eventLogTagsAttributes{
2302 Srcs: srcPartitions[logtagSrcPartition],
2303 },
2304 )
2305 }
2306 javaSrcs.Append(bazel.MakeLabelListAttribute(logtagsSrcs))
2307
Sam Delmerico58614c02022-03-15 21:02:09 +00002308 var javacopts []string
2309 if m.properties.Javacflags != nil {
2310 javacopts = append(javacopts, m.properties.Javacflags...)
2311 }
Vinh Tran3ac6daf2022-04-22 19:09:58 -04002312 if m.properties.Java_version != nil {
2313 javaVersion := normalizeJavaVersion(ctx, *m.properties.Java_version).String()
2314 javacopts = append(javacopts, fmt.Sprintf("-source %s -target %s", javaVersion, javaVersion))
2315 }
2316
Sam Delmerico58614c02022-03-15 21:02:09 +00002317 epEnabled := m.properties.Errorprone.Enabled
2318 //TODO(b/227504307) add configuration that depends on RUN_ERROR_PRONE environment variable
2319 if Bool(epEnabled) {
2320 javacopts = append(javacopts, m.properties.Errorprone.Javacflags...)
2321 }
2322
Sam Delmericoc0161432022-02-25 21:34:51 +00002323 commonAttrs := &javaCommonAttributes{
Sam Delmerico79985812022-03-23 20:20:42 +00002324 Srcs: javaSrcs,
2325 javaResourcesAttributes: m.convertJavaResourcesAttributes(ctx),
Sam Delmerico77267c72022-03-18 14:11:07 +00002326 Plugins: bazel.MakeLabelListAttribute(
2327 android.BazelLabelForModuleDeps(ctx, m.properties.Plugins),
2328 ),
Sam Delmerico58614c02022-03-15 21:02:09 +00002329 Javacopts: bazel.MakeStringListAttribute(javacopts),
Wei Libafb6d62021-12-10 03:14:59 -08002330 }
2331
Sam Delmericoc0161432022-02-25 21:34:51 +00002332 depLabels := &javaDependencyLabels{}
2333
Sam Delmericofde9fb52022-01-28 20:53:38 +00002334 var deps bazel.LabelList
Wei Libafb6d62021-12-10 03:14:59 -08002335 if m.properties.Libs != nil {
Sam Delmericofde9fb52022-01-28 20:53:38 +00002336 deps.Append(android.BazelLabelForModuleDeps(ctx, m.properties.Libs))
Wei Libafb6d62021-12-10 03:14:59 -08002337 }
Sam Delmericoc0161432022-02-25 21:34:51 +00002338
2339 var staticDeps bazel.LabelList
Sam Delmericofde9fb52022-01-28 20:53:38 +00002340 if m.properties.Static_libs != nil {
Sam Delmericoc0161432022-02-25 21:34:51 +00002341 staticDeps.Append(android.BazelLabelForModuleDeps(ctx, m.properties.Static_libs))
Sam Delmericofde9fb52022-01-28 20:53:38 +00002342 }
Sam Delmericoc7681022022-02-04 21:01:20 +00002343
Sam Delmericoc0161432022-02-25 21:34:51 +00002344 protoDepLabel := bp2buildProto(ctx, &m.Module, srcPartitions[protoSrcPartition])
2345 // Soong does not differentiate between a java_library and the Bazel equivalent of
2346 // a java_proto_library + proto_library pair. Instead, in Soong proto sources are
2347 // listed directly in the srcs of a java_library, and the classes produced
2348 // by protoc are included directly in the resulting JAR. Thus upstream dependencies
2349 // that depend on a java_library with proto sources can link directly to the protobuf API,
2350 // and so this should be a static dependency.
2351 staticDeps.Add(protoDepLabel)
Sam Delmericoc7681022022-02-04 21:01:20 +00002352
Sam Delmericoc0161432022-02-25 21:34:51 +00002353 depLabels.Deps = bazel.MakeLabelListAttribute(deps)
2354 depLabels.StaticDeps = bazel.MakeLabelListAttribute(staticDeps)
Sam Delmericofde9fb52022-01-28 20:53:38 +00002355
Sam Delmericoc0161432022-02-25 21:34:51 +00002356 return commonAttrs, depLabels
2357}
2358
2359type javaLibraryAttributes struct {
2360 *javaCommonAttributes
2361 Deps bazel.LabelListAttribute
2362 Exports bazel.LabelListAttribute
Sam Delmericofde9fb52022-01-28 20:53:38 +00002363}
2364
2365func javaLibraryBp2Build(ctx android.TopDownMutatorContext, m *Library) {
Sam Delmericoc0161432022-02-25 21:34:51 +00002366 commonAttrs, depLabels := m.convertLibraryAttrsBp2Build(ctx)
2367
2368 deps := depLabels.Deps
2369 if !commonAttrs.Srcs.IsEmpty() {
2370 deps.Append(depLabels.StaticDeps) // we should only append these if there are sources to use them
2371
2372 sdkVersion := m.SdkVersion(ctx)
2373 if sdkVersion.Kind == android.SdkPublic && sdkVersion.ApiLevel == android.FutureApiLevel {
2374 // TODO(b/220869005) remove forced dependency on current public android.jar
2375 deps.Add(bazel.MakeLabelAttribute("//prebuilts/sdk:public_current_android_sdk_java_import"))
2376 }
2377 } else if !depLabels.Deps.IsEmpty() {
2378 ctx.ModuleErrorf("Module has direct dependencies but no sources. Bazel will not allow this.")
2379 }
2380
2381 attrs := &javaLibraryAttributes{
2382 javaCommonAttributes: commonAttrs,
2383 Deps: deps,
2384 Exports: depLabels.StaticDeps,
2385 }
Wei Libafb6d62021-12-10 03:14:59 -08002386
2387 props := bazel.BazelTargetModuleProperties{
2388 Rule_class: "java_library",
2389 Bzl_load_location: "//build/bazel/rules/java:library.bzl",
2390 }
2391
2392 ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: m.Name()}, attrs)
2393}
2394
2395type javaBinaryHostAttributes struct {
Sam Delmericoc0161432022-02-25 21:34:51 +00002396 *javaCommonAttributes
2397 Deps bazel.LabelListAttribute
2398 Runtime_deps bazel.LabelListAttribute
2399 Main_class string
2400 Jvm_flags bazel.StringListAttribute
Wei Libafb6d62021-12-10 03:14:59 -08002401}
2402
2403// JavaBinaryHostBp2Build is for java_binary_host bp2build.
2404func javaBinaryHostBp2Build(ctx android.TopDownMutatorContext, m *Binary) {
Sam Delmericoc0161432022-02-25 21:34:51 +00002405 commonAttrs, depLabels := m.convertLibraryAttrsBp2Build(ctx)
2406
2407 deps := depLabels.Deps
2408 deps.Append(depLabels.StaticDeps)
2409 if m.binaryProperties.Jni_libs != nil {
2410 deps.Append(bazel.MakeLabelListAttribute(android.BazelLabelForModuleDeps(ctx, m.binaryProperties.Jni_libs)))
2411 }
2412
2413 var runtimeDeps bazel.LabelListAttribute
2414 if commonAttrs.Srcs.IsEmpty() {
2415 // if there are no sources, then the dependencies can only be used at runtime
2416 runtimeDeps = deps
2417 deps = bazel.LabelListAttribute{}
2418 }
2419
Wei Libafb6d62021-12-10 03:14:59 -08002420 mainClass := ""
2421 if m.binaryProperties.Main_class != nil {
2422 mainClass = *m.binaryProperties.Main_class
2423 }
2424 if m.properties.Manifest != nil {
2425 mainClassInManifest, err := android.GetMainClassInManifest(ctx.Config(), android.PathForModuleSrc(ctx, *m.properties.Manifest).String())
2426 if err != nil {
2427 return
2428 }
2429 mainClass = mainClassInManifest
2430 }
Sam Delmericoc0161432022-02-25 21:34:51 +00002431
Wei Libafb6d62021-12-10 03:14:59 -08002432 attrs := &javaBinaryHostAttributes{
Sam Delmericoc0161432022-02-25 21:34:51 +00002433 javaCommonAttributes: commonAttrs,
2434 Deps: deps,
2435 Runtime_deps: runtimeDeps,
2436 Main_class: mainClass,
Wei Libafb6d62021-12-10 03:14:59 -08002437 }
2438
2439 // Attribute jvm_flags
2440 if m.binaryProperties.Jni_libs != nil {
2441 jniLibPackages := map[string]bool{}
2442 for _, jniLibLabel := range android.BazelLabelForModuleDeps(ctx, m.binaryProperties.Jni_libs).Includes {
2443 jniLibPackage := jniLibLabel.Label
2444 indexOfColon := strings.Index(jniLibLabel.Label, ":")
2445 if indexOfColon > 0 {
2446 // JNI lib from other package
2447 jniLibPackage = jniLibLabel.Label[2:indexOfColon]
2448 } else if indexOfColon == 0 {
2449 // JNI lib in the same package of java_binary
2450 packageOfCurrentModule := m.GetBazelLabel(ctx, m)
2451 jniLibPackage = packageOfCurrentModule[2:strings.Index(packageOfCurrentModule, ":")]
2452 }
2453 if _, inMap := jniLibPackages[jniLibPackage]; !inMap {
2454 jniLibPackages[jniLibPackage] = true
2455 }
2456 }
2457 jniLibPaths := []string{}
2458 for jniLibPackage, _ := range jniLibPackages {
2459 // See cs/f:.*/third_party/bazel/.*java_stub_template.txt for the use of RUNPATH
2460 jniLibPaths = append(jniLibPaths, "$${RUNPATH}"+jniLibPackage)
2461 }
2462 attrs.Jvm_flags = bazel.MakeStringListAttribute([]string{"-Djava.library.path=" + strings.Join(jniLibPaths, ":")})
2463 }
2464
2465 props := bazel.BazelTargetModuleProperties{
2466 Rule_class: "java_binary",
2467 }
2468
2469 // Create the BazelTargetModule.
2470 ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: m.Name()}, attrs)
2471}
Romain Jobredeaux428a3662022-01-28 11:12:52 -05002472
2473type bazelJavaImportAttributes struct {
2474 Jars bazel.LabelListAttribute
2475}
2476
2477// java_import bp2Build converter.
2478func (i *Import) ConvertWithBp2build(ctx android.TopDownMutatorContext) {
Sam Delmerico48983162022-02-22 21:41:33 +00002479 var jars bazel.LabelListAttribute
2480 archVariantProps := i.GetArchVariantProperties(ctx, &ImportProperties{})
2481 for axis, configToProps := range archVariantProps {
2482 for config, _props := range configToProps {
2483 if archProps, ok := _props.(*ImportProperties); ok {
2484 archJars := android.BazelLabelForModuleSrcExcludes(ctx, archProps.Jars, []string(nil))
2485 jars.SetSelectValue(axis, config, archJars)
2486 }
2487 }
2488 }
Romain Jobredeaux428a3662022-01-28 11:12:52 -05002489
2490 attrs := &bazelJavaImportAttributes{
2491 Jars: jars,
2492 }
2493 props := bazel.BazelTargetModuleProperties{Rule_class: "java_import"}
2494
2495 ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: android.RemoveOptionalPrebuiltPrefix(i.Name())}, attrs)
Sam Delmerico277795c2022-02-25 17:04:37 +00002496}
Romain Jobredeaux428a3662022-01-28 11:12:52 -05002497
Sam Delmerico277795c2022-02-25 17:04:37 +00002498var _ android.MixedBuildBuildable = (*Import)(nil)
2499
2500func (i *Import) getBazelModuleLabel(ctx android.BaseModuleContext) string {
2501 return android.RemoveOptionalPrebuiltPrefixFromBazelLabel(i.GetBazelLabel(ctx, i))
2502}
2503
2504func (i *Import) ProcessBazelQueryResponse(ctx android.ModuleContext) {
2505 i.commonBuildActions(ctx)
2506
2507 bazelCtx := ctx.Config().BazelContext
2508 filePaths, err := bazelCtx.GetOutputFiles(i.getBazelModuleLabel(ctx), android.GetConfigKey(ctx))
2509 if err != nil {
2510 ctx.ModuleErrorf(err.Error())
2511 return
2512 }
2513
2514 bazelJars := android.Paths{}
2515 for _, bazelOutputFile := range filePaths {
2516 bazelJars = append(bazelJars, android.PathForBazelOut(ctx, bazelOutputFile))
2517 }
2518
2519 jarName := android.RemoveOptionalPrebuiltPrefix(i.Name()) + ".jar"
2520 outputFile := android.PathForModuleOut(ctx, "bazelCombined", jarName)
2521 TransformJarsToJar(ctx, outputFile, "combine prebuilt jars", bazelJars,
2522 android.OptionalPath{}, // manifest
2523 false, // stripDirEntries
2524 []string{}, // filesToStrip
2525 []string{}, // dirsToStrip
2526 )
2527 i.combinedClasspathFile = outputFile
2528
2529 ctx.SetProvider(JavaInfoProvider, JavaInfo{
2530 HeaderJars: android.PathsIfNonNil(i.combinedClasspathFile),
2531 ImplementationAndResourcesJars: android.PathsIfNonNil(i.combinedClasspathFile),
2532 ImplementationJars: android.PathsIfNonNil(i.combinedClasspathFile),
2533 //TODO(b/240308299) include AIDL information from Bazel
2534 })
2535
2536 i.maybeInstall(ctx, jarName, outputFile)
2537}
2538
2539func (i *Import) QueueBazelCall(ctx android.BaseModuleContext) {
2540 bazelCtx := ctx.Config().BazelContext
2541 bazelCtx.QueueBazelRequest(i.getBazelModuleLabel(ctx), cquery.GetOutputFiles, android.GetConfigKey(ctx))
2542}
2543
2544func (i *Import) IsMixedBuildSupported(ctx android.BaseModuleContext) bool {
2545 return true
Romain Jobredeaux428a3662022-01-28 11:12:52 -05002546}