blob: 066e09afbb11313625edeec7f3d6d777ec9f3741 [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"
Colin Cross74d73e22017-08-02 11:05:49 -070024 "strconv"
Colin Cross2fe66872015-03-30 17:20:39 -070025 "strings"
26
27 "github.com/google/blueprint"
Colin Cross3b706fd2019-09-05 16:44:18 -070028 "github.com/google/blueprint/pathtools"
Colin Cross76b5f0c2017-08-29 16:02:06 -070029 "github.com/google/blueprint/proptools"
Colin Cross2fe66872015-03-30 17:20:39 -070030
Colin Cross635c3b02016-05-18 15:37:25 -070031 "android/soong/android"
Colin Cross3e3e72d2017-06-22 17:20:19 -070032 "android/soong/java/config"
Colin Cross303e21f2018-08-07 16:49:25 -070033 "android/soong/tradefed"
Colin Cross2fe66872015-03-30 17:20:39 -070034)
35
Colin Cross463a90e2015-06-17 14:20:06 -070036func init() {
Paul Duffinf9b1da02019-12-18 19:51:55 +000037 RegisterJavaBuildComponents(android.InitRegistrationContext)
Paul Duffin255f18e2019-12-13 11:22:16 +000038
39 // Register sdk member types.
Paul Duffin7b81f5e2020-01-13 21:03:22 +000040 android.RegisterSdkMemberType(javaHeaderLibsSdkMemberType)
Paul Duffin255f18e2019-12-13 11:22:16 +000041
Paul Duffin2b9e3d32020-02-28 14:39:53 +000042 android.RegisterSdkMemberType(&librarySdkMemberType{
43 android.SdkMemberTypeBase{
44 PropertyName: "java_libs",
45 },
46 func(j *Library) android.Path {
47 implementationJars := j.ImplementationJars()
48 if len(implementationJars) != 1 {
49 panic(fmt.Errorf("there must be only one implementation jar from %q", j.Name()))
50 }
51
52 return implementationJars[0]
Paul Duffin255f18e2019-12-13 11:22:16 +000053 },
54 })
Paul Duffin1b82e6a2019-12-03 18:06:47 +000055
56 android.RegisterSdkMemberType(&testSdkMemberType{
57 SdkMemberTypeBase: android.SdkMemberTypeBase{
58 PropertyName: "java_tests",
59 },
60 })
Colin Cross463a90e2015-06-17 14:20:06 -070061}
62
Paul Duffinf9b1da02019-12-18 19:51:55 +000063func RegisterJavaBuildComponents(ctx android.RegistrationContext) {
64 ctx.RegisterModuleType("java_defaults", DefaultsFactory)
65
66 ctx.RegisterModuleType("java_library", LibraryFactory)
67 ctx.RegisterModuleType("java_library_static", LibraryStaticFactory)
68 ctx.RegisterModuleType("java_library_host", LibraryHostFactory)
69 ctx.RegisterModuleType("java_binary", BinaryFactory)
70 ctx.RegisterModuleType("java_binary_host", BinaryHostFactory)
71 ctx.RegisterModuleType("java_test", TestFactory)
72 ctx.RegisterModuleType("java_test_helper_library", TestHelperLibraryFactory)
73 ctx.RegisterModuleType("java_test_host", TestHostFactory)
Paul Duffin1b82e6a2019-12-03 18:06:47 +000074 ctx.RegisterModuleType("java_test_import", JavaTestImportFactory)
Paul Duffinf9b1da02019-12-18 19:51:55 +000075 ctx.RegisterModuleType("java_import", ImportFactory)
76 ctx.RegisterModuleType("java_import_host", ImportFactoryHost)
77 ctx.RegisterModuleType("java_device_for_host", DeviceForHostFactory)
78 ctx.RegisterModuleType("java_host_for_device", HostForDeviceFactory)
79 ctx.RegisterModuleType("dex_import", DexImportFactory)
80
Martin Stjernholm6d415272020-01-31 17:10:36 +000081 ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
82 ctx.BottomUp("dexpreopt_tool_deps", dexpreoptToolDepsMutator).Parallel()
83 })
Martin Stjernholmd90676f2020-01-11 00:37:30 +000084
Paul Duffinf9b1da02019-12-18 19:51:55 +000085 ctx.RegisterSingletonType("logtags", LogtagsSingleton)
86 ctx.RegisterSingletonType("kythe_java_extract", kytheExtractJavaFactory)
87}
88
Artur Satayev2eedf622020-04-15 17:29:42 +010089func (j *Module) CheckStableSdkVersion() error {
90 sdkVersion := j.sdkVersion()
91 if sdkVersion.stable() {
92 return nil
93 }
94 return fmt.Errorf("non stable SDK %v", sdkVersion)
95}
96
Artur Satayeve5ac15a2020-04-08 19:09:30 +010097func (j *Module) checkSdkVersions(ctx android.ModuleContext) {
Colin Crosseb032962020-05-13 11:05:02 -070098 if j.RequiresStableAPIs(ctx) {
Jeongik Cha2cc570d2019-10-29 15:44:45 +090099 if sc, ok := ctx.Module().(sdkContext); ok {
Jiyong Park6a927c42020-01-21 02:03:43 +0900100 if !sc.sdkVersion().specified() {
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900101 ctx.PropertyErrorf("sdk_version",
102 "sdk_version must have a value when the module is located at vendor or product(only if PRODUCT_ENFORCE_PRODUCT_PARTITION_INTERFACE is set).")
103 }
104 }
105 }
Artur Satayeve5ac15a2020-04-08 19:09:30 +0100106
107 ctx.VisitDirectDeps(func(module android.Module) {
108 tag := ctx.OtherModuleDependencyTag(module)
109 switch module.(type) {
110 // TODO(satayev): cover other types as well, e.g. imports
111 case *Library, *AndroidLibrary:
112 switch tag {
113 case bootClasspathTag, libTag, staticLibTag, java9LibTag:
114 checkLinkType(ctx, j, module.(linkTypeContext), tag.(dependencyTag))
115 }
116 }
117 })
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900118}
119
Jeongik Cha538c0d02019-07-11 15:54:27 +0900120func (j *Module) checkPlatformAPI(ctx android.ModuleContext) {
121 if sc, ok := ctx.Module().(sdkContext); ok {
122 usePlatformAPI := proptools.Bool(j.deviceProperties.Platform_apis)
Jiyong Park6a927c42020-01-21 02:03:43 +0900123 sdkVersionSpecified := sc.sdkVersion().specified()
124 if usePlatformAPI && sdkVersionSpecified {
125 ctx.PropertyErrorf("platform_apis", "platform_apis must be false when sdk_version is not empty.")
126 } else if !usePlatformAPI && !sdkVersionSpecified {
127 ctx.PropertyErrorf("platform_apis", "platform_apis must be true when sdk_version is empty.")
Jeongik Cha538c0d02019-07-11 15:54:27 +0900128 }
129
130 }
131}
132
Colin Cross2fe66872015-03-30 17:20:39 -0700133// TODO:
134// Autogenerated files:
Colin Cross2fe66872015-03-30 17:20:39 -0700135// Renderscript
136// Post-jar passes:
137// Proguard
Colin Cross2fe66872015-03-30 17:20:39 -0700138// Rmtypedefs
Colin Cross2fe66872015-03-30 17:20:39 -0700139// DroidDoc
140// Findbugs
141
Colin Cross89536d42017-07-07 14:35:50 -0700142type CompilerProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -0700143 // list of source files used to compile the Java module. May be .java, .logtags, .proto,
144 // or .aidl files.
Colin Cross27b922f2019-03-04 22:35:41 -0800145 Srcs []string `android:"path,arch_variant"`
Dan Willemsen2ef08f42015-06-30 18:15:24 -0700146
147 // list of source files that should not be used to build the Java module.
148 // This is most useful in the arch/multilib variants to remove non-common files
Colin Cross27b922f2019-03-04 22:35:41 -0800149 Exclude_srcs []string `android:"path,arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700150
151 // list of directories containing Java resources
Colin Cross86a63ff2017-09-27 17:33:10 -0700152 Java_resource_dirs []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700153
Colin Cross86a63ff2017-09-27 17:33:10 -0700154 // list of directories that should be excluded from java_resource_dirs
155 Exclude_java_resource_dirs []string `android:"arch_variant"`
Dan Willemsen2ef08f42015-06-30 18:15:24 -0700156
Colin Cross0f37af02017-09-27 17:42:05 -0700157 // list of files to use as Java resources
Colin Cross27b922f2019-03-04 22:35:41 -0800158 Java_resources []string `android:"path,arch_variant"`
Colin Cross0f37af02017-09-27 17:42:05 -0700159
Colin Crosscedd4762018-09-13 11:26:19 -0700160 // list of files that should be excluded from java_resources and java_resource_dirs
Colin Cross27b922f2019-03-04 22:35:41 -0800161 Exclude_java_resources []string `android:"path,arch_variant"`
Colin Cross0f37af02017-09-27 17:42:05 -0700162
Colin Cross7d5136f2015-05-11 13:39:40 -0700163 // list of module-specific flags that will be used for javac compiles
164 Javacflags []string `android:"arch_variant"`
165
Zoran Jovanovic8736ce22018-08-21 17:10:29 +0200166 // list of module-specific flags that will be used for kotlinc compiles
167 Kotlincflags []string `android:"arch_variant"`
168
Colin Cross7d5136f2015-05-11 13:39:40 -0700169 // list of of java libraries that will be in the classpath
Colin Crosse8dc34a2017-07-19 11:22:16 -0700170 Libs []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700171
172 // list of java libraries that will be compiled into the resulting jar
Colin Crosse8dc34a2017-07-19 11:22:16 -0700173 Static_libs []string `android:"arch_variant"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700174
175 // manifest file to be included in resulting jar
Colin Cross27b922f2019-03-04 22:35:41 -0800176 Manifest *string `android:"path"`
Colin Cross7d5136f2015-05-11 13:39:40 -0700177
Colin Cross540eff82017-06-22 17:01:52 -0700178 // if not blank, run jarjar using the specified rules file
Colin Cross27b922f2019-03-04 22:35:41 -0800179 Jarjar_rules *string `android:"path,arch_variant"`
Colin Cross64162712017-08-08 13:17:59 -0700180
181 // If not blank, set the java version passed to javac as -source and -target
182 Java_version *string
Colin Cross2c429dc2017-08-31 16:45:16 -0700183
Colin Cross9ae1b922018-06-26 17:59:05 -0700184 // If set to true, allow this module to be dexed and installed on devices. Has no
185 // effect on host modules, which are always considered installable.
Colin Cross2c429dc2017-08-31 16:45:16 -0700186 Installable *bool
Colin Cross32f676a2017-09-06 13:41:06 -0700187
Colin Cross0f37af02017-09-27 17:42:05 -0700188 // If set to true, include sources used to compile the module in to the final jar
189 Include_srcs *bool
190
Vladimir Marko0975ee02019-04-02 10:29:55 +0100191 // If not empty, classes are restricted to the specified packages and their sub-packages.
192 // This restriction is checked after applying jarjar rules and including static libs.
193 Permitted_packages []string
194
Colin Crossbe9cdb82019-01-21 21:37:16 -0800195 // List of modules to use as annotation processors
196 Plugins []string
Colin Cross1369cdb2017-09-29 17:58:17 -0700197
Artur Satayev9cf46692019-11-26 18:08:34 +0000198 // List of modules to export to libraries that directly depend on this library as annotation processors
199 Exported_plugins []string
200
Nan Zhang61eaedb2017-11-02 13:28:15 -0700201 // The number of Java source entries each Javac instance can process
202 Javac_shard_size *int64
203
Nan Zhang5f8cb422018-02-06 10:34:32 -0800204 // Add host jdk tools.jar to bootclasspath
205 Use_tools_jar *bool
206
Colin Cross1369cdb2017-09-29 17:58:17 -0700207 Openjdk9 struct {
Colin Cross6cef4812019-10-17 14:23:50 -0700208 // List of source files that should only be used when passing -source 1.9 or higher
Colin Cross27b922f2019-03-04 22:35:41 -0800209 Srcs []string `android:"path"`
Colin Cross1369cdb2017-09-29 17:58:17 -0700210
Colin Cross6cef4812019-10-17 14:23:50 -0700211 // List of javac flags that should only be used when passing -source 1.9 or higher
Colin Cross1369cdb2017-09-29 17:58:17 -0700212 Javacflags []string
213 }
Colin Crosscb933592017-11-22 13:49:43 -0800214
Colin Cross81440082018-08-15 20:21:55 -0700215 // When compiling language level 9+ .java code in packages that are part of
216 // a system module, patch_module names the module that your sources and
217 // dependencies should be patched into. The Android runtime currently
218 // doesn't implement the JEP 261 module system so this option is only
219 // supported at compile time. It should only be needed to compile tests in
220 // packages that exist in libcore and which are inconvenient to move
221 // elsewhere.
Tobias Thiererdda713d2018-09-19 16:16:19 +0100222 Patch_module *string `android:"arch_variant"`
Colin Cross81440082018-08-15 20:21:55 -0700223
Colin Crosscb933592017-11-22 13:49:43 -0800224 Jacoco struct {
225 // List of classes to include for instrumentation with jacoco to collect coverage
226 // information at runtime when building with coverage enabled. If unset defaults to all
227 // classes.
228 // Supports '*' as the last character of an entry in the list as a wildcard match.
229 // If preceded by '.' it matches all classes in the package and subpackages, otherwise
230 // it matches classes in the package that have the class name as a prefix.
231 Include_filter []string
232
233 // List of classes to exclude from instrumentation with jacoco to collect coverage
234 // information at runtime when building with coverage enabled. Overrides classes selected
235 // by the include_filter property.
236 // Supports '*' as the last character of an entry in the list as a wildcard match.
237 // If preceded by '.' it matches all classes in the package and subpackages, otherwise
238 // it matches classes in the package that have the class name as a prefix.
239 Exclude_filter []string
240 }
241
Andreas Gampef3e5b552018-01-22 21:27:21 -0800242 Errorprone struct {
243 // List of javac flags that should only be used when running errorprone.
244 Javacflags []string
245 }
246
Colin Cross0f2ee152017-12-14 15:22:43 -0800247 Proto struct {
248 // List of extra options that will be passed to the proto generator.
249 Output_params []string
250 }
251
Colin Crosscb933592017-11-22 13:49:43 -0800252 Instrument bool `blueprint:"mutated"`
Alex Light7f004a72019-02-21 13:27:37 -0800253
254 // List of files to include in the META-INF/services folder of the resulting jar.
Colin Cross27b922f2019-03-04 22:35:41 -0800255 Services []string `android:"path,arch_variant"`
Colin Cross540eff82017-06-22 17:01:52 -0700256}
257
Colin Cross89536d42017-07-07 14:35:50 -0700258type CompilerDeviceProperties struct {
Colin Cross540eff82017-06-22 17:01:52 -0700259 // list of module-specific flags that will be used for dex compiles
260 Dxflags []string `android:"arch_variant"`
261
Jeongik Cha538c0d02019-07-11 15:54:27 +0900262 // if not blank, set to the version of the sdk to compile against.
263 // Defaults to compiling against the current platform.
Nan Zhangea568a42017-11-08 21:20:04 -0800264 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700265
Colin Cross83bb3162018-06-25 15:48:06 -0700266 // if not blank, set the minimum version of the sdk that the compiled artifacts will run against.
267 // Defaults to sdk_version if not set.
268 Min_sdk_version *string
269
Dan Willemsen419290a2018-10-31 15:28:47 -0700270 // if not blank, set the targetSdkVersion in the AndroidManifest.xml.
271 // Defaults to sdk_version if not set.
272 Target_sdk_version *string
273
Jeongik Cha356dac42019-08-19 14:09:52 +0900274 // Whether to compile against the platform APIs instead of an SDK.
275 // If true, then sdk_version must be empty. The value of this field
276 // is ignored when module's type isn't android_app.
Colin Cross6af2e492018-05-22 11:12:33 -0700277 Platform_apis *bool
278
Colin Crossebe1a512017-11-14 13:12:14 -0800279 Aidl struct {
280 // Top level directories to pass to aidl tool
281 Include_dirs []string
Colin Cross7d5136f2015-05-11 13:39:40 -0700282
Colin Crossebe1a512017-11-14 13:12:14 -0800283 // Directories rooted at the Android.bp file to pass to aidl tool
284 Local_include_dirs []string
285
286 // directories that should be added as include directories for any aidl sources of modules
287 // that depend on this module, as well as to aidl for this module.
288 Export_include_dirs []string
Martijn Coeneneab15642018-03-09 09:29:59 +0100289
290 // whether to generate traces (for systrace) for this interface
291 Generate_traces *bool
Olivier Gaillard0a4cfbc2018-07-16 23:37:03 +0100292
293 // whether to generate Binder#GetTransaction name method.
294 Generate_get_transaction_name *bool
Colin Crossebe1a512017-11-14 13:12:14 -0800295 }
Colin Cross92430102017-10-09 14:59:32 -0700296
297 // If true, export a copy of the module as a -hostdex module for host testing.
298 Hostdex *bool
Colin Cross1369cdb2017-09-29 17:58:17 -0700299
Colin Cross7f87f4f2019-04-24 13:41:45 -0700300 Target struct {
301 Hostdex struct {
302 // Additional required dependencies to add to -hostdex modules.
303 Required []string
304 }
305 }
306
David Brazdil17ef5632018-06-27 10:27:45 +0100307 // If set to true, compile dex regardless of installable. Defaults to false.
308 Compile_dex *bool
309
Colin Cross66dbc0b2017-12-28 12:23:20 -0800310 Optimize struct {
Colin Crossae5caf52018-05-22 11:11:52 -0700311 // If false, disable all optimization. Defaults to true for android_app and android_test
312 // modules, false for java_library and java_test modules.
Colin Cross66dbc0b2017-12-28 12:23:20 -0800313 Enabled *bool
Sasha Smundak2057f822019-04-16 17:16:58 -0700314 // True if the module containing this has it set by default.
315 EnabledByDefault bool `blueprint:"mutated"`
Colin Cross66dbc0b2017-12-28 12:23:20 -0800316
317 // If true, optimize for size by removing unused code. Defaults to true for apps,
318 // false for libraries and tests.
319 Shrink *bool
320
321 // If true, optimize bytecode. Defaults to false.
322 Optimize *bool
323
324 // If true, obfuscate bytecode. Defaults to false.
325 Obfuscate *bool
326
327 // If true, do not use the flag files generated by aapt that automatically keep
328 // classes referenced by the app manifest. Defaults to false.
329 No_aapt_flags *bool
330
331 // Flags to pass to proguard.
332 Proguard_flags []string
333
334 // Specifies the locations of files containing proguard flags.
Colin Cross27b922f2019-03-04 22:35:41 -0800335 Proguard_flags_files []string `android:"path"`
Colin Cross66dbc0b2017-12-28 12:23:20 -0800336 }
337
Paul Duffine25c6442019-10-11 13:50:28 +0100338 // When targeting 1.9 and above, override the modules to use with --system,
339 // otherwise provides defaults libraries to add to the bootclasspath.
Colin Cross1369cdb2017-09-29 17:58:17 -0700340 System_modules *string
Colin Cross5a0dcd52018-10-05 14:20:06 -0700341
Jiyong Park4c4c0242019-10-21 14:53:15 +0900342 // set the name of the output
343 Stem *string
344
Colin Cross5a0dcd52018-10-05 14:20:06 -0700345 UncompressDex bool `blueprint:"mutated"`
Colin Cross43f08db2018-11-12 10:13:39 -0800346 IsSDKLibrary bool `blueprint:"mutated"`
Songchun Fan688de9a2020-03-24 20:32:24 -0700347
348 // If true, generate the signature file of APK Signing Scheme V4, along side the signed APK file.
349 // Defaults to false.
350 V4_signature *bool
Colin Cross7d5136f2015-05-11 13:39:40 -0700351}
352
Sasha Smundak2057f822019-04-16 17:16:58 -0700353func (me *CompilerDeviceProperties) EffectiveOptimizeEnabled() bool {
354 return BoolDefault(me.Optimize.Enabled, me.Optimize.EnabledByDefault)
355}
356
Colin Cross46c9b8b2017-06-22 16:51:17 -0700357// Module contains the properties and members used by all java module types
358type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700359 android.ModuleBase
Colin Cross89536d42017-07-07 14:35:50 -0700360 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +0900361 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900362 android.SdkBase
Colin Cross2fe66872015-03-30 17:20:39 -0700363
Colin Cross89536d42017-07-07 14:35:50 -0700364 properties CompilerProperties
Colin Cross6af17aa2017-09-20 12:59:05 -0700365 protoProperties android.ProtoProperties
Colin Cross89536d42017-07-07 14:35:50 -0700366 deviceProperties CompilerDeviceProperties
Colin Cross2fe66872015-03-30 17:20:39 -0700367
Colin Cross331a1212018-08-15 20:40:52 -0700368 // jar file containing header classes including static library dependencies, suitable for
369 // inserting into the bootclasspath/classpath of another compile
Nan Zhanged19fc32017-10-19 13:06:22 -0700370 headerJarFile android.Path
371
Colin Cross331a1212018-08-15 20:40:52 -0700372 // jar file containing implementation classes including static library dependencies but no
373 // resources
Nan Zhanged19fc32017-10-19 13:06:22 -0700374 implementationJarFile android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700375
Colin Cross331a1212018-08-15 20:40:52 -0700376 // jar file containing only resources including from static library dependencies
377 resourceJar android.Path
378
Colin Cross0c4ce212019-05-03 15:28:19 -0700379 // args and dependencies to package source files into a srcjar
380 srcJarArgs []string
381 srcJarDeps android.Paths
382
Colin Cross331a1212018-08-15 20:40:52 -0700383 // jar file containing implementation classes and resources including static library
384 // dependencies
385 implementationAndResourcesJar android.Path
386
387 // output file containing classes.dex and resources
Colin Cross6ade34f2017-09-15 13:00:47 -0700388 dexJarFile android.Path
389
Colin Cross43f08db2018-11-12 10:13:39 -0800390 // output file that contains classes.dex if it should be in the output file
391 maybeStrippedDexJarFile android.Path
392
Colin Crosscb933592017-11-22 13:49:43 -0800393 // output file containing uninstrumented classes that will be instrumented by jacoco
394 jacocoReportClassesFile android.Path
395
Colin Cross66dbc0b2017-12-28 12:23:20 -0800396 // output file containing mapping of obfuscated names
397 proguardDictionary android.Path
398
Colin Cross331a1212018-08-15 20:40:52 -0700399 // output file of the module, which may be a classes jar or a dex jar
Colin Crosse560c4a2019-03-19 16:03:11 -0700400 outputFile android.Path
401 extraOutputFiles android.Paths
Colin Crossb7a63242015-04-16 14:09:14 -0700402
Colin Cross635c3b02016-05-18 15:37:25 -0700403 exportAidlIncludeDirs android.Paths
Colin Crossc0b06f12015-04-08 13:03:43 -0700404
Colin Cross635c3b02016-05-18 15:37:25 -0700405 logtagsSrcs android.Paths
Colin Crossf05fe972015-04-10 17:45:20 -0700406
Colin Cross2fe66872015-03-30 17:20:39 -0700407 // installed file for binary dependency
Colin Cross635c3b02016-05-18 15:37:25 -0700408 installFile android.Path
Colin Cross5ab4e6d2017-11-22 16:20:45 -0800409
410 // list of .java files and srcjars that was passed to javac
411 compiledJavaSrcs android.Paths
412 compiledSrcJars android.Paths
Colin Cross66dbc0b2017-12-28 12:23:20 -0800413
414 // list of extra progurad flag files
415 extraProguardFlagFiles android.Paths
Jiyong Park1be96912018-05-28 18:02:19 +0900416
Colin Cross094054a2018-10-17 15:10:48 -0700417 // manifest file to use instead of properties.Manifest
418 overrideManifest android.OptionalPath
419
Artur Satayev9cf46692019-11-26 18:08:34 +0000420 // list of SDK lib names that this java module is exporting
Jiyong Park1be96912018-05-28 18:02:19 +0900421 exportedSdkLibs []string
Brandon Lee5d45c6f2018-08-15 15:35:38 -0700422
Artur Satayev9cf46692019-11-26 18:08:34 +0000423 // list of plugins that this java module is exporting
424 exportedPluginJars android.Paths
425
426 // list of plugins that this java module is exporting
427 exportedPluginClasses []string
428
429 // list of source files, collected from srcFiles with unique java and all kt files,
patricktu242faad2019-09-24 15:41:30 +0800430 // will be used by android.IDEInfo struct
Brandon Lee5d45c6f2018-08-15 15:35:38 -0700431 expandIDEInfoCompiledSrcs []string
Colin Cross43f08db2018-11-12 10:13:39 -0800432
Steven Morelandc4efd9c2019-01-18 11:51:25 -0800433 // expanded Jarjar_rules
434 expandJarjarRules android.Path
435
Vladimir Marko0975ee02019-04-02 10:29:55 +0100436 // list of additional targets for checkbuild
437 additionalCheckedModules android.Paths
438
Colin Cross988708c2019-05-06 14:04:11 -0700439 // Extra files generated by the module type to be added as java resources.
440 extraResources android.Paths
441
Colin Crossf24a22a2019-01-31 14:12:44 -0800442 hiddenAPI
Colin Cross43f08db2018-11-12 10:13:39 -0800443 dexpreopter
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800444
445 // list of the xref extraction files
446 kytheFiles android.Paths
Anton Hansson1e65f942020-03-27 19:39:48 +0000447
448 distFile android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700449}
450
Colin Cross41955e82019-05-29 14:40:35 -0700451func (j *Module) OutputFiles(tag string) (android.Paths, error) {
452 switch tag {
453 case "":
454 return append(android.Paths{j.outputFile}, j.extraOutputFiles...), nil
Colin Cross375ca3c2019-05-29 14:40:58 -0700455 case ".jar":
456 return android.Paths{j.implementationAndResourcesJar}, nil
Colin Cross2d975b12019-07-29 16:47:42 -0700457 case ".proguard_map":
458 return android.Paths{j.proguardDictionary}, nil
Colin Cross41955e82019-05-29 14:40:35 -0700459 default:
460 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
461 }
Colin Cross54250902017-12-05 09:28:08 -0800462}
463
Colin Cross41955e82019-05-29 14:40:35 -0700464var _ android.OutputFileProducer = (*Module)(nil)
Colin Cross54250902017-12-05 09:28:08 -0800465
Colin Crossf506d872017-07-19 15:53:04 -0700466type Dependency interface {
Nan Zhanged19fc32017-10-19 13:06:22 -0700467 HeaderJars() android.Paths
468 ImplementationJars() android.Paths
Colin Cross331a1212018-08-15 20:40:52 -0700469 ResourceJars() android.Paths
470 ImplementationAndResourcesJars() android.Paths
Colin Crossf24a22a2019-01-31 14:12:44 -0800471 DexJar() android.Path
Colin Cross635c3b02016-05-18 15:37:25 -0700472 AidlIncludeDirs() android.Paths
Jiyong Park1be96912018-05-28 18:02:19 +0900473 ExportedSdkLibs() []string
Artur Satayev9cf46692019-11-26 18:08:34 +0000474 ExportedPlugins() (android.Paths, []string)
Colin Cross0c4ce212019-05-03 15:28:19 -0700475 SrcJarArgs() ([]string, android.Paths)
Colin Crosse323f3c2019-09-17 15:34:09 -0700476 BaseModuleName() string
Jiyong Park618922e2020-01-08 13:35:43 +0900477 JacocoReportClassesFile() android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700478}
479
Jiyong Parkc678ad32018-04-10 13:07:10 +0900480type SdkLibraryDependency interface {
Jiyong Park6a927c42020-01-21 02:03:43 +0900481 SdkHeaderJars(ctx android.BaseModuleContext, sdkVersion sdkSpec) android.Paths
482 SdkImplementationJars(ctx android.BaseModuleContext, sdkVersion sdkSpec) android.Paths
Jiyong Parkc678ad32018-04-10 13:07:10 +0900483}
484
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800485type xref interface {
486 XrefJavaFiles() android.Paths
487}
488
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800489func (j *Module) XrefJavaFiles() android.Paths {
490 return j.kytheFiles
491}
492
Colin Cross89536d42017-07-07 14:35:50 -0700493func InitJavaModule(module android.DefaultableModule, hod android.HostOrDeviceSupported) {
494 android.InitAndroidArchModule(module, hod, android.MultilibCommon)
495 android.InitDefaultableModule(module)
496}
497
Colin Crossbe1da472017-07-07 15:59:46 -0700498type dependencyTag struct {
499 blueprint.BaseDependencyTag
500 name string
Colin Cross2fe66872015-03-30 17:20:39 -0700501}
502
Colin Crossa4f08812018-10-02 22:03:40 -0700503type jniDependencyTag struct {
504 blueprint.BaseDependencyTag
Colin Crossa4f08812018-10-02 22:03:40 -0700505}
506
Jiyong Park8be103b2019-11-08 15:53:48 +0900507func IsJniDepTag(depTag blueprint.DependencyTag) bool {
508 _, ok := depTag.(*jniDependencyTag)
509 return ok
510}
511
Colin Crossbe1da472017-07-07 15:59:46 -0700512var (
Colin Cross4b964c02018-10-15 16:18:06 -0700513 staticLibTag = dependencyTag{name: "staticlib"}
514 libTag = dependencyTag{name: "javalib"}
Colin Cross6cef4812019-10-17 14:23:50 -0700515 java9LibTag = dependencyTag{name: "java9lib"}
Colin Crossbe9cdb82019-01-21 21:37:16 -0800516 pluginTag = dependencyTag{name: "plugin"}
Artur Satayev9cf46692019-11-26 18:08:34 +0000517 exportedPluginTag = dependencyTag{name: "exported-plugin"}
Colin Cross4b964c02018-10-15 16:18:06 -0700518 bootClasspathTag = dependencyTag{name: "bootclasspath"}
519 systemModulesTag = dependencyTag{name: "system modules"}
520 frameworkResTag = dependencyTag{name: "framework-res"}
521 frameworkApkTag = dependencyTag{name: "framework-apk"}
522 kotlinStdlibTag = dependencyTag{name: "kotlin-stdlib"}
Colin Crossafbb1732019-01-17 15:42:52 -0800523 kotlinAnnotationsTag = dependencyTag{name: "kotlin-annotations"}
Colin Cross4b964c02018-10-15 16:18:06 -0700524 proguardRaiseTag = dependencyTag{name: "proguard-raise"}
525 certificateTag = dependencyTag{name: "certificate"}
526 instrumentationForTag = dependencyTag{name: "instrumentation_for"}
Colin Cross50ddcc42019-05-16 12:28:22 -0700527 usesLibTag = dependencyTag{name: "uses-library"}
Colin Crossbe1da472017-07-07 15:59:46 -0700528)
Colin Cross2fe66872015-03-30 17:20:39 -0700529
Jiyong Park83dc74b2020-01-14 18:38:44 +0900530func IsLibDepTag(depTag blueprint.DependencyTag) bool {
531 return depTag == libTag
532}
533
534func IsStaticLibDepTag(depTag blueprint.DependencyTag) bool {
535 return depTag == staticLibTag
536}
537
Colin Crossfc3674a2017-09-18 17:41:52 -0700538type sdkDep struct {
Colin Cross47ff2522017-10-02 14:22:08 -0700539 useModule, useFiles, useDefaultLibs, invalidVersion bool
540
Colin Cross6cef4812019-10-17 14:23:50 -0700541 // The modules that will be added to the bootclasspath when targeting 1.8 or lower
542 bootclasspath []string
Paul Duffine25c6442019-10-11 13:50:28 +0100543
544 // The default system modules to use. Will be an empty string if no system
545 // modules are to be used.
Colin Cross1369cdb2017-09-29 17:58:17 -0700546 systemModules string
547
Colin Cross6cef4812019-10-17 14:23:50 -0700548 // The modules that will be added ot the classpath when targeting 1.9 or higher
549 java9Classpath []string
550
Colin Crossa97c5d32018-03-28 14:58:31 -0700551 frameworkResModule string
552
Colin Cross86a60ae2018-05-29 14:44:55 -0700553 jars android.Paths
Colin Cross3047fa22019-04-18 10:56:44 -0700554 aidl android.OptionalPath
Paul Duffin250e6192019-06-07 10:44:37 +0100555
556 noStandardLibs, noFrameworksLibs bool
557}
558
559func (s sdkDep) hasStandardLibs() bool {
560 return !s.noStandardLibs
561}
562
563func (s sdkDep) hasFrameworkLibs() bool {
564 return !s.noStandardLibs && !s.noFrameworksLibs
Colin Cross1369cdb2017-09-29 17:58:17 -0700565}
566
Colin Crossa4f08812018-10-02 22:03:40 -0700567type jniLib struct {
Jaewoong Jung37ca4a12020-03-26 14:01:48 -0700568 name string
569 path android.Path
570 target android.Target
571 coverageFile android.OptionalPath
Colin Crossa4f08812018-10-02 22:03:40 -0700572}
573
Colin Cross0ea8ba82019-06-06 14:33:29 -0700574func (j *Module) shouldInstrument(ctx android.BaseModuleContext) bool {
Colin Cross3144dfc2018-01-03 15:06:47 -0800575 return j.properties.Instrument && ctx.Config().IsEnvTrue("EMMA_INSTRUMENT")
576}
577
Colin Cross0ea8ba82019-06-06 14:33:29 -0700578func (j *Module) shouldInstrumentStatic(ctx android.BaseModuleContext) bool {
Colin Cross3144dfc2018-01-03 15:06:47 -0800579 return j.shouldInstrument(ctx) &&
580 (ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_STATIC") ||
581 ctx.Config().UnbundledBuild())
582}
583
Jiyong Park6a927c42020-01-21 02:03:43 +0900584func (j *Module) sdkVersion() sdkSpec {
585 return sdkSpecFrom(String(j.deviceProperties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -0700586}
587
Paul Duffine25c6442019-10-11 13:50:28 +0100588func (j *Module) systemModules() string {
589 return proptools.String(j.deviceProperties.System_modules)
590}
591
Jiyong Park6a927c42020-01-21 02:03:43 +0900592func (j *Module) minSdkVersion() sdkSpec {
Colin Cross83bb3162018-06-25 15:48:06 -0700593 if j.deviceProperties.Min_sdk_version != nil {
Jiyong Park6a927c42020-01-21 02:03:43 +0900594 return sdkSpecFrom(*j.deviceProperties.Min_sdk_version)
Colin Cross83bb3162018-06-25 15:48:06 -0700595 }
596 return j.sdkVersion()
597}
598
Jiyong Park6a927c42020-01-21 02:03:43 +0900599func (j *Module) targetSdkVersion() sdkSpec {
Dan Willemsen419290a2018-10-31 15:28:47 -0700600 if j.deviceProperties.Target_sdk_version != nil {
Jiyong Park6a927c42020-01-21 02:03:43 +0900601 return sdkSpecFrom(*j.deviceProperties.Target_sdk_version)
Dan Willemsen419290a2018-10-31 15:28:47 -0700602 }
603 return j.sdkVersion()
604}
605
Artur Satayev388d39b2020-04-27 18:53:18 +0100606func (j *Module) MinSdkVersion() string {
607 return j.minSdkVersion().version.String()
608}
609
Jiyong Parkb02bb402019-12-03 00:43:57 +0900610func (j *Module) AvailableFor(what string) bool {
611 if what == android.AvailableToPlatform && Bool(j.deviceProperties.Hostdex) {
612 // Exception: for hostdex: true libraries, the platform variant is created
613 // even if it's not marked as available to platform. In that case, the platform
614 // variant is used only for the hostdex and not installed to the device.
615 return true
616 }
617 return j.ApexModuleBase.AvailableFor(what)
618}
619
Colin Crossbe1da472017-07-07 15:59:46 -0700620func (j *Module) deps(ctx android.BottomUpMutatorContext) {
Colin Cross1369cdb2017-09-29 17:58:17 -0700621 if ctx.Device() {
Paul Duffin250e6192019-06-07 10:44:37 +0100622 sdkDep := decodeSdkDep(ctx, sdkContext(j))
Colin Cross6d8d8c62019-10-28 15:10:03 -0700623 if sdkDep.useDefaultLibs {
624 ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
625 ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
626 if sdkDep.hasFrameworkLibs() {
627 ctx.AddVariationDependencies(nil, libTag, config.DefaultLibraries...)
Colin Crossbe1da472017-07-07 15:59:46 -0700628 }
Colin Cross6d8d8c62019-10-28 15:10:03 -0700629 } else if sdkDep.useModule {
Colin Cross6cef4812019-10-17 14:23:50 -0700630 ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.bootclasspath...)
Paul Duffine25c6442019-10-11 13:50:28 +0100631 ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
Colin Cross6cef4812019-10-17 14:23:50 -0700632 ctx.AddVariationDependencies(nil, java9LibTag, sdkDep.java9Classpath...)
Colin Cross6d8d8c62019-10-28 15:10:03 -0700633 if j.deviceProperties.EffectiveOptimizeEnabled() && sdkDep.hasStandardLibs() {
634 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultBootclasspathLibraries...)
635 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultLibraries...)
636 }
Colin Cross2fe66872015-03-30 17:20:39 -0700637 }
Colin Cross6d8d8c62019-10-28 15:10:03 -0700638
Nan Zhangb2b33de2018-02-23 11:18:47 -0800639 if ctx.ModuleName() == "android_stubs_current" ||
640 ctx.ModuleName() == "android_system_stubs_current" ||
Nan Zhang863f05b2018-08-07 13:41:10 -0700641 ctx.ModuleName() == "android_test_stubs_current" {
Colin Cross42d48b72018-08-29 14:10:52 -0700642 ctx.AddVariationDependencies(nil, frameworkApkTag, "framework-res")
Nan Zhangb2b33de2018-02-23 11:18:47 -0800643 }
Colin Cross2fe66872015-03-30 17:20:39 -0700644 }
Colin Cross1369cdb2017-09-29 17:58:17 -0700645
Inseob Kimac1e9862019-12-09 18:15:47 +0900646 syspropPublicStubs := syspropPublicStubs(ctx.Config())
647
648 // rewriteSyspropLibs validates if a java module can link against platform's sysprop_library,
649 // and redirects dependency to public stub depending on the link type.
650 rewriteSyspropLibs := func(libs []string, prop string) []string {
651 // make a copy
652 ret := android.CopyOf(libs)
653
654 for idx, lib := range libs {
655 stub, ok := syspropPublicStubs[lib]
656
657 if !ok {
658 continue
659 }
660
661 linkType, _ := j.getLinkType(ctx.ModuleName())
Inseob Kimc5239512020-01-14 15:36:21 +0900662 // only platform modules can use internal props
663 if linkType != javaPlatform {
Inseob Kimac1e9862019-12-09 18:15:47 +0900664 ret[idx] = stub
Inseob Kimac1e9862019-12-09 18:15:47 +0900665 }
666 }
667
668 return ret
669 }
670
671 ctx.AddVariationDependencies(nil, libTag, rewriteSyspropLibs(j.properties.Libs, "libs")...)
672 ctx.AddVariationDependencies(nil, staticLibTag, rewriteSyspropLibs(j.properties.Static_libs, "static_libs")...)
Colin Crossa4f08812018-10-02 22:03:40 -0700673
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700674 ctx.AddFarVariationDependencies(ctx.Config().BuildOSCommonTarget.Variations(), pluginTag, j.properties.Plugins...)
Artur Satayev9cf46692019-11-26 18:08:34 +0000675 ctx.AddFarVariationDependencies(ctx.Config().BuildOSCommonTarget.Variations(), exportedPluginTag, j.properties.Exported_plugins...)
Colin Crossbe9cdb82019-01-21 21:37:16 -0800676
Colin Crossfe17f6f2019-03-28 19:30:56 -0700677 android.ProtoDeps(ctx, &j.protoProperties)
Colin Cross6af17aa2017-09-20 12:59:05 -0700678 if j.hasSrcExt(".proto") {
679 protoDeps(ctx, &j.protoProperties)
680 }
Colin Cross93e85952017-08-15 13:34:18 -0700681
682 if j.hasSrcExt(".kt") {
683 // TODO(ccross): move this to a mutator pass that can tell if generated sources contain
684 // Kotlin files
Colin Cross0b03d972019-05-13 11:06:25 -0700685 ctx.AddVariationDependencies(nil, kotlinStdlibTag,
686 "kotlin-stdlib", "kotlin-stdlib-jdk7", "kotlin-stdlib-jdk8")
Colin Cross7788c122019-01-23 16:14:02 -0800687 if len(j.properties.Plugins) > 0 {
Colin Crossafbb1732019-01-17 15:42:52 -0800688 ctx.AddVariationDependencies(nil, kotlinAnnotationsTag, "kotlin-annotations")
689 }
Colin Cross93e85952017-08-15 13:34:18 -0700690 }
Colin Cross3144dfc2018-01-03 15:06:47 -0800691
Ulya Trafimovich38dfa0f2020-01-07 16:37:02 +0000692 // Framework libraries need special handling in static coverage builds: they should not have
693 // static dependency on jacoco, otherwise there would be multiple conflicting definitions of
694 // the same jacoco classes coming from different bootclasspath jars.
695 if inList(ctx.ModuleName(), config.InstrumentFrameworkModules) {
696 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") {
697 j.properties.Instrument = true
698 }
699 } else if j.shouldInstrumentStatic(ctx) {
Colin Cross42d48b72018-08-29 14:10:52 -0700700 ctx.AddVariationDependencies(nil, staticLibTag, "jacocoagent")
Colin Cross3144dfc2018-01-03 15:06:47 -0800701 }
Colin Cross6af17aa2017-09-20 12:59:05 -0700702}
703
704func hasSrcExt(srcs []string, ext string) bool {
705 for _, src := range srcs {
706 if filepath.Ext(src) == ext {
707 return true
708 }
709 }
710
711 return false
712}
713
714func (j *Module) hasSrcExt(ext string) bool {
715 return hasSrcExt(j.properties.Srcs, ext)
Colin Cross2fe66872015-03-30 17:20:39 -0700716}
717
Colin Cross46c9b8b2017-06-22 16:51:17 -0700718func (j *Module) aidlFlags(ctx android.ModuleContext, aidlPreprocess android.OptionalPath,
Colin Cross3047fa22019-04-18 10:56:44 -0700719 aidlIncludeDirs android.Paths) (string, android.Paths) {
Colin Crossc0b06f12015-04-08 13:03:43 -0700720
Colin Crossebe1a512017-11-14 13:12:14 -0800721 aidlIncludes := android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Local_include_dirs)
722 aidlIncludes = append(aidlIncludes,
723 android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)...)
724 aidlIncludes = append(aidlIncludes,
725 android.PathsForSource(ctx, j.deviceProperties.Aidl.Include_dirs)...)
Colin Crossc0b06f12015-04-08 13:03:43 -0700726
Colin Cross3047fa22019-04-18 10:56:44 -0700727 var flags []string
728 var deps android.Paths
Steven Moreland667f6882018-07-26 12:55:08 -0700729
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700730 if aidlPreprocess.Valid() {
731 flags = append(flags, "-p"+aidlPreprocess.String())
Colin Cross3047fa22019-04-18 10:56:44 -0700732 deps = append(deps, aidlPreprocess.Path())
733 } else if len(aidlIncludeDirs) > 0 {
Colin Cross635c3b02016-05-18 15:37:25 -0700734 flags = append(flags, android.JoinWithPrefix(aidlIncludeDirs.Strings(), "-I"))
Colin Crossc0b06f12015-04-08 13:03:43 -0700735 }
736
Colin Cross3047fa22019-04-18 10:56:44 -0700737 if len(j.exportAidlIncludeDirs) > 0 {
738 flags = append(flags, android.JoinWithPrefix(j.exportAidlIncludeDirs.Strings(), "-I"))
739 }
740
741 if len(aidlIncludes) > 0 {
742 flags = append(flags, android.JoinWithPrefix(aidlIncludes.Strings(), "-I"))
743 }
744
Colin Cross635c3b02016-05-18 15:37:25 -0700745 flags = append(flags, "-I"+android.PathForModuleSrc(ctx).String())
Colin Cross32f38982018-02-22 11:47:25 -0800746 if src := android.ExistentPathForSource(ctx, ctx.ModuleDir(), "src"); src.Valid() {
Colin Crossd48633a2017-07-13 14:41:17 -0700747 flags = append(flags, "-I"+src.String())
748 }
Colin Crossc0b06f12015-04-08 13:03:43 -0700749
Martijn Coeneneab15642018-03-09 09:29:59 +0100750 if Bool(j.deviceProperties.Aidl.Generate_traces) {
751 flags = append(flags, "-t")
752 }
753
Olivier Gaillard0a4cfbc2018-07-16 23:37:03 +0100754 if Bool(j.deviceProperties.Aidl.Generate_get_transaction_name) {
755 flags = append(flags, "--transaction_names")
756 }
757
Colin Cross3047fa22019-04-18 10:56:44 -0700758 return strings.Join(flags, " "), deps
Colin Crossc0b06f12015-04-08 13:03:43 -0700759}
760
Colin Cross32f676a2017-09-06 13:41:06 -0700761type deps struct {
Nan Zhang581fd212018-01-10 16:06:12 -0800762 classpath classpath
Colin Cross6cef4812019-10-17 14:23:50 -0700763 java9Classpath classpath
Nan Zhang581fd212018-01-10 16:06:12 -0800764 bootClasspath classpath
Colin Cross6a77c982018-06-19 22:43:34 -0700765 processorPath classpath
Colin Crossbe9cdb82019-01-21 21:37:16 -0800766 processorClasses []string
Colin Cross6ade34f2017-09-15 13:00:47 -0700767 staticJars android.Paths
Nan Zhanged19fc32017-10-19 13:06:22 -0700768 staticHeaderJars android.Paths
Colin Cross331a1212018-08-15 20:40:52 -0700769 staticResourceJars android.Paths
Colin Cross6ade34f2017-09-15 13:00:47 -0700770 aidlIncludeDirs android.Paths
Nan Zhangb2b33de2018-02-23 11:18:47 -0800771 srcs android.Paths
Colin Cross59149b62017-10-16 18:07:29 -0700772 srcJars android.Paths
Colin Crossb77043e2019-07-16 13:57:13 -0700773 systemModules *systemModules
Colin Cross6ade34f2017-09-15 13:00:47 -0700774 aidlPreprocess android.OptionalPath
Colin Cross93e85952017-08-15 13:34:18 -0700775 kotlinStdlib android.Paths
Colin Crossafbb1732019-01-17 15:42:52 -0800776 kotlinAnnotations android.Paths
Colin Crossbe9cdb82019-01-21 21:37:16 -0800777
778 disableTurbine bool
Colin Cross32f676a2017-09-06 13:41:06 -0700779}
Colin Cross2fe66872015-03-30 17:20:39 -0700780
Colin Cross54250902017-12-05 09:28:08 -0800781func checkProducesJars(ctx android.ModuleContext, dep android.SourceFileProducer) {
782 for _, f := range dep.Srcs() {
783 if f.Ext() != ".jar" {
784 ctx.ModuleErrorf("genrule %q must generate files ending with .jar to be used as a libs or static_libs dependency",
785 ctx.OtherModuleName(dep.(blueprint.Module)))
786 }
787 }
788}
789
Jiyong Park2d492942018-03-05 17:44:10 +0900790type linkType int
791
792const (
Jiyong Park50146e92020-01-30 18:00:15 +0900793 // TODO(jiyong) rename these for better readability. Make the allowed
794 // and disallowed link types explicit
Jiyong Park2d492942018-03-05 17:44:10 +0900795 javaCore linkType = iota
796 javaSdk
797 javaSystem
Jiyong Park50146e92020-01-30 18:00:15 +0900798 javaModule
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900799 javaSystemServer
Jiyong Park2d492942018-03-05 17:44:10 +0900800 javaPlatform
801)
802
Jeongik Cha75b83b02019-11-01 15:28:00 +0900803type linkTypeContext interface {
804 android.Module
805 getLinkType(name string) (ret linkType, stubs bool)
806}
807
808func (m *Module) getLinkType(name string) (ret linkType, stubs bool) {
Colin Cross83bb3162018-06-25 15:48:06 -0700809 ver := m.sdkVersion()
Colin Crossf19b9bb2018-03-26 14:42:44 -0700810 switch {
Jiyong Park46f78fb2018-10-20 16:33:17 +0900811 case name == "core.current.stubs" || name == "core.platform.api.stubs" ||
812 name == "stub-annotations" || name == "private-stub-annotations-jar" ||
Pete Gillincbff3262019-05-08 15:10:06 +0100813 name == "core-lambda-stubs" || name == "core-generated-annotation-stubs":
Jiyong Park46f78fb2018-10-20 16:33:17 +0900814 return javaCore, true
Jiyong Park6a927c42020-01-21 02:03:43 +0900815 case ver.kind == sdkCore:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900816 return javaCore, false
817 case name == "android_system_stubs_current":
818 return javaSystem, true
Jiyong Park6a927c42020-01-21 02:03:43 +0900819 case ver.kind == sdkSystem:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900820 return javaSystem, false
821 case name == "android_test_stubs_current":
822 return javaSystem, true
Jiyong Park6a927c42020-01-21 02:03:43 +0900823 case ver.kind == sdkTest:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900824 return javaPlatform, false
825 case name == "android_stubs_current":
826 return javaSdk, true
Jiyong Park6a927c42020-01-21 02:03:43 +0900827 case ver.kind == sdkPublic:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900828 return javaSdk, false
Jiyong Park50146e92020-01-30 18:00:15 +0900829 case name == "android_module_lib_stubs_current":
830 return javaModule, true
831 case ver.kind == sdkModule:
832 return javaModule, false
Anton Hanssonbbd78552020-03-19 15:23:38 +0000833 case name == "android_system_server_stubs_current":
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900834 return javaSystemServer, true
835 case ver.kind == sdkSystemServer:
836 return javaSystemServer, false
Jiyong Park6a927c42020-01-21 02:03:43 +0900837 case ver.kind == sdkPrivate || ver.kind == sdkNone || ver.kind == sdkCorePlatform:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900838 return javaPlatform, false
Jiyong Park6a927c42020-01-21 02:03:43 +0900839 case !ver.valid():
840 panic(fmt.Errorf("sdk_version is invalid. got %q", ver.raw))
Colin Crossf19b9bb2018-03-26 14:42:44 -0700841 default:
Jiyong Park46f78fb2018-10-20 16:33:17 +0900842 return javaSdk, false
Jiyong Park2d492942018-03-05 17:44:10 +0900843 }
844}
845
Jeongik Cha75b83b02019-11-01 15:28:00 +0900846func checkLinkType(ctx android.ModuleContext, from *Module, to linkTypeContext, tag dependencyTag) {
Colin Crossf19b9bb2018-03-26 14:42:44 -0700847 if ctx.Host() {
848 return
849 }
850
Jeongik Cha75b83b02019-11-01 15:28:00 +0900851 myLinkType, stubs := from.getLinkType(ctx.ModuleName())
Jiyong Park46f78fb2018-10-20 16:33:17 +0900852 if stubs {
853 return
854 }
Jeongik Cha75b83b02019-11-01 15:28:00 +0900855 otherLinkType, _ := to.getLinkType(ctx.OtherModuleName(to))
Jiyong Park2d492942018-03-05 17:44:10 +0900856 commonMessage := "Adjust sdk_version: property of the source or target module so that target module is built with the same or smaller API set than the source."
857
858 switch myLinkType {
859 case javaCore:
860 if otherLinkType != javaCore {
861 ctx.ModuleErrorf("compiles against core Java API, but dependency %q is compiling against non-core Java APIs."+commonMessage,
Jiyong Park750e5572018-01-31 00:20:13 +0900862 ctx.OtherModuleName(to))
863 }
Jiyong Park2d492942018-03-05 17:44:10 +0900864 break
865 case javaSdk:
866 if otherLinkType != javaCore && otherLinkType != javaSdk {
867 ctx.ModuleErrorf("compiles against Android API, but dependency %q is compiling against non-public Android API."+commonMessage,
868 ctx.OtherModuleName(to))
869 }
870 break
871 case javaSystem:
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900872 if otherLinkType == javaPlatform || otherLinkType == javaModule || otherLinkType == javaSystemServer {
Jiyong Park2d492942018-03-05 17:44:10 +0900873 ctx.ModuleErrorf("compiles against system API, but dependency %q is compiling against private API."+commonMessage,
874 ctx.OtherModuleName(to))
875 }
876 break
Jiyong Park50146e92020-01-30 18:00:15 +0900877 case javaModule:
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900878 if otherLinkType == javaPlatform || otherLinkType == javaSystemServer {
Jiyong Park50146e92020-01-30 18:00:15 +0900879 ctx.ModuleErrorf("compiles against module API, but dependency %q is compiling against private API."+commonMessage,
880 ctx.OtherModuleName(to))
881 }
882 break
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900883 case javaSystemServer:
884 if otherLinkType == javaPlatform {
885 ctx.ModuleErrorf("compiles against system server API, but dependency %q is compiling against private API."+commonMessage,
886 ctx.OtherModuleName(to))
887 }
888 break
Jiyong Park2d492942018-03-05 17:44:10 +0900889 case javaPlatform:
890 // no restriction on link-type
891 break
Jiyong Park750e5572018-01-31 00:20:13 +0900892 }
893}
894
Colin Cross32f676a2017-09-06 13:41:06 -0700895func (j *Module) collectDeps(ctx android.ModuleContext) deps {
896 var deps deps
Colin Crossfc3674a2017-09-18 17:41:52 -0700897
Colin Cross300f0382018-03-06 13:11:51 -0800898 if ctx.Device() {
Colin Cross83bb3162018-06-25 15:48:06 -0700899 sdkDep := decodeSdkDep(ctx, sdkContext(j))
Colin Cross300f0382018-03-06 13:11:51 -0800900 if sdkDep.invalidVersion {
Colin Cross6cef4812019-10-17 14:23:50 -0700901 ctx.AddMissingDependencies(sdkDep.bootclasspath)
902 ctx.AddMissingDependencies(sdkDep.java9Classpath)
Colin Cross300f0382018-03-06 13:11:51 -0800903 } else if sdkDep.useFiles {
904 // sdkDep.jar is actually equivalent to turbine header.jar.
Colin Cross86a60ae2018-05-29 14:44:55 -0700905 deps.classpath = append(deps.classpath, sdkDep.jars...)
Colin Cross3047fa22019-04-18 10:56:44 -0700906 deps.aidlPreprocess = sdkDep.aidl
907 } else {
908 deps.aidlPreprocess = sdkDep.aidl
Colin Cross300f0382018-03-06 13:11:51 -0800909 }
Colin Crossfc3674a2017-09-18 17:41:52 -0700910 }
911
Colin Crossd11fcda2017-10-23 17:59:01 -0700912 ctx.VisitDirectDeps(func(module android.Module) {
Colin Cross2fe66872015-03-30 17:20:39 -0700913 otherName := ctx.OtherModuleName(module)
Colin Crossec7a0422017-07-07 14:47:12 -0700914 tag := ctx.OtherModuleDependencyTag(module)
915
Colin Crossa4f08812018-10-02 22:03:40 -0700916 if _, ok := tag.(*jniDependencyTag); ok {
Colin Crossbd01e2a2018-10-04 15:21:03 -0700917 // Handled by AndroidApp.collectAppDeps
918 return
919 }
920 if tag == certificateTag {
921 // Handled by AndroidApp.collectAppDeps
Colin Crossa4f08812018-10-02 22:03:40 -0700922 return
923 }
Artur Satayeve5ac15a2020-04-08 19:09:30 +0100924
Colin Cross54250902017-12-05 09:28:08 -0800925 switch dep := module.(type) {
Colin Cross897d2ed2019-02-11 14:03:51 -0800926 case SdkLibraryDependency:
927 switch tag {
928 case libTag:
929 deps.classpath = append(deps.classpath, dep.SdkHeaderJars(ctx, j.sdkVersion())...)
930 // names of sdk libs that are directly depended are exported
931 j.exportedSdkLibs = append(j.exportedSdkLibs, otherName)
Colin Cross79c7c262019-04-17 11:11:46 -0700932 case staticLibTag:
Colin Cross897d2ed2019-02-11 14:03:51 -0800933 ctx.ModuleErrorf("dependency on java_sdk_library %q can only be in libs", otherName)
934 }
Colin Cross54250902017-12-05 09:28:08 -0800935 case Dependency:
936 switch tag {
937 case bootClasspathTag:
938 deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars()...)
Colin Cross4b964c02018-10-15 16:18:06 -0700939 case libTag, instrumentationForTag:
Colin Cross54250902017-12-05 09:28:08 -0800940 deps.classpath = append(deps.classpath, dep.HeaderJars()...)
Jiyong Park1be96912018-05-28 18:02:19 +0900941 // sdk lib names from dependencies are re-exported
942 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
Colin Cross3047fa22019-04-18 10:56:44 -0700943 deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
Artur Satayev9cf46692019-11-26 18:08:34 +0000944 pluginJars, pluginClasses := dep.ExportedPlugins()
945 addPlugins(&deps, pluginJars, pluginClasses...)
Colin Cross6cef4812019-10-17 14:23:50 -0700946 case java9LibTag:
947 deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars()...)
Colin Cross54250902017-12-05 09:28:08 -0800948 case staticLibTag:
949 deps.classpath = append(deps.classpath, dep.HeaderJars()...)
950 deps.staticJars = append(deps.staticJars, dep.ImplementationJars()...)
951 deps.staticHeaderJars = append(deps.staticHeaderJars, dep.HeaderJars()...)
Colin Cross331a1212018-08-15 20:40:52 -0700952 deps.staticResourceJars = append(deps.staticResourceJars, dep.ResourceJars()...)
Jiyong Park1be96912018-05-28 18:02:19 +0900953 // sdk lib names from dependencies are re-exported
954 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
Colin Cross3047fa22019-04-18 10:56:44 -0700955 deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
Artur Satayev9cf46692019-11-26 18:08:34 +0000956 pluginJars, pluginClasses := dep.ExportedPlugins()
957 addPlugins(&deps, pluginJars, pluginClasses...)
Colin Crossbe9cdb82019-01-21 21:37:16 -0800958 case pluginTag:
959 if plugin, ok := dep.(*Plugin); ok {
Colin Crossbe9cdb82019-01-21 21:37:16 -0800960 if plugin.pluginProperties.Processor_class != nil {
Artur Satayev9cf46692019-11-26 18:08:34 +0000961 addPlugins(&deps, plugin.ImplementationAndResourcesJars(), *plugin.pluginProperties.Processor_class)
962 } else {
963 addPlugins(&deps, plugin.ImplementationAndResourcesJars())
Colin Crossbe9cdb82019-01-21 21:37:16 -0800964 }
965 deps.disableTurbine = deps.disableTurbine || Bool(plugin.pluginProperties.Generates_api)
966 } else {
967 ctx.PropertyErrorf("plugins", "%q is not a java_plugin module", otherName)
968 }
Artur Satayev9cf46692019-11-26 18:08:34 +0000969 case exportedPluginTag:
970 if plugin, ok := dep.(*Plugin); ok {
971 if plugin.pluginProperties.Generates_api != nil && *plugin.pluginProperties.Generates_api {
972 ctx.PropertyErrorf("exported_plugins", "Cannot export plugins with generates_api = true, found %v", otherName)
973 }
974 j.exportedPluginJars = append(j.exportedPluginJars, plugin.ImplementationAndResourcesJars()...)
975 if plugin.pluginProperties.Processor_class != nil {
976 j.exportedPluginClasses = append(j.exportedPluginClasses, *plugin.pluginProperties.Processor_class)
977 }
978 } else {
979 ctx.PropertyErrorf("exported_plugins", "%q is not a java_plugin module", otherName)
980 }
Nan Zhangb2b33de2018-02-23 11:18:47 -0800981 case frameworkApkTag:
982 if ctx.ModuleName() == "android_stubs_current" ||
983 ctx.ModuleName() == "android_system_stubs_current" ||
Nan Zhang863f05b2018-08-07 13:41:10 -0700984 ctx.ModuleName() == "android_test_stubs_current" {
Nan Zhangb2b33de2018-02-23 11:18:47 -0800985 // framework stubs.jar need to depend on framework-res.apk, in order to pull the
986 // resource files out of there for aapt.
987 //
988 // Normally the package rule runs aapt, which includes the resource,
989 // but we're not running that in our package rule so just copy in the
990 // resource files here.
Colin Cross331a1212018-08-15 20:40:52 -0700991 deps.staticResourceJars = append(deps.staticResourceJars, dep.(*AndroidApp).exportPackage)
Nan Zhangb2b33de2018-02-23 11:18:47 -0800992 }
Colin Cross54250902017-12-05 09:28:08 -0800993 case kotlinStdlibTag:
Colin Cross0b03d972019-05-13 11:06:25 -0700994 deps.kotlinStdlib = append(deps.kotlinStdlib, dep.HeaderJars()...)
Colin Crossafbb1732019-01-17 15:42:52 -0800995 case kotlinAnnotationsTag:
996 deps.kotlinAnnotations = dep.HeaderJars()
Colin Cross54250902017-12-05 09:28:08 -0800997 }
998
Colin Cross54250902017-12-05 09:28:08 -0800999 case android.SourceFileProducer:
1000 switch tag {
1001 case libTag:
1002 checkProducesJars(ctx, dep)
1003 deps.classpath = append(deps.classpath, dep.Srcs()...)
1004 case staticLibTag:
1005 checkProducesJars(ctx, dep)
1006 deps.classpath = append(deps.classpath, dep.Srcs()...)
1007 deps.staticJars = append(deps.staticJars, dep.Srcs()...)
1008 deps.staticHeaderJars = append(deps.staticHeaderJars, dep.Srcs()...)
Colin Cross54250902017-12-05 09:28:08 -08001009 }
1010 default:
Colin Crossec7a0422017-07-07 14:47:12 -07001011 switch tag {
Paul Duffin68289b02019-09-20 13:50:52 +01001012 case bootClasspathTag:
1013 // If a system modules dependency has been added to the bootclasspath
1014 // then add its libs to the bootclasspath.
Paul Duffin83a2d962019-11-19 19:44:10 +00001015 sm := module.(SystemModulesProvider)
1016 deps.bootClasspath = append(deps.bootClasspath, sm.HeaderJars()...)
Paul Duffin68289b02019-09-20 13:50:52 +01001017
Colin Cross1369cdb2017-09-29 17:58:17 -07001018 case systemModulesTag:
1019 if deps.systemModules != nil {
1020 panic("Found two system module dependencies")
1021 }
Paul Duffin83a2d962019-11-19 19:44:10 +00001022 sm := module.(SystemModulesProvider)
1023 outputDir, outputDeps := sm.OutputDirAndDeps()
1024 deps.systemModules = &systemModules{outputDir, outputDeps}
Colin Cross2fe66872015-03-30 17:20:39 -07001025 }
Colin Crossec7a0422017-07-07 14:47:12 -07001026 }
Colin Cross2fe66872015-03-30 17:20:39 -07001027 })
1028
Jiyong Park1be96912018-05-28 18:02:19 +09001029 j.exportedSdkLibs = android.FirstUniqueStrings(j.exportedSdkLibs)
1030
Colin Cross32f676a2017-09-06 13:41:06 -07001031 return deps
Colin Cross2fe66872015-03-30 17:20:39 -07001032}
1033
Artur Satayev9cf46692019-11-26 18:08:34 +00001034func addPlugins(deps *deps, pluginJars android.Paths, pluginClasses ...string) {
1035 deps.processorPath = append(deps.processorPath, pluginJars...)
1036 deps.processorClasses = append(deps.processorClasses, pluginClasses...)
1037}
1038
Colin Cross1e743852019-10-28 11:37:20 -07001039func getJavaVersion(ctx android.ModuleContext, javaVersion string, sdkContext sdkContext) javaVersion {
Jiyong Park6a927c42020-01-21 02:03:43 +09001040 sdk, err := sdkContext.sdkVersion().effectiveVersion(ctx)
Colin Cross83bb3162018-06-25 15:48:06 -07001041 if err != nil {
1042 ctx.PropertyErrorf("sdk_version", "%s", err)
1043 }
Nan Zhang357466b2018-04-17 17:38:36 -07001044 if javaVersion != "" {
Colin Cross1e743852019-10-28 11:37:20 -07001045 return normalizeJavaVersion(ctx, javaVersion)
Nan Zhang357466b2018-04-17 17:38:36 -07001046 } else if ctx.Device() && sdk <= 23 {
Colin Cross1e743852019-10-28 11:37:20 -07001047 return JAVA_VERSION_7
Pete Gillina1c9e9d2019-10-17 14:52:07 +01001048 } else if ctx.Device() && sdk <= 29 {
Colin Cross1e743852019-10-28 11:37:20 -07001049 return JAVA_VERSION_8
Colin Cross6cef4812019-10-17 14:23:50 -07001050 } else if ctx.Device() && ctx.Config().UnbundledBuildUsePrebuiltSdks() {
1051 // TODO(b/142896162): once we have prebuilt system modules we can use 1.9 for unbundled builds
Colin Cross1e743852019-10-28 11:37:20 -07001052 return JAVA_VERSION_8
Nan Zhang357466b2018-04-17 17:38:36 -07001053 } else {
Colin Cross1e743852019-10-28 11:37:20 -07001054 return JAVA_VERSION_9
Nan Zhang357466b2018-04-17 17:38:36 -07001055 }
Nan Zhang357466b2018-04-17 17:38:36 -07001056}
1057
Colin Cross1e743852019-10-28 11:37:20 -07001058type javaVersion int
1059
1060const (
1061 JAVA_VERSION_UNSUPPORTED = 0
1062 JAVA_VERSION_6 = 6
1063 JAVA_VERSION_7 = 7
1064 JAVA_VERSION_8 = 8
1065 JAVA_VERSION_9 = 9
1066)
1067
1068func (v javaVersion) String() string {
1069 switch v {
1070 case JAVA_VERSION_6:
1071 return "1.6"
1072 case JAVA_VERSION_7:
1073 return "1.7"
1074 case JAVA_VERSION_8:
1075 return "1.8"
1076 case JAVA_VERSION_9:
1077 return "1.9"
1078 default:
1079 return "unsupported"
1080 }
1081}
1082
1083// Returns true if javac targeting this version uses system modules instead of a bootclasspath.
1084func (v javaVersion) usesJavaModules() bool {
1085 return v >= 9
1086}
1087
1088func normalizeJavaVersion(ctx android.BaseModuleContext, javaVersion string) javaVersion {
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001089 switch javaVersion {
1090 case "1.6", "6":
Colin Cross1e743852019-10-28 11:37:20 -07001091 return JAVA_VERSION_6
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001092 case "1.7", "7":
Colin Cross1e743852019-10-28 11:37:20 -07001093 return JAVA_VERSION_7
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001094 case "1.8", "8":
Colin Cross1e743852019-10-28 11:37:20 -07001095 return JAVA_VERSION_8
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001096 case "1.9", "9":
Colin Cross1e743852019-10-28 11:37:20 -07001097 return JAVA_VERSION_9
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001098 case "10", "11":
1099 ctx.PropertyErrorf("java_version", "Java language levels above 9 are not supported")
Colin Cross1e743852019-10-28 11:37:20 -07001100 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001101 default:
1102 ctx.PropertyErrorf("java_version", "Unrecognized Java language level")
Colin Cross1e743852019-10-28 11:37:20 -07001103 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001104 }
1105}
1106
Nan Zhanged19fc32017-10-19 13:06:22 -07001107func (j *Module) collectBuilderFlags(ctx android.ModuleContext, deps deps) javaBuilderFlags {
Colin Crossc0b06f12015-04-08 13:03:43 -07001108
Colin Crossf03c82b2015-04-13 13:53:40 -07001109 var flags javaBuilderFlags
1110
Tobias Thierer06dd04f2018-09-11 16:21:05 +01001111 // javaVersion flag.
1112 flags.javaVersion = getJavaVersion(ctx, String(j.properties.Java_version), sdkContext(j))
1113
Nan Zhanged19fc32017-10-19 13:06:22 -07001114 // javac flags.
Colin Crossf03c82b2015-04-13 13:53:40 -07001115 javacFlags := j.properties.Javacflags
Colin Cross1e743852019-10-28 11:37:20 -07001116 if flags.javaVersion.usesJavaModules() {
Colin Cross1369cdb2017-09-29 17:58:17 -07001117 javacFlags = append(javacFlags, j.properties.Openjdk9.Javacflags...)
Nan Zhanged19fc32017-10-19 13:06:22 -07001118 }
Colin Cross6510f912017-11-29 00:27:14 -08001119 if ctx.Config().MinimizeJavaDebugInfo() {
Colin Cross126a25c2017-10-31 13:55:34 -07001120 // Override the -g flag passed globally to remove local variable debug info to reduce
1121 // disk and memory usage.
1122 javacFlags = append(javacFlags, "-g:source,lines")
1123 }
Colin Crossc228a702019-11-06 16:18:05 -08001124 javacFlags = append(javacFlags, "-Xlint:-dep-ann")
Colin Cross64162712017-08-08 13:17:59 -07001125
Colin Cross66548102018-06-19 22:47:35 -07001126 if ctx.Config().RunErrorProne() {
1127 if config.ErrorProneClasspath == nil {
1128 ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
1129 }
1130
1131 errorProneFlags := []string{
1132 "-Xplugin:ErrorProne",
1133 "${config.ErrorProneChecks}",
1134 }
1135 errorProneFlags = append(errorProneFlags, j.properties.Errorprone.Javacflags...)
1136
1137 flags.errorProneExtraJavacFlags = "${config.ErrorProneFlags} " +
1138 "'" + strings.Join(errorProneFlags, " ") + "'"
1139 flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
Andreas Gampef3e5b552018-01-22 21:27:21 -08001140 }
1141
Nan Zhanged19fc32017-10-19 13:06:22 -07001142 // classpath
Nan Zhang581fd212018-01-10 16:06:12 -08001143 flags.bootClasspath = append(flags.bootClasspath, deps.bootClasspath...)
1144 flags.classpath = append(flags.classpath, deps.classpath...)
Colin Cross6cef4812019-10-17 14:23:50 -07001145 flags.java9Classpath = append(flags.java9Classpath, deps.java9Classpath...)
Colin Cross6a77c982018-06-19 22:43:34 -07001146 flags.processorPath = append(flags.processorPath, deps.processorPath...)
Colin Cross7fdd2b72018-01-02 18:14:25 -08001147
Colin Crossd99540b2020-04-22 11:44:34 -07001148 flags.processors = append(flags.processors, deps.processorClasses...)
1149 flags.processors = android.FirstUniqueStrings(flags.processors)
Colin Crossbe9cdb82019-01-21 21:37:16 -08001150
Colin Cross1e743852019-10-28 11:37:20 -07001151 if len(flags.bootClasspath) == 0 && ctx.Host() && !flags.javaVersion.usesJavaModules() &&
1152 decodeSdkDep(ctx, sdkContext(j)).hasStandardLibs() {
Colin Cross7fdd2b72018-01-02 18:14:25 -08001153 // Give host-side tools a version of OpenJDK's standard libraries
1154 // close to what they're targeting. As of Dec 2017, AOSP is only
1155 // bundling OpenJDK 8 and 9, so nothing < 8 is available.
1156 //
1157 // When building with OpenJDK 8, the following should have no
1158 // effect since those jars would be available by default.
1159 //
1160 // When building with OpenJDK 9 but targeting a version < 1.8,
1161 // putting them on the bootclasspath means that:
1162 // a) code can't (accidentally) refer to OpenJDK 9 specific APIs
1163 // b) references to existing APIs are not reinterpreted in an
1164 // OpenJDK 9-specific way, eg. calls to subclasses of
1165 // java.nio.Buffer as in http://b/70862583
1166 java8Home := ctx.Config().Getenv("ANDROID_JAVA8_HOME")
1167 flags.bootClasspath = append(flags.bootClasspath,
1168 android.PathForSource(ctx, java8Home, "jre/lib/jce.jar"),
1169 android.PathForSource(ctx, java8Home, "jre/lib/rt.jar"))
Nan Zhang5f8cb422018-02-06 10:34:32 -08001170 if Bool(j.properties.Use_tools_jar) {
1171 flags.bootClasspath = append(flags.bootClasspath,
1172 android.PathForSource(ctx, java8Home, "lib/tools.jar"))
1173 }
Colin Cross7fdd2b72018-01-02 18:14:25 -08001174 }
1175
Colin Cross1e743852019-10-28 11:37:20 -07001176 if j.properties.Patch_module != nil && flags.javaVersion.usesJavaModules() {
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001177 // Manually specify build directory in case it is not under the repo root.
1178 // (javac doesn't seem to expand into symbolc links when searching for patch-module targets, so
1179 // just adding a symlink under the root doesn't help.)
1180 patchPaths := ".:" + ctx.Config().BuildDir()
1181 classPath := flags.classpath.FormJavaClassPath("")
1182 if classPath != "" {
1183 patchPaths += ":" + classPath
1184 }
1185 javacFlags = append(javacFlags, "--patch-module="+String(j.properties.Patch_module)+"="+patchPaths)
Colin Cross81440082018-08-15 20:21:55 -07001186 }
1187
Nan Zhanged19fc32017-10-19 13:06:22 -07001188 // systemModules
Colin Crossb77043e2019-07-16 13:57:13 -07001189 flags.systemModules = deps.systemModules
Colin Cross1369cdb2017-09-29 17:58:17 -07001190
Nan Zhanged19fc32017-10-19 13:06:22 -07001191 // aidl flags.
Colin Cross3047fa22019-04-18 10:56:44 -07001192 flags.aidlFlags, flags.aidlDeps = j.aidlFlags(ctx, deps.aidlPreprocess, deps.aidlIncludeDirs)
Colin Cross2fe66872015-03-30 17:20:39 -07001193
Colin Cross81440082018-08-15 20:21:55 -07001194 if len(javacFlags) > 0 {
1195 // optimization.
1196 ctx.Variable(pctx, "javacFlags", strings.Join(javacFlags, " "))
1197 flags.javacFlags = "$javacFlags"
1198 }
1199
Nan Zhanged19fc32017-10-19 13:06:22 -07001200 return flags
1201}
Colin Crossc0b06f12015-04-08 13:03:43 -07001202
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001203func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) {
Colin Crossebe1a512017-11-14 13:12:14 -08001204 j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)
Nan Zhanged19fc32017-10-19 13:06:22 -07001205
1206 deps := j.collectDeps(ctx)
1207 flags := j.collectBuilderFlags(ctx, deps)
1208
Colin Cross1e743852019-10-28 11:37:20 -07001209 if flags.javaVersion.usesJavaModules() {
Nan Zhanged19fc32017-10-19 13:06:22 -07001210 j.properties.Srcs = append(j.properties.Srcs, j.properties.Openjdk9.Srcs...)
1211 }
Colin Cross8a497952019-03-05 22:25:09 -08001212 srcFiles := android.PathsForModuleSrcExcludes(ctx, j.properties.Srcs, j.properties.Exclude_srcs)
Colin Cross6af17aa2017-09-20 12:59:05 -07001213 if hasSrcExt(srcFiles.Strings(), ".proto") {
Colin Cross0f2ee152017-12-14 15:22:43 -08001214 flags = protoFlags(ctx, &j.properties, &j.protoProperties, flags)
Colin Cross6af17aa2017-09-20 12:59:05 -07001215 }
1216
Colin Crossaf050172017-11-15 23:01:59 -08001217 srcFiles = j.genSources(ctx, srcFiles, flags)
1218
1219 srcJars := srcFiles.FilterByExt(".srcjar")
Colin Cross59149b62017-10-16 18:07:29 -07001220 srcJars = append(srcJars, deps.srcJars...)
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001221 if aaptSrcJar != nil {
1222 srcJars = append(srcJars, aaptSrcJar)
1223 }
Colin Crossb7a63242015-04-16 14:09:14 -07001224
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001225 if j.properties.Jarjar_rules != nil {
Colin Cross8a497952019-03-05 22:25:09 -08001226 j.expandJarjarRules = android.PathForModuleSrc(ctx, *j.properties.Jarjar_rules)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001227 }
1228
Colin Cross1ee23172017-10-18 14:44:18 -07001229 jarName := ctx.ModuleName() + ".jar"
1230
Przemyslaw Szczepaniak4b5fe9d2018-02-13 14:32:54 +00001231 javaSrcFiles := srcFiles.FilterByExt(".java")
1232 var uniqueSrcFiles android.Paths
1233 set := make(map[string]bool)
1234 for _, v := range javaSrcFiles {
1235 if _, found := set[v.String()]; !found {
1236 set[v.String()] = true
1237 uniqueSrcFiles = append(uniqueSrcFiles, v)
1238 }
1239 }
1240
patricktu242faad2019-09-24 15:41:30 +08001241 // Collect .java files for AIDEGen
1242 j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, uniqueSrcFiles.Strings()...)
1243
Colin Cross55f63ea2018-08-27 12:37:09 -07001244 var kotlinJars android.Paths
1245
Colin Cross93e85952017-08-15 13:34:18 -07001246 if srcFiles.HasExt(".kt") {
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001247 // user defined kotlin flags.
1248 kotlincFlags := j.properties.Kotlincflags
1249 CheckKotlincFlags(ctx, kotlincFlags)
1250
Colin Cross93e85952017-08-15 13:34:18 -07001251 // If there are kotlin files, compile them first but pass all the kotlin and java files
1252 // kotlinc will use the java files to resolve types referenced by the kotlin files, but
1253 // won't emit any classes for them.
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001254 kotlincFlags = append(kotlincFlags, "-no-stdlib")
Colin Cross93e85952017-08-15 13:34:18 -07001255 if ctx.Device() {
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001256 kotlincFlags = append(kotlincFlags, "-no-jdk")
1257 }
1258 if len(kotlincFlags) > 0 {
1259 // optimization.
1260 ctx.Variable(pctx, "kotlincFlags", strings.Join(kotlincFlags, " "))
1261 flags.kotlincFlags += "$kotlincFlags"
Colin Cross93e85952017-08-15 13:34:18 -07001262 }
1263
Przemyslaw Szczepaniak4b5fe9d2018-02-13 14:32:54 +00001264 var kotlinSrcFiles android.Paths
1265 kotlinSrcFiles = append(kotlinSrcFiles, uniqueSrcFiles...)
1266 kotlinSrcFiles = append(kotlinSrcFiles, srcFiles.FilterByExt(".kt")...)
1267
patricktu242faad2019-09-24 15:41:30 +08001268 // Collect .kt files for AIDEGen
1269 j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, srcFiles.FilterByExt(".kt").Strings()...)
1270
Colin Crossafbb1732019-01-17 15:42:52 -08001271 flags.classpath = append(flags.classpath, deps.kotlinStdlib...)
1272 flags.classpath = append(flags.classpath, deps.kotlinAnnotations...)
1273
1274 flags.kotlincClasspath = append(flags.kotlincClasspath, flags.bootClasspath...)
1275 flags.kotlincClasspath = append(flags.kotlincClasspath, flags.classpath...)
1276
1277 if len(flags.processorPath) > 0 {
1278 // Use kapt for annotation processing
1279 kaptSrcJar := android.PathForModuleOut(ctx, "kapt", "kapt-sources.jar")
1280 kotlinKapt(ctx, kaptSrcJar, kotlinSrcFiles, srcJars, flags)
1281 srcJars = append(srcJars, kaptSrcJar)
1282 // Disable annotation processing in javac, it's already been handled by kapt
1283 flags.processorPath = nil
Colin Crossd99540b2020-04-22 11:44:34 -07001284 flags.processors = nil
Colin Crossafbb1732019-01-17 15:42:52 -08001285 }
Colin Cross93e85952017-08-15 13:34:18 -07001286
Colin Cross1ee23172017-10-18 14:44:18 -07001287 kotlinJar := android.PathForModuleOut(ctx, "kotlin", jarName)
Colin Cross21fc9bb2019-01-18 15:05:09 -08001288 kotlinCompile(ctx, kotlinJar, kotlinSrcFiles, srcJars, flags)
Colin Cross93e85952017-08-15 13:34:18 -07001289 if ctx.Failed() {
1290 return
1291 }
1292
1293 // Make javac rule depend on the kotlinc rule
1294 flags.classpath = append(flags.classpath, kotlinJar)
Przemyslaw Szczepaniak66c0c402018-03-08 13:21:55 +00001295
Colin Cross93e85952017-08-15 13:34:18 -07001296 // Jar kotlin classes into the final jar after javac
Colin Cross55f63ea2018-08-27 12:37:09 -07001297 kotlinJars = append(kotlinJars, kotlinJar)
Colin Cross9b38aef2018-08-27 15:42:25 -07001298 kotlinJars = append(kotlinJars, deps.kotlinStdlib...)
Colin Cross93e85952017-08-15 13:34:18 -07001299 }
1300
Colin Cross55f63ea2018-08-27 12:37:09 -07001301 jars := append(android.Paths(nil), kotlinJars...)
1302
Colin Cross5ab4e6d2017-11-22 16:20:45 -08001303 // Store the list of .java files that was passed to javac
1304 j.compiledJavaSrcs = uniqueSrcFiles
1305 j.compiledSrcJars = srcJars
1306
Nan Zhang61eaedb2017-11-02 13:28:15 -07001307 enable_sharding := false
Colin Crossf5a66282020-02-21 08:16:41 -08001308 var headerJarFileWithoutJarjar android.Path
Colin Crossbe9cdb82019-01-21 21:37:16 -08001309 if ctx.Device() && !ctx.Config().IsEnvFalse("TURBINE_ENABLED") && !deps.disableTurbine {
Nan Zhang61eaedb2017-11-02 13:28:15 -07001310 if j.properties.Javac_shard_size != nil && *(j.properties.Javac_shard_size) > 0 {
1311 enable_sharding = true
Ashley Rosee36efcf2019-01-16 17:34:08 -05001312 // Formerly, there was a check here that prevented annotation processors
1313 // from being used when sharding was enabled, as some annotation processors
1314 // do not function correctly in sharded environments. It was removed to
1315 // allow for the use of annotation processors that do function correctly
1316 // with sharding enabled. See: b/77284273.
Nan Zhang61eaedb2017-11-02 13:28:15 -07001317 }
Colin Crossf5a66282020-02-21 08:16:41 -08001318 headerJarFileWithoutJarjar, j.headerJarFile =
1319 j.compileJavaHeader(ctx, uniqueSrcFiles, srcJars, deps, flags, jarName, kotlinJars)
Colin Crossf19b9bb2018-03-26 14:42:44 -07001320 if ctx.Failed() {
1321 return
Nan Zhanged19fc32017-10-19 13:06:22 -07001322 }
1323 }
Colin Cross8eadbf02017-10-24 17:46:00 -07001324 if len(uniqueSrcFiles) > 0 || len(srcJars) > 0 {
Colin Crossd6891432017-09-27 17:39:56 -07001325 var extraJarDeps android.Paths
Colin Cross66548102018-06-19 22:47:35 -07001326 if ctx.Config().RunErrorProne() {
Colin Crossc6bbef32017-08-14 14:16:06 -07001327 // If error-prone is enabled, add an additional rule to compile the java files into
1328 // a separate set of classes (so that they don't overwrite the normal ones and require
Colin Crossd6891432017-09-27 17:39:56 -07001329 // a rebuild when error-prone is turned off).
Colin Crossc6bbef32017-08-14 14:16:06 -07001330 // TODO(ccross): Once we always compile with javac9 we may be able to conditionally
1331 // enable error-prone without affecting the output class files.
Colin Cross1ee23172017-10-18 14:44:18 -07001332 errorprone := android.PathForModuleOut(ctx, "errorprone", jarName)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001333 RunErrorProne(ctx, errorprone, uniqueSrcFiles, srcJars, flags)
Colin Crossc6bbef32017-08-14 14:16:06 -07001334 extraJarDeps = append(extraJarDeps, errorprone)
1335 }
1336
Nan Zhang61eaedb2017-11-02 13:28:15 -07001337 if enable_sharding {
Colin Crossf5a66282020-02-21 08:16:41 -08001338 flags.classpath = append(flags.classpath, headerJarFileWithoutJarjar)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001339 shardSize := int(*(j.properties.Javac_shard_size))
1340 var shardSrcs []android.Paths
1341 if len(uniqueSrcFiles) > 0 {
Colin Cross0a2f7192019-09-23 14:33:09 -07001342 shardSrcs = android.ShardPaths(uniqueSrcFiles, shardSize)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001343 for idx, shardSrc := range shardSrcs {
Colin Cross3b706fd2019-09-05 16:44:18 -07001344 classes := j.compileJavaClasses(ctx, jarName, idx, shardSrc,
1345 nil, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001346 jars = append(jars, classes)
1347 }
1348 }
1349 if len(srcJars) > 0 {
Colin Cross3b706fd2019-09-05 16:44:18 -07001350 classes := j.compileJavaClasses(ctx, jarName, len(shardSrcs),
1351 nil, srcJars, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001352 jars = append(jars, classes)
1353 }
1354 } else {
Colin Cross3b706fd2019-09-05 16:44:18 -07001355 classes := j.compileJavaClasses(ctx, jarName, -1, uniqueSrcFiles, srcJars, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001356 jars = append(jars, classes)
1357 }
Colin Crossd6891432017-09-27 17:39:56 -07001358 if ctx.Failed() {
1359 return
1360 }
Colin Cross2fe66872015-03-30 17:20:39 -07001361 }
1362
Colin Cross0c4ce212019-05-03 15:28:19 -07001363 j.srcJarArgs, j.srcJarDeps = resourcePathsToJarArgs(srcFiles), srcFiles
1364
1365 var includeSrcJar android.WritablePath
1366 if Bool(j.properties.Include_srcs) {
1367 includeSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+".srcjar")
1368 TransformResourcesToJar(ctx, includeSrcJar, j.srcJarArgs, j.srcJarDeps)
1369 }
1370
Colin Crosscedd4762018-09-13 11:26:19 -07001371 dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs,
1372 j.properties.Exclude_java_resource_dirs, j.properties.Exclude_java_resources)
Colin Cross0f37af02017-09-27 17:42:05 -07001373 fileArgs, fileDeps := ResourceFilesToJarArgs(ctx, j.properties.Java_resources, j.properties.Exclude_java_resources)
Colin Cross988708c2019-05-06 14:04:11 -07001374 extraArgs, extraDeps := resourcePathsToJarArgs(j.extraResources), j.extraResources
Colin Cross0f37af02017-09-27 17:42:05 -07001375
1376 var resArgs []string
1377 var resDeps android.Paths
1378
1379 resArgs = append(resArgs, dirArgs...)
1380 resDeps = append(resDeps, dirDeps...)
1381
1382 resArgs = append(resArgs, fileArgs...)
1383 resDeps = append(resDeps, fileDeps...)
1384
Colin Cross988708c2019-05-06 14:04:11 -07001385 resArgs = append(resArgs, extraArgs...)
1386 resDeps = append(resDeps, extraDeps...)
1387
Colin Cross40a36712017-09-27 17:41:35 -07001388 if len(resArgs) > 0 {
Colin Cross1ee23172017-10-18 14:44:18 -07001389 resourceJar := android.PathForModuleOut(ctx, "res", jarName)
Colin Crosse9a275b2017-10-16 17:09:48 -07001390 TransformResourcesToJar(ctx, resourceJar, resArgs, resDeps)
Colin Cross331a1212018-08-15 20:40:52 -07001391 j.resourceJar = resourceJar
Colin Cross65bf4f22015-04-03 16:54:17 -07001392 if ctx.Failed() {
1393 return
1394 }
1395 }
1396
Colin Cross0c4ce212019-05-03 15:28:19 -07001397 var resourceJars android.Paths
1398 if j.resourceJar != nil {
1399 resourceJars = append(resourceJars, j.resourceJar)
1400 }
1401 if Bool(j.properties.Include_srcs) {
1402 resourceJars = append(resourceJars, includeSrcJar)
1403 }
1404 resourceJars = append(resourceJars, deps.staticResourceJars...)
Colin Cross331a1212018-08-15 20:40:52 -07001405
Colin Cross0c4ce212019-05-03 15:28:19 -07001406 if len(resourceJars) > 1 {
Colin Cross331a1212018-08-15 20:40:52 -07001407 combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName)
Colin Cross0c4ce212019-05-03 15:28:19 -07001408 TransformJarsToJar(ctx, combinedJar, "for resources", resourceJars, android.OptionalPath{},
Colin Cross331a1212018-08-15 20:40:52 -07001409 false, nil, nil)
1410 j.resourceJar = combinedJar
Colin Cross0c4ce212019-05-03 15:28:19 -07001411 } else if len(resourceJars) == 1 {
1412 j.resourceJar = resourceJars[0]
Colin Cross331a1212018-08-15 20:40:52 -07001413 }
1414
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001415 if len(deps.staticJars) > 0 {
1416 jars = append(jars, deps.staticJars...)
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001417 }
Colin Cross0a6e0072017-08-30 14:24:55 -07001418
Colin Cross094054a2018-10-17 15:10:48 -07001419 manifest := j.overrideManifest
1420 if !manifest.Valid() && j.properties.Manifest != nil {
Colin Cross8a497952019-03-05 22:25:09 -08001421 manifest = android.OptionalPathForPath(android.PathForModuleSrc(ctx, *j.properties.Manifest))
Colin Cross366938f2017-12-11 16:29:02 -08001422 }
Colin Cross635acc92017-09-12 22:50:46 -07001423
Colin Cross8a497952019-03-05 22:25:09 -08001424 services := android.PathsForModuleSrc(ctx, j.properties.Services)
Alex Light7f004a72019-02-21 13:27:37 -08001425 if len(services) > 0 {
1426 servicesJar := android.PathForModuleOut(ctx, "services", jarName)
1427 var zipargs []string
1428 for _, file := range services {
1429 serviceFile := file.String()
1430 zipargs = append(zipargs, "-C", filepath.Dir(serviceFile), "-f", serviceFile)
1431 }
1432 ctx.Build(pctx, android.BuildParams{
1433 Rule: zip,
1434 Output: servicesJar,
1435 Implicits: services,
1436 Args: map[string]string{
Colin Cross0b9f31f2019-02-28 11:00:01 -08001437 "jarArgs": "-P META-INF/services/ " + strings.Join(proptools.NinjaAndShellEscapeList(zipargs), " "),
Alex Light7f004a72019-02-21 13:27:37 -08001438 },
1439 })
1440 jars = append(jars, servicesJar)
1441 }
1442
Colin Cross0a6e0072017-08-30 14:24:55 -07001443 // Combine the classes built from sources, any manifests, and any static libraries into
Nan Zhanged19fc32017-10-19 13:06:22 -07001444 // classes.jar. If there is only one input jar this step will be skipped.
Colin Cross3063b782018-08-15 11:19:12 -07001445 var outputFile android.ModuleOutPath
Colin Crosse9a275b2017-10-16 17:09:48 -07001446
1447 if len(jars) == 1 && !manifest.Valid() {
Colin Cross3063b782018-08-15 11:19:12 -07001448 if moduleOutPath, ok := jars[0].(android.ModuleOutPath); ok {
1449 // Optimization: skip the combine step if there is nothing to do
1450 // TODO(ccross): this leaves any module-info.class files, but those should only come from
1451 // prebuilt dependencies until we support modules in the platform build, so there shouldn't be
1452 // any if len(jars) == 1.
1453 outputFile = moduleOutPath
1454 } else {
1455 combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
1456 ctx.Build(pctx, android.BuildParams{
1457 Rule: android.Cp,
1458 Input: jars[0],
1459 Output: combinedJar,
1460 })
1461 outputFile = combinedJar
1462 }
Colin Crosse9a275b2017-10-16 17:09:48 -07001463 } else {
Colin Cross1ee23172017-10-18 14:44:18 -07001464 combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07001465 TransformJarsToJar(ctx, combinedJar, "for javac", jars, manifest,
Colin Cross9b38aef2018-08-27 15:42:25 -07001466 false, nil, nil)
Colin Crosse9a275b2017-10-16 17:09:48 -07001467 outputFile = combinedJar
1468 }
Colin Cross0a6e0072017-08-30 14:24:55 -07001469
Colin Cross331a1212018-08-15 20:40:52 -07001470 // jarjar implementation jar if necessary
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001471 if j.expandJarjarRules != nil {
Colin Cross8649b262017-09-27 18:03:17 -07001472 // Transform classes.jar into classes-jarjar.jar
Colin Cross1ee23172017-10-18 14:44:18 -07001473 jarjarFile := android.PathForModuleOut(ctx, "jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001474 TransformJarJar(ctx, jarjarFile, outputFile, j.expandJarjarRules)
Colin Crosse9a275b2017-10-16 17:09:48 -07001475 outputFile = jarjarFile
Colin Cross331a1212018-08-15 20:40:52 -07001476
1477 // jarjar resource jar if necessary
1478 if j.resourceJar != nil {
1479 resourceJarJarFile := android.PathForModuleOut(ctx, "res-jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001480 TransformJarJar(ctx, resourceJarJarFile, j.resourceJar, j.expandJarjarRules)
Colin Cross331a1212018-08-15 20:40:52 -07001481 j.resourceJar = resourceJarJarFile
1482 }
1483
Colin Cross0a6e0072017-08-30 14:24:55 -07001484 if ctx.Failed() {
1485 return
1486 }
1487 }
Vladimir Marko0975ee02019-04-02 10:29:55 +01001488
1489 // Check package restrictions if necessary.
1490 if len(j.properties.Permitted_packages) > 0 {
1491 // Check packages and copy to package-checked file.
1492 pkgckFile := android.PathForModuleOut(ctx, "package-check.stamp")
1493 CheckJarPackages(ctx, pkgckFile, outputFile, j.properties.Permitted_packages)
1494 j.additionalCheckedModules = append(j.additionalCheckedModules, pkgckFile)
1495
1496 if ctx.Failed() {
1497 return
1498 }
1499 }
1500
Nan Zhanged19fc32017-10-19 13:06:22 -07001501 j.implementationJarFile = outputFile
1502 if j.headerJarFile == nil {
1503 j.headerJarFile = j.implementationJarFile
1504 }
Colin Cross2fe66872015-03-30 17:20:39 -07001505
Jiyong Park28826602020-02-21 16:04:53 +09001506 // Force enable the instrumentation for java code that is built for APEXes ...
1507 // except for the jacocoagent itself (because instrumenting jacocoagent using jacocoagent
1508 // doesn't make sense)
1509 isJacocoAgent := ctx.ModuleName() == "jacocoagent"
1510 if android.DirectlyInAnyApex(ctx, ctx.ModuleName()) && !isJacocoAgent && !j.IsForPlatform() {
Jiyong Park81aaa0c2020-02-18 12:50:44 +00001511 j.properties.Instrument = true
1512 }
1513
Colin Cross3144dfc2018-01-03 15:06:47 -08001514 if j.shouldInstrument(ctx) {
Colin Crosscb933592017-11-22 13:49:43 -08001515 outputFile = j.instrument(ctx, flags, outputFile, jarName)
1516 }
1517
Colin Cross331a1212018-08-15 20:40:52 -07001518 // merge implementation jar with resources if necessary
1519 implementationAndResourcesJar := outputFile
1520 if j.resourceJar != nil {
Colin Cross08a409d2019-04-29 10:22:44 -07001521 jars := android.Paths{j.resourceJar, implementationAndResourcesJar}
Colin Cross331a1212018-08-15 20:40:52 -07001522 combinedJar := android.PathForModuleOut(ctx, "withres", jarName)
Colin Cross08a409d2019-04-29 10:22:44 -07001523 TransformJarsToJar(ctx, combinedJar, "for resources", jars, manifest,
Colin Cross331a1212018-08-15 20:40:52 -07001524 false, nil, nil)
1525 implementationAndResourcesJar = combinedJar
1526 }
1527
1528 j.implementationAndResourcesJar = implementationAndResourcesJar
1529
Jiyong Park6b21c7d2020-02-11 09:16:01 +09001530 // Enable dex compilation for the APEX variants, unless it is disabled explicitly
1531 if android.DirectlyInAnyApex(ctx, ctx.ModuleName()) && !j.IsForPlatform() {
1532 if j.deviceProperties.Compile_dex == nil {
1533 j.deviceProperties.Compile_dex = proptools.BoolPtr(true)
1534 }
1535 if j.deviceProperties.Hostdex == nil {
1536 j.deviceProperties.Hostdex = proptools.BoolPtr(true)
1537 }
1538 }
1539
Jaewoong Jungc27ab662019-05-30 15:51:14 -07001540 if ctx.Device() && j.hasCode(ctx) &&
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001541 (Bool(j.properties.Installable) || Bool(j.deviceProperties.Compile_dex)) {
Colin Cross8faf8fc2019-01-16 15:15:52 -08001542 // Dex compilation
Colin Cross3063b782018-08-15 11:19:12 -07001543 var dexOutputFile android.ModuleOutPath
David Brazdil17ef5632018-06-27 10:27:45 +01001544 dexOutputFile = j.compileDex(ctx, flags, outputFile, jarName)
Colin Cross2fe66872015-03-30 17:20:39 -07001545 if ctx.Failed() {
1546 return
1547 }
Colin Cross331a1212018-08-15 20:40:52 -07001548
Jiyong Park09cb6292019-07-15 15:29:23 +09001549 // Hidden API CSV generation and dex encoding
1550 dexOutputFile = j.hiddenAPI.hiddenAPI(ctx, dexOutputFile, j.implementationJarFile,
1551 j.deviceProperties.UncompressDex)
Colin Cross8faf8fc2019-01-16 15:15:52 -08001552
Colin Cross331a1212018-08-15 20:40:52 -07001553 // merge dex jar with resources if necessary
1554 if j.resourceJar != nil {
1555 jars := android.Paths{dexOutputFile, j.resourceJar}
1556 combinedJar := android.PathForModuleOut(ctx, "dex-withres", jarName)
1557 TransformJarsToJar(ctx, combinedJar, "for dex resources", jars, android.OptionalPath{},
1558 false, nil, nil)
Nicolas Geoffrayf3438722019-01-23 15:57:21 +00001559 if j.deviceProperties.UncompressDex {
1560 combinedAlignedJar := android.PathForModuleOut(ctx, "dex-withres-aligned", jarName)
1561 TransformZipAlign(ctx, combinedAlignedJar, combinedJar)
1562 dexOutputFile = combinedAlignedJar
1563 } else {
1564 dexOutputFile = combinedJar
1565 }
Colin Cross331a1212018-08-15 20:40:52 -07001566 }
1567
1568 j.dexJarFile = dexOutputFile
1569
Colin Cross8faf8fc2019-01-16 15:15:52 -08001570 // Dexpreopting
Colin Cross43f08db2018-11-12 10:13:39 -08001571 dexOutputFile = j.dexpreopt(ctx, dexOutputFile)
1572
1573 j.maybeStrippedDexJarFile = dexOutputFile
1574
Colin Cross3063b782018-08-15 11:19:12 -07001575 outputFile = dexOutputFile
Colin Cross43f08db2018-11-12 10:13:39 -08001576
1577 if ctx.Failed() {
1578 return
1579 }
Colin Cross331a1212018-08-15 20:40:52 -07001580 } else {
1581 outputFile = implementationAndResourcesJar
Colin Cross2fe66872015-03-30 17:20:39 -07001582 }
Colin Cross331a1212018-08-15 20:40:52 -07001583
Colin Crossb7a63242015-04-16 14:09:14 -07001584 ctx.CheckbuildFile(outputFile)
Colin Cross3063b782018-08-15 11:19:12 -07001585
1586 // Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource
1587 j.outputFile = outputFile.WithoutRel()
Colin Cross2fe66872015-03-30 17:20:39 -07001588}
1589
Colin Cross3b706fd2019-09-05 16:44:18 -07001590func (j *Module) compileJavaClasses(ctx android.ModuleContext, jarName string, idx int,
1591 srcFiles, srcJars android.Paths, flags javaBuilderFlags, extraJarDeps android.Paths) android.WritablePath {
1592
1593 kzipName := pathtools.ReplaceExtension(jarName, "kzip")
1594 if idx >= 0 {
1595 kzipName = strings.TrimSuffix(jarName, filepath.Ext(jarName)) + strconv.Itoa(idx) + ".kzip"
1596 jarName += strconv.Itoa(idx)
1597 }
1598
1599 classes := android.PathForModuleOut(ctx, "javac", jarName)
1600 TransformJavaToClasses(ctx, classes, idx, srcFiles, srcJars, flags, extraJarDeps)
1601
1602 if ctx.Config().EmitXrefRules() {
1603 extractionFile := android.PathForModuleOut(ctx, kzipName)
1604 emitXrefRule(ctx, extractionFile, idx, srcFiles, srcJars, flags, extraJarDeps)
1605 j.kytheFiles = append(j.kytheFiles, extractionFile)
1606 }
1607
1608 return classes
1609}
1610
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001611// Check for invalid kotlinc flags. Only use this for flags explicitly passed by the user,
1612// since some of these flags may be used internally.
1613func CheckKotlincFlags(ctx android.ModuleContext, flags []string) {
1614 for _, flag := range flags {
1615 flag = strings.TrimSpace(flag)
1616
1617 if !strings.HasPrefix(flag, "-") {
1618 ctx.PropertyErrorf("kotlincflags", "Flag `%s` must start with `-`", flag)
1619 } else if strings.HasPrefix(flag, "-Xintellij-plugin-root") {
1620 ctx.PropertyErrorf("kotlincflags",
1621 "Bad flag: `%s`, only use internal compiler for consistency.", flag)
1622 } else if inList(flag, config.KotlincIllegalFlags) {
1623 ctx.PropertyErrorf("kotlincflags", "Flag `%s` already used by build system", flag)
1624 } else if flag == "-include-runtime" {
1625 ctx.PropertyErrorf("kotlincflags", "Bad flag: `%s`, do not include runtime.", flag)
1626 } else {
1627 args := strings.Split(flag, " ")
1628 if args[0] == "-kotlin-home" {
1629 ctx.PropertyErrorf("kotlincflags",
1630 "Bad flag: `%s`, kotlin home already set to default (path to kotlinc in the repo).", flag)
1631 }
1632 }
1633 }
1634}
1635
Colin Cross8eadbf02017-10-24 17:46:00 -07001636func (j *Module) compileJavaHeader(ctx android.ModuleContext, srcFiles, srcJars android.Paths,
Colin Crossf5a66282020-02-21 08:16:41 -08001637 deps deps, flags javaBuilderFlags, jarName string,
1638 extraJars android.Paths) (headerJar, jarjarHeaderJar android.Path) {
Nan Zhanged19fc32017-10-19 13:06:22 -07001639
1640 var jars android.Paths
Colin Cross8eadbf02017-10-24 17:46:00 -07001641 if len(srcFiles) > 0 || len(srcJars) > 0 {
Nan Zhanged19fc32017-10-19 13:06:22 -07001642 // Compile java sources into turbine.jar.
1643 turbineJar := android.PathForModuleOut(ctx, "turbine", jarName)
1644 TransformJavaToHeaderClasses(ctx, turbineJar, srcFiles, srcJars, flags)
1645 if ctx.Failed() {
Colin Crossf5a66282020-02-21 08:16:41 -08001646 return nil, nil
Nan Zhanged19fc32017-10-19 13:06:22 -07001647 }
1648 jars = append(jars, turbineJar)
1649 }
1650
Colin Cross55f63ea2018-08-27 12:37:09 -07001651 jars = append(jars, extraJars...)
1652
Nan Zhanged19fc32017-10-19 13:06:22 -07001653 // Combine any static header libraries into classes-header.jar. If there is only
1654 // one input jar this step will be skipped.
Nan Zhanged19fc32017-10-19 13:06:22 -07001655 jars = append(jars, deps.staticHeaderJars...)
1656
Colin Cross5c6ecc12017-10-23 18:12:27 -07001657 // we cannot skip the combine step for now if there is only one jar
1658 // since we have to strip META-INF/TRANSITIVE dir from turbine.jar
1659 combinedJar := android.PathForModuleOut(ctx, "turbine-combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07001660 TransformJarsToJar(ctx, combinedJar, "for turbine", jars, android.OptionalPath{},
Colin Cross6c6e6cd2019-05-08 14:30:12 -07001661 false, nil, []string{"META-INF/TRANSITIVE"})
Colin Cross5c6ecc12017-10-23 18:12:27 -07001662 headerJar = combinedJar
Colin Crossf5a66282020-02-21 08:16:41 -08001663 jarjarHeaderJar = combinedJar
Nan Zhanged19fc32017-10-19 13:06:22 -07001664
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001665 if j.expandJarjarRules != nil {
Nan Zhanged19fc32017-10-19 13:06:22 -07001666 // Transform classes.jar into classes-jarjar.jar
1667 jarjarFile := android.PathForModuleOut(ctx, "turbine-jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001668 TransformJarJar(ctx, jarjarFile, headerJar, j.expandJarjarRules)
Colin Crossf5a66282020-02-21 08:16:41 -08001669 jarjarHeaderJar = jarjarFile
Nan Zhanged19fc32017-10-19 13:06:22 -07001670 if ctx.Failed() {
Colin Crossf5a66282020-02-21 08:16:41 -08001671 return nil, nil
Nan Zhanged19fc32017-10-19 13:06:22 -07001672 }
1673 }
1674
Colin Crossf5a66282020-02-21 08:16:41 -08001675 return headerJar, jarjarHeaderJar
Nan Zhanged19fc32017-10-19 13:06:22 -07001676}
1677
Colin Crosscb933592017-11-22 13:49:43 -08001678func (j *Module) instrument(ctx android.ModuleContext, flags javaBuilderFlags,
Colin Cross3063b782018-08-15 11:19:12 -07001679 classesJar android.Path, jarName string) android.ModuleOutPath {
Colin Crosscb933592017-11-22 13:49:43 -08001680
Colin Cross7a3139e2017-12-19 13:57:50 -08001681 specs := j.jacocoModuleToZipCommand(ctx)
Colin Crosscb933592017-11-22 13:49:43 -08001682
Colin Cross84c38822018-01-03 15:59:46 -08001683 jacocoReportClassesFile := android.PathForModuleOut(ctx, "jacoco-report-classes", jarName)
Colin Crosscb933592017-11-22 13:49:43 -08001684 instrumentedJar := android.PathForModuleOut(ctx, "jacoco", jarName)
1685
1686 jacocoInstrumentJar(ctx, instrumentedJar, jacocoReportClassesFile, classesJar, specs)
1687
1688 j.jacocoReportClassesFile = jacocoReportClassesFile
1689
1690 return instrumentedJar
1691}
1692
albaltai36ff7dc2018-12-25 14:35:23 +08001693var _ Dependency = (*Module)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07001694
Nan Zhanged19fc32017-10-19 13:06:22 -07001695func (j *Module) HeaderJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001696 if j.headerJarFile == nil {
1697 return nil
1698 }
Nan Zhanged19fc32017-10-19 13:06:22 -07001699 return android.Paths{j.headerJarFile}
1700}
1701
1702func (j *Module) ImplementationJars() android.Paths {
shinwang9e4c07a2018-12-24 15:41:04 +08001703 if j.implementationJarFile == nil {
1704 return nil
1705 }
Nan Zhanged19fc32017-10-19 13:06:22 -07001706 return android.Paths{j.implementationJarFile}
Colin Cross2fe66872015-03-30 17:20:39 -07001707}
1708
Colin Crossf24a22a2019-01-31 14:12:44 -08001709func (j *Module) DexJar() android.Path {
1710 return j.dexJarFile
1711}
1712
Colin Cross331a1212018-08-15 20:40:52 -07001713func (j *Module) ResourceJars() android.Paths {
1714 if j.resourceJar == nil {
1715 return nil
1716 }
1717 return android.Paths{j.resourceJar}
1718}
1719
1720func (j *Module) ImplementationAndResourcesJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001721 if j.implementationAndResourcesJar == nil {
1722 return nil
1723 }
Colin Cross331a1212018-08-15 20:40:52 -07001724 return android.Paths{j.implementationAndResourcesJar}
1725}
1726
Colin Cross46c9b8b2017-06-22 16:51:17 -07001727func (j *Module) AidlIncludeDirs() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001728 // exportAidlIncludeDirs is type android.Paths already
Colin Crossc0b06f12015-04-08 13:03:43 -07001729 return j.exportAidlIncludeDirs
1730}
1731
Jiyong Park1be96912018-05-28 18:02:19 +09001732func (j *Module) ExportedSdkLibs() []string {
albaltai36ff7dc2018-12-25 14:35:23 +08001733 // exportedSdkLibs is type []string
Jiyong Park1be96912018-05-28 18:02:19 +09001734 return j.exportedSdkLibs
1735}
1736
Artur Satayev9cf46692019-11-26 18:08:34 +00001737func (j *Module) ExportedPlugins() (android.Paths, []string) {
1738 return j.exportedPluginJars, j.exportedPluginClasses
1739}
1740
Colin Cross0c4ce212019-05-03 15:28:19 -07001741func (j *Module) SrcJarArgs() ([]string, android.Paths) {
1742 return j.srcJarArgs, j.srcJarDeps
1743}
1744
Colin Cross46c9b8b2017-06-22 16:51:17 -07001745var _ logtagsProducer = (*Module)(nil)
Colin Crossf05fe972015-04-10 17:45:20 -07001746
Colin Cross46c9b8b2017-06-22 16:51:17 -07001747func (j *Module) logtags() android.Paths {
Colin Crossf05fe972015-04-10 17:45:20 -07001748 return j.logtagsSrcs
1749}
1750
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001751// Collect information for opening IDE project files in java/jdeps.go.
1752func (j *Module) IDEInfo(dpInfo *android.IdeInfo) {
1753 dpInfo.Deps = append(dpInfo.Deps, j.CompilerDeps()...)
1754 dpInfo.Srcs = append(dpInfo.Srcs, j.expandIDEInfoCompiledSrcs...)
patricktu18c82ff2019-05-10 15:48:50 +08001755 dpInfo.SrcJars = append(dpInfo.SrcJars, j.compiledSrcJars.Strings()...)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001756 dpInfo.Aidl_include_dirs = append(dpInfo.Aidl_include_dirs, j.deviceProperties.Aidl.Include_dirs...)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001757 if j.expandJarjarRules != nil {
1758 dpInfo.Jarjar_rules = append(dpInfo.Jarjar_rules, j.expandJarjarRules.String())
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001759 }
1760}
1761
1762func (j *Module) CompilerDeps() []string {
1763 jdeps := []string{}
1764 jdeps = append(jdeps, j.properties.Libs...)
1765 jdeps = append(jdeps, j.properties.Static_libs...)
1766 return jdeps
1767}
1768
Jaewoong Jungc27ab662019-05-30 15:51:14 -07001769func (j *Module) hasCode(ctx android.ModuleContext) bool {
1770 srcFiles := android.PathsForModuleSrcExcludes(ctx, j.properties.Srcs, j.properties.Exclude_srcs)
1771 return len(srcFiles) > 0 || len(ctx.GetDirectDepsWithTag(staticLibTag)) > 0
1772}
1773
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001774func (j *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Jiyong Park0f80c182020-01-31 02:49:53 +09001775 // Dependencies other than the static linkage are all considered crossing APEX boundary
Jooyung Hanb8fa86a2020-03-10 06:23:13 +09001776 if staticLibTag == ctx.OtherModuleDependencyTag(dep) {
1777 return true
1778 }
Jooyung Hanb8fa86a2020-03-10 06:23:13 +09001779 return false
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001780}
1781
Jiyong Park0b238752019-10-29 11:23:10 +09001782func (j *Module) Stem() string {
1783 return proptools.StringDefault(j.deviceProperties.Stem, j.Name())
1784}
1785
Jiyong Park618922e2020-01-08 13:35:43 +09001786func (j *Module) JacocoReportClassesFile() android.Path {
1787 return j.jacocoReportClassesFile
1788}
1789
Martin Stjernholm6d415272020-01-31 17:10:36 +00001790func (j *Module) IsInstallable() bool {
1791 return Bool(j.properties.Installable)
1792}
1793
Colin Cross2fe66872015-03-30 17:20:39 -07001794//
1795// Java libraries (.jar file)
1796//
1797
Anton Hansson1e65f942020-03-27 19:39:48 +00001798type LibraryProperties struct {
1799 Dist struct {
1800 // The tag of the output of this module that should be output.
1801 Tag *string `android:"arch_variant"`
1802 } `android:"arch_variant"`
1803}
1804
Colin Crossf506d872017-07-19 15:53:04 -07001805type Library struct {
Colin Cross46c9b8b2017-06-22 16:51:17 -07001806 Module
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001807
Anton Hansson1e65f942020-03-27 19:39:48 +00001808 libraryProperties LibraryProperties
1809
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001810 InstallMixin func(ctx android.ModuleContext, installPath android.Path) (extraInstallDeps android.Paths)
Colin Cross2fe66872015-03-30 17:20:39 -07001811}
1812
Colin Cross42be7612019-02-21 18:12:14 -08001813func shouldUncompressDex(ctx android.ModuleContext, dexpreopter *dexpreopter) bool {
Ulya Trafimovichf491dde2020-01-24 12:19:45 +00001814 // Store uncompressed (and aligned) any dex files from jars in APEXes.
1815 if am, ok := ctx.Module().(android.ApexModule); ok && !am.IsForPlatform() {
1816 return true
1817 }
1818
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +00001819 // Store uncompressed (and do not strip) dex files from boot class path jars.
1820 if inList(ctx.ModuleName(), ctx.Config().BootJars()) {
1821 return true
1822 }
1823
1824 // Store uncompressed dex files that are preopted on /system.
Colin Cross42be7612019-02-21 18:12:14 -08001825 if !dexpreopter.dexpreoptDisabled(ctx) && (ctx.Host() || !odexOnSystemOther(ctx, dexpreopter.installPath)) {
Vladimir Markoe8b00d62018-12-21 15:54:16 +00001826 return true
1827 }
Colin Cross083a2aa2019-02-06 16:37:12 -08001828 if ctx.Config().UncompressPrivAppDex() &&
1829 inList(ctx.ModuleName(), ctx.Config().ModulesLoadedByPrivilegedModules()) {
1830 return true
1831 }
1832
Colin Cross2fc72f62018-12-21 12:59:54 -08001833 return false
1834}
1835
Colin Crossf506d872017-07-19 15:53:04 -07001836func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Artur Satayeve5ac15a2020-04-08 19:09:30 +01001837 j.checkSdkVersions(ctx)
Jiyong Park0b238752019-10-29 11:23:10 +09001838 j.dexpreopter.installPath = android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar")
Colin Cross43f08db2018-11-12 10:13:39 -08001839 j.dexpreopter.isSDKLibrary = j.deviceProperties.IsSDKLibrary
Colin Cross42be7612019-02-21 18:12:14 -08001840 j.dexpreopter.uncompressedDex = shouldUncompressDex(ctx, &j.dexpreopter)
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +00001841 j.deviceProperties.UncompressDex = j.dexpreopter.uncompressedDex
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001842 j.compile(ctx, nil)
Colin Crossb7a63242015-04-16 14:09:14 -07001843
Jiyong Park7f7766d2019-07-25 22:02:35 +09001844 exclusivelyForApex := android.InAnyApex(ctx.ModuleName()) && !j.IsForPlatform()
1845 if (Bool(j.properties.Installable) || ctx.Host()) && !exclusivelyForApex {
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001846 var extraInstallDeps android.Paths
1847 if j.InstallMixin != nil {
1848 extraInstallDeps = j.InstallMixin(ctx, j.outputFile)
1849 }
Colin Cross2c429dc2017-08-31 16:45:16 -07001850 j.installFile = ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001851 ctx.ModuleName()+".jar", j.outputFile, extraInstallDeps...)
Colin Cross2c429dc2017-08-31 16:45:16 -07001852 }
Anton Hansson1e65f942020-03-27 19:39:48 +00001853
1854 // Verify Dist.Tag is set to a supported output
1855 if j.libraryProperties.Dist.Tag != nil {
1856 distFiles, err := j.OutputFiles(*j.libraryProperties.Dist.Tag)
1857 if err != nil {
1858 ctx.PropertyErrorf("dist.tag", "%s", err.Error())
1859 }
1860 j.distFile = distFiles[0]
1861 }
Colin Crossb7a63242015-04-16 14:09:14 -07001862}
1863
Colin Crossf506d872017-07-19 15:53:04 -07001864func (j *Library) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross46c9b8b2017-06-22 16:51:17 -07001865 j.deps(ctx)
1866}
1867
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001868const (
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001869 aidlIncludeDir = "aidl"
1870 javaDir = "java"
1871 jarFileSuffix = ".jar"
1872 testConfigSuffix = "-AndroidTest.xml"
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001873)
1874
Paul Duffina0dbf432019-12-05 11:25:53 +00001875// path to the jar file of a java library. Relative to <sdk_root>/<api_dir>
Paul Duffin9b358d72020-03-02 10:16:35 +00001876func sdkSnapshotFilePathForJar(osPrefix, name string) string {
1877 return sdkSnapshotFilePathForMember(osPrefix, name, jarFileSuffix)
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001878}
1879
Paul Duffin9b358d72020-03-02 10:16:35 +00001880func sdkSnapshotFilePathForMember(osPrefix, name string, suffix string) string {
1881 return filepath.Join(javaDir, osPrefix, name+suffix)
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001882}
1883
Paul Duffin13879572019-11-28 14:31:38 +00001884type librarySdkMemberType struct {
Paul Duffin255f18e2019-12-13 11:22:16 +00001885 android.SdkMemberTypeBase
Paul Duffin2b9e3d32020-02-28 14:39:53 +00001886
1887 // Function to retrieve the appropriate output jar (implementation or header) from
1888 // the library.
1889 jarToExportGetter func(j *Library) android.Path
Paul Duffin13879572019-11-28 14:31:38 +00001890}
1891
1892func (mt *librarySdkMemberType) AddDependencies(mctx android.BottomUpMutatorContext, dependencyTag blueprint.DependencyTag, names []string) {
1893 mctx.AddVariationDependencies(nil, dependencyTag, names...)
1894}
1895
1896func (mt *librarySdkMemberType) IsInstance(module android.Module) bool {
1897 _, ok := module.(*Library)
1898 return ok
1899}
1900
Paul Duffin17ab8832020-03-19 16:11:18 +00001901func (mt *librarySdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
1902 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_import")
Paul Duffind76209b2020-03-02 11:33:02 +00001903}
Paul Duffina0dbf432019-12-05 11:25:53 +00001904
Paul Duffind76209b2020-03-02 11:33:02 +00001905func (mt *librarySdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
Paul Duffinc9103932020-03-17 21:04:24 +00001906 return &librarySdkMemberProperties{}
Paul Duffind76209b2020-03-02 11:33:02 +00001907}
1908
1909type librarySdkMemberProperties struct {
1910 android.SdkMemberPropertiesBase
1911
Paul Duffin08385bf2020-05-06 10:23:19 +01001912 JarToExport android.Path `android:"arch_variant"`
Paul Duffinc9103932020-03-17 21:04:24 +00001913 AidlIncludeDirs android.Paths
Paul Duffind76209b2020-03-02 11:33:02 +00001914}
1915
Paul Duffin17ab8832020-03-19 16:11:18 +00001916func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffin13879572019-11-28 14:31:38 +00001917 j := variant.(*Library)
1918
Paul Duffinc9103932020-03-17 21:04:24 +00001919 p.JarToExport = ctx.MemberType().(*librarySdkMemberType).jarToExportGetter(j)
1920 p.AidlIncludeDirs = j.AidlIncludeDirs()
Paul Duffind76209b2020-03-02 11:33:02 +00001921}
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001922
Paul Duffin17ab8832020-03-19 16:11:18 +00001923func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffinc9103932020-03-17 21:04:24 +00001924 builder := ctx.SnapshotBuilder()
Paul Duffin17ab8832020-03-19 16:11:18 +00001925
Paul Duffinc9103932020-03-17 21:04:24 +00001926 exportedJar := p.JarToExport
1927 if exportedJar != nil {
1928 snapshotRelativeJavaLibPath := sdkSnapshotFilePathForJar(p.OsPrefix(), ctx.Name())
Paul Duffind76209b2020-03-02 11:33:02 +00001929 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
1930
Paul Duffinc9103932020-03-17 21:04:24 +00001931 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
1932 }
1933
1934 aidlIncludeDirs := p.AidlIncludeDirs
1935 if len(aidlIncludeDirs) != 0 {
1936 sdkModuleContext := ctx.SdkModuleContext()
1937 for _, dir := range aidlIncludeDirs {
Paul Duffind76209b2020-03-02 11:33:02 +00001938 // TODO(jiyong): copy parcelable declarations only
1939 aidlFiles, _ := sdkModuleContext.GlobWithDeps(dir.String()+"/**/*.aidl", nil)
1940 for _, file := range aidlFiles {
1941 builder.CopyToSnapshot(android.PathForSource(sdkModuleContext, file), filepath.Join(aidlIncludeDir, file))
1942 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001943 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001944
Paul Duffinc9103932020-03-17 21:04:24 +00001945 // TODO(b/151933053) - add aidl include dirs property
Paul Duffind76209b2020-03-02 11:33:02 +00001946 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001947}
1948
Paul Duffin2b9e3d32020-02-28 14:39:53 +00001949var javaHeaderLibsSdkMemberType android.SdkMemberType = &librarySdkMemberType{
1950 android.SdkMemberTypeBase{
1951 PropertyName: "java_header_libs",
1952 SupportsSdk: true,
Paul Duffin7b81f5e2020-01-13 21:03:22 +00001953 },
Paul Duffin2b9e3d32020-02-28 14:39:53 +00001954 func(j *Library) android.Path {
Paul Duffina0dbf432019-12-05 11:25:53 +00001955 headerJars := j.HeaderJars()
1956 if len(headerJars) != 1 {
1957 panic(fmt.Errorf("there must be only one header jar from %q", j.Name()))
1958 }
1959
1960 return headerJars[0]
Paul Duffin2b9e3d32020-02-28 14:39:53 +00001961 },
Paul Duffina0dbf432019-12-05 11:25:53 +00001962}
1963
Colin Cross1b16b0e2019-02-12 14:41:32 -08001964// java_library builds and links sources into a `.jar` file for the device, and possibly for the host as well.
1965//
1966// By default, a java_library has a single variant that produces a `.jar` file containing `.class` files that were
1967// compiled against the device bootclasspath. This jar is not suitable for installing on a device, but can be used
1968// as a `static_libs` dependency of another module.
1969//
1970// Specifying `installable: true` will product a `.jar` file containing `classes.dex` files, suitable for installing on
1971// a device.
1972//
1973// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
1974// compiled against the host bootclasspath.
Colin Cross9ae1b922018-06-26 17:59:05 -07001975func LibraryFactory() android.Module {
1976 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -07001977
Colin Cross9ae1b922018-06-26 17:59:05 -07001978 module.AddProperties(
1979 &module.Module.properties,
1980 &module.Module.deviceProperties,
Colin Cross43f08db2018-11-12 10:13:39 -08001981 &module.Module.dexpreoptProperties,
Anton Hansson1e65f942020-03-27 19:39:48 +00001982 &module.Module.protoProperties,
1983 &module.libraryProperties)
Colin Cross2fe66872015-03-30 17:20:39 -07001984
Jiyong Park7f7766d2019-07-25 22:02:35 +09001985 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09001986 android.InitSdkAwareModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09001987 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross9ae1b922018-06-26 17:59:05 -07001988 return module
Colin Cross2fe66872015-03-30 17:20:39 -07001989}
1990
Colin Cross1b16b0e2019-02-12 14:41:32 -08001991// java_library_static is an obsolete alias for java_library.
1992func LibraryStaticFactory() android.Module {
1993 return LibraryFactory()
1994}
1995
1996// java_library_host builds and links sources into a `.jar` file for the host.
1997//
1998// A java_library_host has a single variant that produces a `.jar` file containing `.class` files that were
1999// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002000func LibraryHostFactory() android.Module {
2001 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -07002002
Colin Cross6af17aa2017-09-20 12:59:05 -07002003 module.AddProperties(
2004 &module.Module.properties,
2005 &module.Module.protoProperties)
Colin Cross36242852017-06-23 15:06:31 -07002006
Colin Cross9ae1b922018-06-26 17:59:05 -07002007 module.Module.properties.Installable = proptools.BoolPtr(true)
2008
Jiyong Park7f7766d2019-07-25 22:02:35 +09002009 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002010 InitJavaModule(module, android.HostSupported)
Colin Cross36242852017-06-23 15:06:31 -07002011 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002012}
2013
2014//
Colin Crossb628ea52018-08-14 16:42:33 -07002015// Java Tests
Colin Cross05638fc2018-04-09 18:40:24 -07002016//
2017
2018type testProperties struct {
Colin Cross05638fc2018-04-09 18:40:24 -07002019 // list of compatibility suites (for example "cts", "vts") that the module should be
2020 // installed into.
2021 Test_suites []string `android:"arch_variant"`
Julien Despreze146e392018-08-02 15:00:46 -07002022
2023 // the name of the test configuration (for example "AndroidTest.xml") that should be
2024 // installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -08002025 Test_config *string `android:"path,arch_variant"`
Colin Crossd96ca352018-08-10 16:06:24 -07002026
Jack He33338892018-09-19 02:21:28 -07002027 // the name of the test configuration template (for example "AndroidTestTemplate.xml") that
2028 // should be installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -08002029 Test_config_template *string `android:"path,arch_variant"`
Jack He33338892018-09-19 02:21:28 -07002030
Colin Crossd96ca352018-08-10 16:06:24 -07002031 // list of files or filegroup modules that provide data that should be installed alongside
2032 // the test
Colin Cross27b922f2019-03-04 22:35:41 -08002033 Data []string `android:"path"`
Dan Shi6ffaaa82019-09-26 11:41:36 -07002034
2035 // Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
2036 // doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
2037 // explicitly.
2038 Auto_gen_config *bool
Colin Cross05638fc2018-04-09 18:40:24 -07002039}
2040
Paul Duffin42df1442019-03-20 12:45:53 +00002041type testHelperLibraryProperties struct {
2042 // list of compatibility suites (for example "cts", "vts") that the module should be
2043 // installed into.
2044 Test_suites []string `android:"arch_variant"`
2045}
2046
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002047type prebuiltTestProperties struct {
2048 // list of compatibility suites (for example "cts", "vts") that the module should be
2049 // installed into.
2050 Test_suites []string `android:"arch_variant"`
2051
2052 // the name of the test configuration (for example "AndroidTest.xml") that should be
2053 // installed with the module.
2054 Test_config *string `android:"path,arch_variant"`
2055}
2056
Colin Cross05638fc2018-04-09 18:40:24 -07002057type Test struct {
2058 Library
2059
2060 testProperties testProperties
Colin Cross303e21f2018-08-07 16:49:25 -07002061
2062 testConfig android.Path
Colin Crossd96ca352018-08-10 16:06:24 -07002063 data android.Paths
Colin Cross303e21f2018-08-07 16:49:25 -07002064}
2065
Paul Duffin42df1442019-03-20 12:45:53 +00002066type TestHelperLibrary struct {
2067 Library
2068
2069 testHelperLibraryProperties testHelperLibraryProperties
2070}
2071
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002072type JavaTestImport struct {
2073 Import
2074
2075 prebuiltTestProperties prebuiltTestProperties
2076
2077 testConfig android.Path
2078}
2079
Colin Cross303e21f2018-08-07 16:49:25 -07002080func (j *Test) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Dan Shi6ffaaa82019-09-26 11:41:36 -07002081 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.testProperties.Test_config, j.testProperties.Test_config_template,
2082 j.testProperties.Test_suites, j.testProperties.Auto_gen_config)
Colin Cross8a497952019-03-05 22:25:09 -08002083 j.data = android.PathsForModuleSrc(ctx, j.testProperties.Data)
Colin Cross303e21f2018-08-07 16:49:25 -07002084
2085 j.Library.GenerateAndroidBuildActions(ctx)
Colin Cross05638fc2018-04-09 18:40:24 -07002086}
2087
Paul Duffin42df1442019-03-20 12:45:53 +00002088func (j *TestHelperLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2089 j.Library.GenerateAndroidBuildActions(ctx)
2090}
2091
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002092func (j *JavaTestImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2093 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.prebuiltTestProperties.Test_config, nil,
2094 j.prebuiltTestProperties.Test_suites, nil)
2095
2096 j.Import.GenerateAndroidBuildActions(ctx)
2097}
2098
2099type testSdkMemberType struct {
2100 android.SdkMemberTypeBase
2101}
2102
2103func (mt *testSdkMemberType) AddDependencies(mctx android.BottomUpMutatorContext, dependencyTag blueprint.DependencyTag, names []string) {
2104 mctx.AddVariationDependencies(nil, dependencyTag, names...)
2105}
2106
2107func (mt *testSdkMemberType) IsInstance(module android.Module) bool {
2108 _, ok := module.(*Test)
2109 return ok
2110}
2111
Paul Duffin17ab8832020-03-19 16:11:18 +00002112func (mt *testSdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
2113 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_test_import")
Paul Duffind76209b2020-03-02 11:33:02 +00002114}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002115
Paul Duffind76209b2020-03-02 11:33:02 +00002116func (mt *testSdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
2117 return &testSdkMemberProperties{}
2118}
2119
2120type testSdkMemberProperties struct {
2121 android.SdkMemberPropertiesBase
2122
Paul Duffinc9103932020-03-17 21:04:24 +00002123 JarToExport android.Path
2124 TestConfig android.Path
Paul Duffind76209b2020-03-02 11:33:02 +00002125}
2126
Paul Duffin17ab8832020-03-19 16:11:18 +00002127func (p *testSdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffind76209b2020-03-02 11:33:02 +00002128 test := variant.(*Test)
2129
2130 implementationJars := test.ImplementationJars()
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002131 if len(implementationJars) != 1 {
Paul Duffind76209b2020-03-02 11:33:02 +00002132 panic(fmt.Errorf("there must be only one implementation jar from %q", test.Name()))
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002133 }
2134
Paul Duffinc9103932020-03-17 21:04:24 +00002135 p.JarToExport = implementationJars[0]
2136 p.TestConfig = test.testConfig
Paul Duffind76209b2020-03-02 11:33:02 +00002137}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002138
Paul Duffin17ab8832020-03-19 16:11:18 +00002139func (p *testSdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffinc9103932020-03-17 21:04:24 +00002140 builder := ctx.SnapshotBuilder()
Paul Duffin17ab8832020-03-19 16:11:18 +00002141
Paul Duffinc9103932020-03-17 21:04:24 +00002142 exportedJar := p.JarToExport
2143 if exportedJar != nil {
2144 snapshotRelativeJavaLibPath := sdkSnapshotFilePathForJar(p.OsPrefix(), ctx.Name())
2145 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
Paul Duffind76209b2020-03-02 11:33:02 +00002146
2147 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
Paul Duffinc9103932020-03-17 21:04:24 +00002148 }
2149
2150 testConfig := p.TestConfig
2151 if testConfig != nil {
2152 snapshotRelativeTestConfigPath := sdkSnapshotFilePathForMember(p.OsPrefix(), ctx.Name(), testConfigSuffix)
2153 builder.CopyToSnapshot(testConfig, snapshotRelativeTestConfigPath)
Paul Duffind76209b2020-03-02 11:33:02 +00002154 propertySet.AddProperty("test_config", snapshotRelativeTestConfigPath)
2155 }
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002156}
2157
Colin Cross1b16b0e2019-02-12 14:41:32 -08002158// java_test builds a and links sources into a `.jar` file for the device, and possibly for the host as well, and
2159// creates an `AndroidTest.xml` file to allow running the test with `atest` or a `TEST_MAPPING` file.
2160//
2161// By default, a java_test has a single variant that produces a `.jar` file containing `classes.dex` files that were
2162// compiled against the device bootclasspath.
2163//
2164// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
2165// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07002166func TestFactory() android.Module {
2167 module := &Test{}
2168
2169 module.AddProperties(
2170 &module.Module.properties,
2171 &module.Module.deviceProperties,
Colin Cross43f08db2018-11-12 10:13:39 -08002172 &module.Module.dexpreoptProperties,
Colin Cross05638fc2018-04-09 18:40:24 -07002173 &module.Module.protoProperties,
2174 &module.testProperties)
2175
Colin Cross9ae1b922018-06-26 17:59:05 -07002176 module.Module.properties.Installable = proptools.BoolPtr(true)
Colin Crosse3026872019-01-05 22:30:13 -08002177 module.Module.dexpreopter.isTest = true
Colin Cross9ae1b922018-06-26 17:59:05 -07002178
Colin Cross05638fc2018-04-09 18:40:24 -07002179 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross05638fc2018-04-09 18:40:24 -07002180 return module
2181}
2182
Paul Duffin42df1442019-03-20 12:45:53 +00002183// java_test_helper_library creates a java library and makes sure that it is added to the appropriate test suite.
2184func TestHelperLibraryFactory() android.Module {
2185 module := &TestHelperLibrary{}
2186
2187 module.AddProperties(
2188 &module.Module.properties,
2189 &module.Module.deviceProperties,
2190 &module.Module.dexpreoptProperties,
2191 &module.Module.protoProperties,
2192 &module.testHelperLibraryProperties)
2193
Colin Cross9a4abed2019-04-24 13:19:28 -07002194 module.Module.properties.Installable = proptools.BoolPtr(true)
2195 module.Module.dexpreopter.isTest = true
2196
Paul Duffin42df1442019-03-20 12:45:53 +00002197 InitJavaModule(module, android.HostAndDeviceSupported)
2198 return module
2199}
2200
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002201// java_test_import imports one or more `.jar` files into the build graph as if they were built by a java_test module
2202// and makes sure that it is added to the appropriate test suite.
2203//
2204// By default, a java_test_import has a single variant that expects a `.jar` file containing `.class` files that were
2205// compiled against an Android classpath.
2206//
2207// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
2208// for host modules.
2209func JavaTestImportFactory() android.Module {
2210 module := &JavaTestImport{}
2211
2212 module.AddProperties(
2213 &module.Import.properties,
2214 &module.prebuiltTestProperties)
2215
2216 module.Import.properties.Installable = proptools.BoolPtr(true)
2217
2218 android.InitPrebuiltModule(module, &module.properties.Jars)
2219 android.InitApexModule(module)
2220 android.InitSdkAwareModule(module)
2221 InitJavaModule(module, android.HostAndDeviceSupported)
2222 return module
2223}
2224
Colin Cross1b16b0e2019-02-12 14:41:32 -08002225// java_test_host builds a and links sources into a `.jar` file for the host, and creates an `AndroidTest.xml` file to
2226// allow running the test with `atest` or a `TEST_MAPPING` file.
2227//
2228// A java_test_host has a single variant that produces a `.jar` file containing `.class` files that were
2229// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07002230func TestHostFactory() android.Module {
2231 module := &Test{}
2232
2233 module.AddProperties(
2234 &module.Module.properties,
2235 &module.Module.protoProperties,
2236 &module.testProperties)
2237
Colin Cross9ae1b922018-06-26 17:59:05 -07002238 module.Module.properties.Installable = proptools.BoolPtr(true)
2239
Colin Cross05638fc2018-04-09 18:40:24 -07002240 InitJavaModule(module, android.HostSupported)
Colin Cross05638fc2018-04-09 18:40:24 -07002241 return module
2242}
2243
2244//
Colin Cross2fe66872015-03-30 17:20:39 -07002245// Java Binaries (.jar file plus wrapper script)
2246//
2247
Colin Crossf506d872017-07-19 15:53:04 -07002248type binaryProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -07002249 // installable script to execute the resulting jar
Colin Cross27b922f2019-03-04 22:35:41 -08002250 Wrapper *string `android:"path"`
Colin Cross094054a2018-10-17 15:10:48 -07002251
2252 // Name of the class containing main to be inserted into the manifest as Main-Class.
2253 Main_class *string
Colin Cross7d5136f2015-05-11 13:39:40 -07002254}
2255
Colin Crossf506d872017-07-19 15:53:04 -07002256type Binary struct {
2257 Library
Colin Cross2fe66872015-03-30 17:20:39 -07002258
Colin Crossf506d872017-07-19 15:53:04 -07002259 binaryProperties binaryProperties
Colin Cross10a03492017-08-10 17:09:43 -07002260
Colin Cross6b4a32d2017-12-05 13:42:45 -08002261 isWrapperVariant bool
2262
Colin Crossc3315992017-12-08 19:12:36 -08002263 wrapperFile android.Path
Colin Cross70dda7e2019-10-01 22:05:35 -07002264 binaryFile android.InstallPath
Colin Cross2fe66872015-03-30 17:20:39 -07002265}
2266
Alex Light24237172017-10-26 09:46:21 -07002267func (j *Binary) HostToolPath() android.OptionalPath {
2268 return android.OptionalPathForPath(j.binaryFile)
2269}
2270
Colin Crossf506d872017-07-19 15:53:04 -07002271func (j *Binary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002272 if ctx.Arch().ArchType == android.Common {
2273 // Compile the jar
Colin Cross094054a2018-10-17 15:10:48 -07002274 if j.binaryProperties.Main_class != nil {
2275 if j.properties.Manifest != nil {
2276 ctx.PropertyErrorf("main_class", "main_class cannot be used when manifest is set")
2277 }
2278 manifestFile := android.PathForModuleOut(ctx, "manifest.txt")
2279 GenerateMainClassManifest(ctx, manifestFile, String(j.binaryProperties.Main_class))
2280 j.overrideManifest = android.OptionalPathForPath(manifestFile)
2281 }
2282
Colin Cross6b4a32d2017-12-05 13:42:45 -08002283 j.Library.GenerateAndroidBuildActions(ctx)
Nan Zhang3c807db2017-11-03 14:53:31 -07002284 } else {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002285 // Handle the binary wrapper
2286 j.isWrapperVariant = true
2287
Colin Cross366938f2017-12-11 16:29:02 -08002288 if j.binaryProperties.Wrapper != nil {
Colin Cross8a497952019-03-05 22:25:09 -08002289 j.wrapperFile = android.PathForModuleSrc(ctx, *j.binaryProperties.Wrapper)
Colin Cross6b4a32d2017-12-05 13:42:45 -08002290 } else {
2291 j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh")
2292 }
2293
2294 // Depend on the installed jar so that the wrapper doesn't get executed by
2295 // another build rule before the jar has been installed.
2296 jarFile := ctx.PrimaryModule().(*Binary).installFile
2297
2298 j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"),
2299 ctx.ModuleName(), j.wrapperFile, jarFile)
Nan Zhang3c807db2017-11-03 14:53:31 -07002300 }
Colin Cross2fe66872015-03-30 17:20:39 -07002301}
2302
Colin Crossf506d872017-07-19 15:53:04 -07002303func (j *Binary) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002304 if ctx.Arch().ArchType == android.Common {
2305 j.deps(ctx)
2306 }
Colin Cross46c9b8b2017-06-22 16:51:17 -07002307}
2308
Colin Cross1b16b0e2019-02-12 14:41:32 -08002309// java_binary builds a `.jar` file and a shell script that executes it for the device, and possibly for the host
2310// as well.
2311//
2312// By default, a java_binary has a single variant that produces a `.jar` file containing `classes.dex` files that were
2313// compiled against the device bootclasspath.
2314//
2315// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
2316// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002317func BinaryFactory() android.Module {
2318 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07002319
Colin Cross36242852017-06-23 15:06:31 -07002320 module.AddProperties(
Colin Cross540eff82017-06-22 17:01:52 -07002321 &module.Module.properties,
2322 &module.Module.deviceProperties,
Colin Cross43f08db2018-11-12 10:13:39 -08002323 &module.Module.dexpreoptProperties,
Colin Cross6af17aa2017-09-20 12:59:05 -07002324 &module.Module.protoProperties,
Colin Cross540eff82017-06-22 17:01:52 -07002325 &module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07002326
Colin Cross9ae1b922018-06-26 17:59:05 -07002327 module.Module.properties.Installable = proptools.BoolPtr(true)
2328
Colin Cross6b4a32d2017-12-05 13:42:45 -08002329 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommonFirst)
2330 android.InitDefaultableModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002331 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002332}
2333
Colin Cross1b16b0e2019-02-12 14:41:32 -08002334// java_binary_host builds a `.jar` file and a shell script that executes it for the host.
2335//
2336// A java_binary_host has a single variant that produces a `.jar` file containing `.class` files that were
2337// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002338func BinaryHostFactory() android.Module {
2339 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07002340
Colin Cross36242852017-06-23 15:06:31 -07002341 module.AddProperties(
Colin Cross540eff82017-06-22 17:01:52 -07002342 &module.Module.properties,
Colin Cross6af17aa2017-09-20 12:59:05 -07002343 &module.Module.protoProperties,
Colin Cross540eff82017-06-22 17:01:52 -07002344 &module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07002345
Colin Cross9ae1b922018-06-26 17:59:05 -07002346 module.Module.properties.Installable = proptools.BoolPtr(true)
2347
Colin Cross6b4a32d2017-12-05 13:42:45 -08002348 android.InitAndroidArchModule(module, android.HostSupported, android.MultilibCommonFirst)
2349 android.InitDefaultableModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002350 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002351}
2352
2353//
2354// Java prebuilts
2355//
2356
Colin Cross74d73e22017-08-02 11:05:49 -07002357type ImportProperties struct {
Paul Duffin9b358d72020-03-02 10:16:35 +00002358 Jars []string `android:"path,arch_variant"`
Colin Cross461bd1a2017-10-20 13:59:18 -07002359
Nan Zhangea568a42017-11-08 21:20:04 -08002360 Sdk_version *string
Colin Cross535e2cf2017-10-20 17:57:49 -07002361
2362 Installable *bool
Jiyong Park1be96912018-05-28 18:02:19 +09002363
2364 // List of shared java libs that this module has dependencies to
2365 Libs []string
Colin Cross37f6d792018-07-12 12:28:41 -07002366
2367 // List of files to remove from the jar file(s)
2368 Exclude_files []string
2369
2370 // List of directories to remove from the jar file(s)
2371 Exclude_dirs []string
Nan Zhang4c819fb2018-08-27 18:31:46 -07002372
2373 // if set to true, run Jetifier against .jar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -07002374 Jetifier *bool
Jiyong Park4c4c0242019-10-21 14:53:15 +09002375
2376 // set the name of the output
2377 Stem *string
Colin Cross74d73e22017-08-02 11:05:49 -07002378}
2379
2380type Import struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002381 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -07002382 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002383 android.ApexModuleBase
Colin Crossec7a0422017-07-07 14:47:12 -07002384 prebuilt android.Prebuilt
Jiyong Parkd1063c12019-07-17 20:08:41 +09002385 android.SdkBase
Colin Cross2fe66872015-03-30 17:20:39 -07002386
Colin Cross74d73e22017-08-02 11:05:49 -07002387 properties ImportProperties
2388
Colin Cross0a6e0072017-08-30 14:24:55 -07002389 combinedClasspathFile android.Path
Jiyong Park1be96912018-05-28 18:02:19 +09002390 exportedSdkLibs []string
Colin Cross2fe66872015-03-30 17:20:39 -07002391}
2392
Jiyong Park6a927c42020-01-21 02:03:43 +09002393func (j *Import) sdkVersion() sdkSpec {
2394 return sdkSpecFrom(String(j.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -07002395}
2396
Jiyong Park6a927c42020-01-21 02:03:43 +09002397func (j *Import) minSdkVersion() sdkSpec {
Colin Cross83bb3162018-06-25 15:48:06 -07002398 return j.sdkVersion()
2399}
2400
Artur Satayev388d39b2020-04-27 18:53:18 +01002401func (j *Import) MinSdkVersion() string {
2402 return j.minSdkVersion().version.String()
2403}
2404
Colin Cross74d73e22017-08-02 11:05:49 -07002405func (j *Import) Prebuilt() *android.Prebuilt {
Colin Crossec7a0422017-07-07 14:47:12 -07002406 return &j.prebuilt
2407}
2408
Colin Cross74d73e22017-08-02 11:05:49 -07002409func (j *Import) PrebuiltSrcs() []string {
2410 return j.properties.Jars
2411}
2412
2413func (j *Import) Name() string {
Colin Cross5ea9bcc2017-07-27 15:41:32 -07002414 return j.prebuilt.Name(j.ModuleBase.Name())
2415}
2416
Jiyong Park0b238752019-10-29 11:23:10 +09002417func (j *Import) Stem() string {
2418 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
2419}
2420
Jiyong Park618922e2020-01-08 13:35:43 +09002421func (a *Import) JacocoReportClassesFile() android.Path {
2422 return nil
2423}
2424
Colin Cross74d73e22017-08-02 11:05:49 -07002425func (j *Import) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross42d48b72018-08-29 14:10:52 -07002426 ctx.AddVariationDependencies(nil, libTag, j.properties.Libs...)
Colin Cross1e676be2016-10-12 14:38:15 -07002427}
2428
Colin Cross74d73e22017-08-02 11:05:49 -07002429func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Cross8a497952019-03-05 22:25:09 -08002430 jars := android.PathsForModuleSrc(ctx, j.properties.Jars)
Colin Crosse1d62a82015-04-03 16:53:05 -07002431
Jiyong Park0b238752019-10-29 11:23:10 +09002432 jarName := j.Stem() + ".jar"
Nan Zhang4c819fb2018-08-27 18:31:46 -07002433 outputFile := android.PathForModuleOut(ctx, "combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07002434 TransformJarsToJar(ctx, outputFile, "for prebuilts", jars, android.OptionalPath{},
2435 false, j.properties.Exclude_files, j.properties.Exclude_dirs)
Colin Cross1001a792019-03-21 22:21:39 -07002436 if Bool(j.properties.Jetifier) {
Nan Zhang4c819fb2018-08-27 18:31:46 -07002437 inputFile := outputFile
2438 outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
2439 TransformJetifier(ctx, outputFile, inputFile)
2440 }
Colin Crosse9a275b2017-10-16 17:09:48 -07002441 j.combinedClasspathFile = outputFile
Jiyong Park1be96912018-05-28 18:02:19 +09002442
2443 ctx.VisitDirectDeps(func(module android.Module) {
2444 otherName := ctx.OtherModuleName(module)
2445 tag := ctx.OtherModuleDependencyTag(module)
2446
2447 switch dep := module.(type) {
2448 case Dependency:
2449 switch tag {
2450 case libTag, staticLibTag:
2451 // sdk lib names from dependencies are re-exported
2452 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
2453 }
2454 case SdkLibraryDependency:
2455 switch tag {
2456 case libTag:
2457 // names of sdk libs that are directly depended are exported
2458 j.exportedSdkLibs = append(j.exportedSdkLibs, otherName)
2459 }
2460 }
2461 })
2462
2463 j.exportedSdkLibs = android.FirstUniqueStrings(j.exportedSdkLibs)
Nan Zhang4973ecf2018-08-10 13:42:12 -07002464 if Bool(j.properties.Installable) {
2465 ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
Jiyong Park4c4c0242019-10-21 14:53:15 +09002466 jarName, outputFile)
Nan Zhang4973ecf2018-08-10 13:42:12 -07002467 }
Colin Cross2fe66872015-03-30 17:20:39 -07002468}
2469
Colin Cross74d73e22017-08-02 11:05:49 -07002470var _ Dependency = (*Import)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07002471
Nan Zhanged19fc32017-10-19 13:06:22 -07002472func (j *Import) HeaderJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08002473 if j.combinedClasspathFile == nil {
2474 return nil
2475 }
Colin Cross37f6d792018-07-12 12:28:41 -07002476 return android.Paths{j.combinedClasspathFile}
Nan Zhanged19fc32017-10-19 13:06:22 -07002477}
2478
2479func (j *Import) ImplementationJars() android.Paths {
shinwang9e4c07a2018-12-24 15:41:04 +08002480 if j.combinedClasspathFile == nil {
2481 return nil
2482 }
Colin Cross37f6d792018-07-12 12:28:41 -07002483 return android.Paths{j.combinedClasspathFile}
Colin Cross2fe66872015-03-30 17:20:39 -07002484}
2485
Colin Cross331a1212018-08-15 20:40:52 -07002486func (j *Import) ResourceJars() android.Paths {
2487 return nil
2488}
2489
2490func (j *Import) ImplementationAndResourcesJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08002491 if j.combinedClasspathFile == nil {
2492 return nil
2493 }
Colin Cross331a1212018-08-15 20:40:52 -07002494 return android.Paths{j.combinedClasspathFile}
2495}
2496
Colin Crossf24a22a2019-01-31 14:12:44 -08002497func (j *Import) DexJar() android.Path {
2498 return nil
2499}
2500
Colin Cross74d73e22017-08-02 11:05:49 -07002501func (j *Import) AidlIncludeDirs() android.Paths {
Colin Crossc0b06f12015-04-08 13:03:43 -07002502 return nil
2503}
2504
Jiyong Park1be96912018-05-28 18:02:19 +09002505func (j *Import) ExportedSdkLibs() []string {
2506 return j.exportedSdkLibs
2507}
2508
Artur Satayev9cf46692019-11-26 18:08:34 +00002509func (j *Import) ExportedPlugins() (android.Paths, []string) {
2510 return nil, nil
2511}
2512
Colin Cross0c4ce212019-05-03 15:28:19 -07002513func (j *Import) SrcJarArgs() ([]string, android.Paths) {
2514 return nil, nil
2515}
2516
Jiyong Park0f80c182020-01-31 02:49:53 +09002517func (j *Import) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Jiyong Park0f80c182020-01-31 02:49:53 +09002518 // dependencies other than the static linkage are all considered crossing APEX boundary
Jooyung Hanb8fa86a2020-03-10 06:23:13 +09002519 if staticLibTag == ctx.OtherModuleDependencyTag(dep) {
2520 return true
2521 }
Jooyung Hanb8fa86a2020-03-10 06:23:13 +09002522 return false
Jiyong Park0f80c182020-01-31 02:49:53 +09002523}
2524
albaltai36ff7dc2018-12-25 14:35:23 +08002525// Add compile time check for interface implementation
2526var _ android.IDEInfo = (*Import)(nil)
2527var _ android.IDECustomizedModuleName = (*Import)(nil)
2528
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002529// Collect information for opening IDE project files in java/jdeps.go.
2530const (
2531 removedPrefix = "prebuilt_"
2532)
2533
2534func (j *Import) IDEInfo(dpInfo *android.IdeInfo) {
2535 dpInfo.Jars = append(dpInfo.Jars, j.PrebuiltSrcs()...)
2536}
2537
2538func (j *Import) IDECustomizedModuleName() string {
2539 // TODO(b/113562217): Extract the base module name from the Import name, often the Import name
2540 // has a prefix "prebuilt_". Remove the prefix explicitly if needed until we find a better
2541 // solution to get the Import name.
2542 name := j.Name()
2543 if strings.HasPrefix(name, removedPrefix) {
patricktubb640e02018-10-11 18:33:16 +08002544 name = strings.TrimPrefix(name, removedPrefix)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002545 }
2546 return name
2547}
2548
Colin Cross74d73e22017-08-02 11:05:49 -07002549var _ android.PrebuiltInterface = (*Import)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07002550
Colin Cross1b16b0e2019-02-12 14:41:32 -08002551// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library module.
2552//
2553// By default, a java_import has a single variant that expects a `.jar` file containing `.class` files that were
2554// compiled against an Android classpath.
2555//
2556// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
2557// for host modules.
Colin Cross74d73e22017-08-02 11:05:49 -07002558func ImportFactory() android.Module {
2559 module := &Import{}
Colin Cross36242852017-06-23 15:06:31 -07002560
Colin Cross74d73e22017-08-02 11:05:49 -07002561 module.AddProperties(&module.properties)
2562
2563 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002564 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09002565 android.InitSdkAwareModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002566 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross36242852017-06-23 15:06:31 -07002567 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002568}
2569
Colin Cross1b16b0e2019-02-12 14:41:32 -08002570// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library_host
2571// module.
2572//
2573// A java_import_host has a single variant that expects a `.jar` file containing `.class` files that were
2574// compiled against a host bootclasspath.
Colin Cross74d73e22017-08-02 11:05:49 -07002575func ImportFactoryHost() android.Module {
2576 module := &Import{}
2577
2578 module.AddProperties(&module.properties)
2579
2580 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002581 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002582 InitJavaModule(module, android.HostSupported)
Colin Cross74d73e22017-08-02 11:05:49 -07002583 return module
2584}
2585
Colin Cross42be7612019-02-21 18:12:14 -08002586// dex_import module
2587
2588type DexImportProperties struct {
Colin Cross5cfc70d2019-07-15 13:36:55 -07002589 Jars []string `android:"path"`
Jiyong Park4c4c0242019-10-21 14:53:15 +09002590
2591 // set the name of the output
2592 Stem *string
Colin Cross42be7612019-02-21 18:12:14 -08002593}
2594
2595type DexImport struct {
2596 android.ModuleBase
2597 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002598 android.ApexModuleBase
Colin Cross42be7612019-02-21 18:12:14 -08002599 prebuilt android.Prebuilt
2600
2601 properties DexImportProperties
2602
2603 dexJarFile android.Path
2604 maybeStrippedDexJarFile android.Path
2605
2606 dexpreopter
2607}
2608
2609func (j *DexImport) Prebuilt() *android.Prebuilt {
2610 return &j.prebuilt
2611}
2612
2613func (j *DexImport) PrebuiltSrcs() []string {
2614 return j.properties.Jars
2615}
2616
2617func (j *DexImport) Name() string {
2618 return j.prebuilt.Name(j.ModuleBase.Name())
2619}
2620
Jiyong Park0b238752019-10-29 11:23:10 +09002621func (j *DexImport) Stem() string {
2622 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
2623}
2624
Martin Stjernholm6d415272020-01-31 17:10:36 +00002625func (j *DexImport) IsInstallable() bool {
2626 return true
2627}
2628
Colin Cross42be7612019-02-21 18:12:14 -08002629func (j *DexImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2630 if len(j.properties.Jars) != 1 {
2631 ctx.PropertyErrorf("jars", "exactly one jar must be provided")
2632 }
2633
Jiyong Park0b238752019-10-29 11:23:10 +09002634 j.dexpreopter.installPath = android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar")
Colin Cross42be7612019-02-21 18:12:14 -08002635 j.dexpreopter.uncompressedDex = shouldUncompressDex(ctx, &j.dexpreopter)
2636
2637 inputJar := ctx.ExpandSource(j.properties.Jars[0], "jars")
2638 dexOutputFile := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar")
2639
2640 if j.dexpreopter.uncompressedDex {
2641 rule := android.NewRuleBuilder()
2642
2643 temporary := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar.unaligned")
2644 rule.Temporary(temporary)
2645
2646 // use zip2zip to uncompress classes*.dex files
2647 rule.Command().
Colin Crossee94d6a2019-07-08 17:08:34 -07002648 BuiltTool(ctx, "zip2zip").
Colin Cross42be7612019-02-21 18:12:14 -08002649 FlagWithInput("-i ", inputJar).
2650 FlagWithOutput("-o ", temporary).
2651 FlagWithArg("-0 ", "'classes*.dex'")
2652
2653 // use zipalign to align uncompressed classes*.dex files
2654 rule.Command().
Colin Crossee94d6a2019-07-08 17:08:34 -07002655 BuiltTool(ctx, "zipalign").
Colin Cross42be7612019-02-21 18:12:14 -08002656 Flag("-f").
2657 Text("4").
2658 Input(temporary).
2659 Output(dexOutputFile)
2660
2661 rule.DeleteTemporaryFiles()
2662
2663 rule.Build(pctx, ctx, "uncompress_dex", "uncompress dex")
2664 } else {
2665 ctx.Build(pctx, android.BuildParams{
2666 Rule: android.Cp,
2667 Input: inputJar,
2668 Output: dexOutputFile,
2669 })
2670 }
2671
2672 j.dexJarFile = dexOutputFile
2673
2674 dexOutputFile = j.dexpreopt(ctx, dexOutputFile)
2675
2676 j.maybeStrippedDexJarFile = dexOutputFile
2677
2678 ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
2679 ctx.ModuleName()+".jar", dexOutputFile)
2680}
2681
2682func (j *DexImport) DexJar() android.Path {
2683 return j.dexJarFile
2684}
2685
2686// dex_import imports a `.jar` file containing classes.dex files.
2687//
2688// A dex_import module cannot be used as a dependency of a java_* or android_* module, it can only be installed
2689// to the device.
2690func DexImportFactory() android.Module {
2691 module := &DexImport{}
2692
2693 module.AddProperties(&module.properties)
2694
2695 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002696 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002697 InitJavaModule(module, android.DeviceSupported)
Colin Cross42be7612019-02-21 18:12:14 -08002698 return module
2699}
2700
Colin Cross89536d42017-07-07 14:35:50 -07002701//
2702// Defaults
2703//
2704type Defaults struct {
2705 android.ModuleBase
2706 android.DefaultsModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002707 android.ApexModuleBase
Colin Cross89536d42017-07-07 14:35:50 -07002708}
2709
Colin Cross1b16b0e2019-02-12 14:41:32 -08002710// java_defaults provides a set of properties that can be inherited by other java or android modules.
2711//
2712// A module can use the properties from a java_defaults module using `defaults: ["defaults_module_name"]`. Each
2713// property in the defaults module that exists in the depending module will be prepended to the depending module's
2714// value for that property.
2715//
2716// Example:
2717//
2718// java_defaults {
2719// name: "example_defaults",
2720// srcs: ["common/**/*.java"],
2721// javacflags: ["-Xlint:all"],
2722// aaptflags: ["--auto-add-overlay"],
2723// }
2724//
2725// java_library {
2726// name: "example",
2727// defaults: ["example_defaults"],
2728// srcs: ["example/**/*.java"],
2729// }
2730//
2731// is functionally identical to:
2732//
2733// java_library {
2734// name: "example",
2735// srcs: [
2736// "common/**/*.java",
2737// "example/**/*.java",
2738// ],
2739// javacflags: ["-Xlint:all"],
2740// }
Colin Cross89536d42017-07-07 14:35:50 -07002741func defaultsFactory() android.Module {
2742 return DefaultsFactory()
2743}
2744
Paul Duffin47357662019-12-05 14:07:14 +00002745func DefaultsFactory() android.Module {
Colin Cross89536d42017-07-07 14:35:50 -07002746 module := &Defaults{}
2747
Colin Cross89536d42017-07-07 14:35:50 -07002748 module.AddProperties(
2749 &CompilerProperties{},
2750 &CompilerDeviceProperties{},
Colin Cross43f08db2018-11-12 10:13:39 -08002751 &DexpreoptProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08002752 &android.ProtoProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002753 &aaptProperties{},
2754 &androidLibraryProperties{},
2755 &appProperties{},
2756 &appTestProperties{},
Jaewoong Jung525443a2019-02-28 15:35:54 -08002757 &overridableAppProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002758 &ImportProperties{},
2759 &AARImportProperties{},
2760 &sdkLibraryProperties{},
Paul Duffin1a724e62020-05-08 13:44:43 +01002761 &commonToSdkLibraryAndImportProperties{},
Colin Cross42be7612019-02-21 18:12:14 -08002762 &DexImportProperties{},
Jooyung Han18020ea2019-11-13 10:50:48 +09002763 &android.ApexProperties{},
Jaewoong Jung062ed7e2020-04-26 15:10:51 -07002764 &RuntimeResourceOverlayProperties{},
Colin Cross89536d42017-07-07 14:35:50 -07002765 )
2766
2767 android.InitDefaultsModule(module)
Colin Cross89536d42017-07-07 14:35:50 -07002768 return module
2769}
Nan Zhangea568a42017-11-08 21:20:04 -08002770
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002771func kytheExtractJavaFactory() android.Singleton {
2772 return &kytheExtractJavaSingleton{}
2773}
2774
2775type kytheExtractJavaSingleton struct {
2776}
2777
2778func (ks *kytheExtractJavaSingleton) GenerateBuildActions(ctx android.SingletonContext) {
2779 var xrefTargets android.Paths
2780 ctx.VisitAllModules(func(module android.Module) {
2781 if javaModule, ok := module.(xref); ok {
2782 xrefTargets = append(xrefTargets, javaModule.XrefJavaFiles()...)
2783 }
2784 })
2785 // TODO(asmundak): perhaps emit a rule to output a warning if there were no xrefTargets
2786 if len(xrefTargets) > 0 {
2787 ctx.Build(pctx, android.BuildParams{
2788 Rule: blueprint.Phony,
2789 Output: android.PathForPhony(ctx, "xref_java"),
2790 Inputs: xrefTargets,
2791 })
2792 }
2793}
2794
Nan Zhangea568a42017-11-08 21:20:04 -08002795var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07002796var BoolDefault = proptools.BoolDefault
Nan Zhangea568a42017-11-08 21:20:04 -08002797var String = proptools.String
Colin Cross0d0ba592018-02-20 13:33:42 -08002798var inList = android.InList