blob: 1560e1869fc1b133e41339c88f265ff7bb06fafb [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 Crossaaf58062020-06-18 15:52:01 -0700256
257 // If true, package the kotlin stdlib into the jar. Defaults to true.
258 Static_kotlin_stdlib *bool `android:"arch_variant"`
Colin Cross540eff82017-06-22 17:01:52 -0700259}
260
Colin Cross89536d42017-07-07 14:35:50 -0700261type CompilerDeviceProperties struct {
Colin Cross540eff82017-06-22 17:01:52 -0700262 // list of module-specific flags that will be used for dex compiles
263 Dxflags []string `android:"arch_variant"`
264
Jeongik Cha538c0d02019-07-11 15:54:27 +0900265 // if not blank, set to the version of the sdk to compile against.
266 // Defaults to compiling against the current platform.
Nan Zhangea568a42017-11-08 21:20:04 -0800267 Sdk_version *string
Colin Cross7d5136f2015-05-11 13:39:40 -0700268
Colin Cross83bb3162018-06-25 15:48:06 -0700269 // if not blank, set the minimum version of the sdk that the compiled artifacts will run against.
270 // Defaults to sdk_version if not set.
271 Min_sdk_version *string
272
Dan Willemsen419290a2018-10-31 15:28:47 -0700273 // if not blank, set the targetSdkVersion in the AndroidManifest.xml.
274 // Defaults to sdk_version if not set.
275 Target_sdk_version *string
276
Jeongik Cha356dac42019-08-19 14:09:52 +0900277 // Whether to compile against the platform APIs instead of an SDK.
278 // If true, then sdk_version must be empty. The value of this field
279 // is ignored when module's type isn't android_app.
Colin Cross6af2e492018-05-22 11:12:33 -0700280 Platform_apis *bool
281
Colin Crossebe1a512017-11-14 13:12:14 -0800282 Aidl struct {
283 // Top level directories to pass to aidl tool
284 Include_dirs []string
Colin Cross7d5136f2015-05-11 13:39:40 -0700285
Colin Crossebe1a512017-11-14 13:12:14 -0800286 // Directories rooted at the Android.bp file to pass to aidl tool
287 Local_include_dirs []string
288
289 // directories that should be added as include directories for any aidl sources of modules
290 // that depend on this module, as well as to aidl for this module.
291 Export_include_dirs []string
Martijn Coeneneab15642018-03-09 09:29:59 +0100292
293 // whether to generate traces (for systrace) for this interface
294 Generate_traces *bool
Olivier Gaillard0a4cfbc2018-07-16 23:37:03 +0100295
296 // whether to generate Binder#GetTransaction name method.
297 Generate_get_transaction_name *bool
Colin Crossebe1a512017-11-14 13:12:14 -0800298 }
Colin Cross92430102017-10-09 14:59:32 -0700299
300 // If true, export a copy of the module as a -hostdex module for host testing.
301 Hostdex *bool
Colin Cross1369cdb2017-09-29 17:58:17 -0700302
Colin Cross7f87f4f2019-04-24 13:41:45 -0700303 Target struct {
304 Hostdex struct {
305 // Additional required dependencies to add to -hostdex modules.
306 Required []string
307 }
308 }
309
David Brazdil17ef5632018-06-27 10:27:45 +0100310 // If set to true, compile dex regardless of installable. Defaults to false.
311 Compile_dex *bool
312
Colin Cross66dbc0b2017-12-28 12:23:20 -0800313 Optimize struct {
Colin Crossae5caf52018-05-22 11:11:52 -0700314 // If false, disable all optimization. Defaults to true for android_app and android_test
315 // modules, false for java_library and java_test modules.
Colin Cross66dbc0b2017-12-28 12:23:20 -0800316 Enabled *bool
Sasha Smundak2057f822019-04-16 17:16:58 -0700317 // True if the module containing this has it set by default.
318 EnabledByDefault bool `blueprint:"mutated"`
Colin Cross66dbc0b2017-12-28 12:23:20 -0800319
320 // If true, optimize for size by removing unused code. Defaults to true for apps,
321 // false for libraries and tests.
322 Shrink *bool
323
324 // If true, optimize bytecode. Defaults to false.
325 Optimize *bool
326
327 // If true, obfuscate bytecode. Defaults to false.
328 Obfuscate *bool
329
330 // If true, do not use the flag files generated by aapt that automatically keep
331 // classes referenced by the app manifest. Defaults to false.
332 No_aapt_flags *bool
333
334 // Flags to pass to proguard.
335 Proguard_flags []string
336
337 // Specifies the locations of files containing proguard flags.
Colin Cross27b922f2019-03-04 22:35:41 -0800338 Proguard_flags_files []string `android:"path"`
Colin Cross66dbc0b2017-12-28 12:23:20 -0800339 }
340
Paul Duffine25c6442019-10-11 13:50:28 +0100341 // When targeting 1.9 and above, override the modules to use with --system,
342 // otherwise provides defaults libraries to add to the bootclasspath.
Colin Cross1369cdb2017-09-29 17:58:17 -0700343 System_modules *string
Colin Cross5a0dcd52018-10-05 14:20:06 -0700344
Jiyong Park4c4c0242019-10-21 14:53:15 +0900345 // set the name of the output
346 Stem *string
347
David Srbecky98c71222020-05-20 22:20:28 +0100348 // Keep the data uncompressed. We always need uncompressed dex for execution,
349 // so this might actually save space by avoiding storing the same data twice.
350 // This defaults to reasonable value based on module and should not be set.
351 // It exists only to support ART tests.
352 Uncompress_dex *bool
353
354 IsSDKLibrary bool `blueprint:"mutated"`
Songchun Fan688de9a2020-03-24 20:32:24 -0700355
356 // If true, generate the signature file of APK Signing Scheme V4, along side the signed APK file.
357 // Defaults to false.
358 V4_signature *bool
Colin Cross7d5136f2015-05-11 13:39:40 -0700359}
360
Sasha Smundak2057f822019-04-16 17:16:58 -0700361func (me *CompilerDeviceProperties) EffectiveOptimizeEnabled() bool {
362 return BoolDefault(me.Optimize.Enabled, me.Optimize.EnabledByDefault)
363}
364
Paul Duffinc8f2f182020-05-17 08:34:50 +0100365// Functionality common to Module and Import
Paul Duffin64e61992020-05-15 10:20:31 +0100366//
367// It is embedded in Module so its functionality can be used by methods in Module
368// but it is currently only initialized by Import and Library.
Paul Duffinc8f2f182020-05-17 08:34:50 +0100369type embeddableInModuleAndImport struct {
Paul Duffin64e61992020-05-15 10:20:31 +0100370
371 // Functionality related to this being used as a component of a java_sdk_library.
372 EmbeddableSdkLibraryComponent
373}
374
375func (e *embeddableInModuleAndImport) initModuleAndImport(moduleBase *android.ModuleBase) {
376 e.initSdkLibraryComponent(moduleBase)
Paul Duffinc8f2f182020-05-17 08:34:50 +0100377}
378
379// Module/Import's DepIsInSameApex(...) delegates to this method.
380//
381// This cannot implement DepIsInSameApex(...) directly as that leads to ambiguity with
382// the one provided by ApexModuleBase.
383func (e *embeddableInModuleAndImport) depIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
384 // dependencies other than the static linkage are all considered crossing APEX boundary
385 if staticLibTag == ctx.OtherModuleDependencyTag(dep) {
386 return true
387 }
388 return false
389}
390
Colin Cross46c9b8b2017-06-22 16:51:17 -0700391// Module contains the properties and members used by all java module types
392type Module struct {
Colin Cross635c3b02016-05-18 15:37:25 -0700393 android.ModuleBase
Colin Cross89536d42017-07-07 14:35:50 -0700394 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +0900395 android.ApexModuleBase
Jiyong Parkd1063c12019-07-17 20:08:41 +0900396 android.SdkBase
Colin Cross2fe66872015-03-30 17:20:39 -0700397
Paul Duffinc8f2f182020-05-17 08:34:50 +0100398 // Functionality common to Module and Import.
399 embeddableInModuleAndImport
400
Colin Cross89536d42017-07-07 14:35:50 -0700401 properties CompilerProperties
Colin Cross6af17aa2017-09-20 12:59:05 -0700402 protoProperties android.ProtoProperties
Colin Cross89536d42017-07-07 14:35:50 -0700403 deviceProperties CompilerDeviceProperties
Colin Cross2fe66872015-03-30 17:20:39 -0700404
Colin Cross331a1212018-08-15 20:40:52 -0700405 // jar file containing header classes including static library dependencies, suitable for
406 // inserting into the bootclasspath/classpath of another compile
Nan Zhanged19fc32017-10-19 13:06:22 -0700407 headerJarFile android.Path
408
Colin Cross331a1212018-08-15 20:40:52 -0700409 // jar file containing implementation classes including static library dependencies but no
410 // resources
Nan Zhanged19fc32017-10-19 13:06:22 -0700411 implementationJarFile android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700412
Colin Cross331a1212018-08-15 20:40:52 -0700413 // jar file containing only resources including from static library dependencies
414 resourceJar android.Path
415
Colin Cross0c4ce212019-05-03 15:28:19 -0700416 // args and dependencies to package source files into a srcjar
417 srcJarArgs []string
418 srcJarDeps android.Paths
419
Colin Cross331a1212018-08-15 20:40:52 -0700420 // jar file containing implementation classes and resources including static library
421 // dependencies
422 implementationAndResourcesJar android.Path
423
424 // output file containing classes.dex and resources
Colin Cross6ade34f2017-09-15 13:00:47 -0700425 dexJarFile android.Path
426
Colin Cross43f08db2018-11-12 10:13:39 -0800427 // output file that contains classes.dex if it should be in the output file
428 maybeStrippedDexJarFile android.Path
429
Colin Crosscb933592017-11-22 13:49:43 -0800430 // output file containing uninstrumented classes that will be instrumented by jacoco
431 jacocoReportClassesFile android.Path
432
Colin Cross66dbc0b2017-12-28 12:23:20 -0800433 // output file containing mapping of obfuscated names
434 proguardDictionary android.Path
435
Colin Cross331a1212018-08-15 20:40:52 -0700436 // output file of the module, which may be a classes jar or a dex jar
Colin Crosse560c4a2019-03-19 16:03:11 -0700437 outputFile android.Path
438 extraOutputFiles android.Paths
Colin Crossb7a63242015-04-16 14:09:14 -0700439
Colin Cross635c3b02016-05-18 15:37:25 -0700440 exportAidlIncludeDirs android.Paths
Colin Crossc0b06f12015-04-08 13:03:43 -0700441
Colin Cross635c3b02016-05-18 15:37:25 -0700442 logtagsSrcs android.Paths
Colin Crossf05fe972015-04-10 17:45:20 -0700443
Colin Cross2fe66872015-03-30 17:20:39 -0700444 // installed file for binary dependency
Colin Cross635c3b02016-05-18 15:37:25 -0700445 installFile android.Path
Colin Cross5ab4e6d2017-11-22 16:20:45 -0800446
447 // list of .java files and srcjars that was passed to javac
448 compiledJavaSrcs android.Paths
449 compiledSrcJars android.Paths
Colin Cross66dbc0b2017-12-28 12:23:20 -0800450
451 // list of extra progurad flag files
452 extraProguardFlagFiles android.Paths
Jiyong Park1be96912018-05-28 18:02:19 +0900453
Colin Cross094054a2018-10-17 15:10:48 -0700454 // manifest file to use instead of properties.Manifest
455 overrideManifest android.OptionalPath
456
Artur Satayev9cf46692019-11-26 18:08:34 +0000457 // list of SDK lib names that this java module is exporting
Jiyong Park1be96912018-05-28 18:02:19 +0900458 exportedSdkLibs []string
Brandon Lee5d45c6f2018-08-15 15:35:38 -0700459
Artur Satayev9cf46692019-11-26 18:08:34 +0000460 // list of plugins that this java module is exporting
461 exportedPluginJars android.Paths
462
463 // list of plugins that this java module is exporting
464 exportedPluginClasses []string
465
466 // list of source files, collected from srcFiles with unique java and all kt files,
patricktu242faad2019-09-24 15:41:30 +0800467 // will be used by android.IDEInfo struct
Brandon Lee5d45c6f2018-08-15 15:35:38 -0700468 expandIDEInfoCompiledSrcs []string
Colin Cross43f08db2018-11-12 10:13:39 -0800469
Steven Morelandc4efd9c2019-01-18 11:51:25 -0800470 // expanded Jarjar_rules
471 expandJarjarRules android.Path
472
Tej Singh83839722020-06-03 18:45:54 +0000473 // list of additional targets for checkbuild
474 additionalCheckedModules android.Paths
475
Colin Cross988708c2019-05-06 14:04:11 -0700476 // Extra files generated by the module type to be added as java resources.
477 extraResources android.Paths
478
Colin Crossf24a22a2019-01-31 14:12:44 -0800479 hiddenAPI
Colin Cross43f08db2018-11-12 10:13:39 -0800480 dexpreopter
Colin Cross1e28e3c2020-06-02 20:09:13 -0700481 linter
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800482
483 // list of the xref extraction files
484 kytheFiles android.Paths
Anton Hansson1e65f942020-03-27 19:39:48 +0000485
486 distFile android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700487}
488
Colin Cross1c14b4e2020-06-15 16:09:53 -0700489func (j *Module) addHostProperties() {
490 j.AddProperties(
491 &j.properties,
492 &j.protoProperties,
493 )
494}
495
496func (j *Module) addHostAndDeviceProperties() {
497 j.addHostProperties()
498 j.AddProperties(
499 &j.deviceProperties,
500 &j.dexpreoptProperties,
Colin Cross1e28e3c2020-06-02 20:09:13 -0700501 &j.linter.properties,
Colin Cross1c14b4e2020-06-15 16:09:53 -0700502 )
503}
504
Colin Cross41955e82019-05-29 14:40:35 -0700505func (j *Module) OutputFiles(tag string) (android.Paths, error) {
506 switch tag {
507 case "":
508 return append(android.Paths{j.outputFile}, j.extraOutputFiles...), nil
Colin Cross375ca3c2019-05-29 14:40:58 -0700509 case ".jar":
510 return android.Paths{j.implementationAndResourcesJar}, nil
Colin Cross2d975b12019-07-29 16:47:42 -0700511 case ".proguard_map":
512 return android.Paths{j.proguardDictionary}, nil
Colin Cross41955e82019-05-29 14:40:35 -0700513 default:
514 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
515 }
Colin Cross54250902017-12-05 09:28:08 -0800516}
517
Colin Cross41955e82019-05-29 14:40:35 -0700518var _ android.OutputFileProducer = (*Module)(nil)
Colin Cross54250902017-12-05 09:28:08 -0800519
Paul Duffin9ee66da2020-06-17 16:59:43 +0100520// Methods that need to be implemented for a module that is added to apex java_libs property.
521type ApexDependency interface {
Nan Zhanged19fc32017-10-19 13:06:22 -0700522 HeaderJars() android.Paths
Paul Duffin9ee66da2020-06-17 16:59:43 +0100523 ImplementationAndResourcesJars() android.Paths
524}
525
526type Dependency interface {
527 ApexDependency
Nan Zhanged19fc32017-10-19 13:06:22 -0700528 ImplementationJars() android.Paths
Colin Cross331a1212018-08-15 20:40:52 -0700529 ResourceJars() android.Paths
Colin Crossf24a22a2019-01-31 14:12:44 -0800530 DexJar() android.Path
Colin Cross635c3b02016-05-18 15:37:25 -0700531 AidlIncludeDirs() android.Paths
Jiyong Park1be96912018-05-28 18:02:19 +0900532 ExportedSdkLibs() []string
Artur Satayev9cf46692019-11-26 18:08:34 +0000533 ExportedPlugins() (android.Paths, []string)
Colin Cross0c4ce212019-05-03 15:28:19 -0700534 SrcJarArgs() ([]string, android.Paths)
Colin Crosse323f3c2019-09-17 15:34:09 -0700535 BaseModuleName() string
Jiyong Park618922e2020-01-08 13:35:43 +0900536 JacocoReportClassesFile() android.Path
Colin Cross2fe66872015-03-30 17:20:39 -0700537}
538
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800539type xref interface {
540 XrefJavaFiles() android.Paths
541}
542
Sasha Smundak2a4549e2018-11-05 16:49:08 -0800543func (j *Module) XrefJavaFiles() android.Paths {
544 return j.kytheFiles
545}
546
Colin Cross89536d42017-07-07 14:35:50 -0700547func InitJavaModule(module android.DefaultableModule, hod android.HostOrDeviceSupported) {
548 android.InitAndroidArchModule(module, hod, android.MultilibCommon)
549 android.InitDefaultableModule(module)
550}
551
Colin Crossbe1da472017-07-07 15:59:46 -0700552type dependencyTag struct {
553 blueprint.BaseDependencyTag
554 name string
Colin Cross2fe66872015-03-30 17:20:39 -0700555}
556
Colin Crossa4f08812018-10-02 22:03:40 -0700557type jniDependencyTag struct {
558 blueprint.BaseDependencyTag
Colin Crossa4f08812018-10-02 22:03:40 -0700559}
560
Jiyong Park8be103b2019-11-08 15:53:48 +0900561func IsJniDepTag(depTag blueprint.DependencyTag) bool {
562 _, ok := depTag.(*jniDependencyTag)
563 return ok
564}
565
Colin Crossbe1da472017-07-07 15:59:46 -0700566var (
Colin Cross4b964c02018-10-15 16:18:06 -0700567 staticLibTag = dependencyTag{name: "staticlib"}
568 libTag = dependencyTag{name: "javalib"}
Colin Cross6cef4812019-10-17 14:23:50 -0700569 java9LibTag = dependencyTag{name: "java9lib"}
Colin Crossbe9cdb82019-01-21 21:37:16 -0800570 pluginTag = dependencyTag{name: "plugin"}
Artur Satayev9cf46692019-11-26 18:08:34 +0000571 exportedPluginTag = dependencyTag{name: "exported-plugin"}
Colin Cross4b964c02018-10-15 16:18:06 -0700572 bootClasspathTag = dependencyTag{name: "bootclasspath"}
573 systemModulesTag = dependencyTag{name: "system modules"}
574 frameworkResTag = dependencyTag{name: "framework-res"}
575 frameworkApkTag = dependencyTag{name: "framework-apk"}
576 kotlinStdlibTag = dependencyTag{name: "kotlin-stdlib"}
Colin Crossafbb1732019-01-17 15:42:52 -0800577 kotlinAnnotationsTag = dependencyTag{name: "kotlin-annotations"}
Colin Cross4b964c02018-10-15 16:18:06 -0700578 proguardRaiseTag = dependencyTag{name: "proguard-raise"}
579 certificateTag = dependencyTag{name: "certificate"}
580 instrumentationForTag = dependencyTag{name: "instrumentation_for"}
Colin Cross50ddcc42019-05-16 12:28:22 -0700581 usesLibTag = dependencyTag{name: "uses-library"}
Colin Cross205a5042020-06-18 15:56:48 -0700582 extraLintCheckTag = dependencyTag{name: "extra-lint-check"}
Colin Crossbe1da472017-07-07 15:59:46 -0700583)
Colin Cross2fe66872015-03-30 17:20:39 -0700584
Jiyong Park83dc74b2020-01-14 18:38:44 +0900585func IsLibDepTag(depTag blueprint.DependencyTag) bool {
586 return depTag == libTag
587}
588
589func IsStaticLibDepTag(depTag blueprint.DependencyTag) bool {
590 return depTag == staticLibTag
591}
592
Colin Crossfc3674a2017-09-18 17:41:52 -0700593type sdkDep struct {
Colin Cross47ff2522017-10-02 14:22:08 -0700594 useModule, useFiles, useDefaultLibs, invalidVersion bool
595
Colin Cross6cef4812019-10-17 14:23:50 -0700596 // The modules that will be added to the bootclasspath when targeting 1.8 or lower
597 bootclasspath []string
Paul Duffine25c6442019-10-11 13:50:28 +0100598
599 // The default system modules to use. Will be an empty string if no system
600 // modules are to be used.
Colin Cross1369cdb2017-09-29 17:58:17 -0700601 systemModules string
602
Colin Cross6cef4812019-10-17 14:23:50 -0700603 // The modules that will be added ot the classpath when targeting 1.9 or higher
604 java9Classpath []string
605
Colin Crossa97c5d32018-03-28 14:58:31 -0700606 frameworkResModule string
607
Colin Cross86a60ae2018-05-29 14:44:55 -0700608 jars android.Paths
Colin Cross3047fa22019-04-18 10:56:44 -0700609 aidl android.OptionalPath
Paul Duffin250e6192019-06-07 10:44:37 +0100610
611 noStandardLibs, noFrameworksLibs bool
612}
613
614func (s sdkDep) hasStandardLibs() bool {
615 return !s.noStandardLibs
616}
617
618func (s sdkDep) hasFrameworkLibs() bool {
619 return !s.noStandardLibs && !s.noFrameworksLibs
Colin Cross1369cdb2017-09-29 17:58:17 -0700620}
621
Colin Crossa4f08812018-10-02 22:03:40 -0700622type jniLib struct {
Jaewoong Jung37ca4a12020-03-26 14:01:48 -0700623 name string
624 path android.Path
625 target android.Target
626 coverageFile android.OptionalPath
Colin Crossa4f08812018-10-02 22:03:40 -0700627}
628
Colin Cross0ea8ba82019-06-06 14:33:29 -0700629func (j *Module) shouldInstrument(ctx android.BaseModuleContext) bool {
Roland Levillain583691a2020-06-09 13:07:36 +0100630 return j.properties.Instrument &&
631 ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") &&
632 ctx.DeviceConfig().JavaCoverageEnabledForPath(ctx.ModuleDir())
Colin Cross3144dfc2018-01-03 15:06:47 -0800633}
634
Colin Cross0ea8ba82019-06-06 14:33:29 -0700635func (j *Module) shouldInstrumentStatic(ctx android.BaseModuleContext) bool {
Colin Cross3144dfc2018-01-03 15:06:47 -0800636 return j.shouldInstrument(ctx) &&
637 (ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_STATIC") ||
638 ctx.Config().UnbundledBuild())
639}
640
Jiyong Park6a927c42020-01-21 02:03:43 +0900641func (j *Module) sdkVersion() sdkSpec {
642 return sdkSpecFrom(String(j.deviceProperties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -0700643}
644
Paul Duffine25c6442019-10-11 13:50:28 +0100645func (j *Module) systemModules() string {
646 return proptools.String(j.deviceProperties.System_modules)
647}
648
Jiyong Park6a927c42020-01-21 02:03:43 +0900649func (j *Module) minSdkVersion() sdkSpec {
Colin Cross83bb3162018-06-25 15:48:06 -0700650 if j.deviceProperties.Min_sdk_version != nil {
Jiyong Park6a927c42020-01-21 02:03:43 +0900651 return sdkSpecFrom(*j.deviceProperties.Min_sdk_version)
Colin Cross83bb3162018-06-25 15:48:06 -0700652 }
653 return j.sdkVersion()
654}
655
Jiyong Park6a927c42020-01-21 02:03:43 +0900656func (j *Module) targetSdkVersion() sdkSpec {
Dan Willemsen419290a2018-10-31 15:28:47 -0700657 if j.deviceProperties.Target_sdk_version != nil {
Jiyong Park6a927c42020-01-21 02:03:43 +0900658 return sdkSpecFrom(*j.deviceProperties.Target_sdk_version)
Dan Willemsen419290a2018-10-31 15:28:47 -0700659 }
660 return j.sdkVersion()
661}
662
Artur Satayev388d39b2020-04-27 18:53:18 +0100663func (j *Module) MinSdkVersion() string {
664 return j.minSdkVersion().version.String()
665}
666
Jiyong Parkb02bb402019-12-03 00:43:57 +0900667func (j *Module) AvailableFor(what string) bool {
668 if what == android.AvailableToPlatform && Bool(j.deviceProperties.Hostdex) {
669 // Exception: for hostdex: true libraries, the platform variant is created
670 // even if it's not marked as available to platform. In that case, the platform
671 // variant is used only for the hostdex and not installed to the device.
672 return true
673 }
674 return j.ApexModuleBase.AvailableFor(what)
675}
676
Colin Crossbe1da472017-07-07 15:59:46 -0700677func (j *Module) deps(ctx android.BottomUpMutatorContext) {
Colin Cross1369cdb2017-09-29 17:58:17 -0700678 if ctx.Device() {
Colin Cross205a5042020-06-18 15:56:48 -0700679 j.linter.deps(ctx)
680
Paul Duffin250e6192019-06-07 10:44:37 +0100681 sdkDep := decodeSdkDep(ctx, sdkContext(j))
Colin Cross6d8d8c62019-10-28 15:10:03 -0700682 if sdkDep.useDefaultLibs {
683 ctx.AddVariationDependencies(nil, bootClasspathTag, config.DefaultBootclasspathLibraries...)
684 ctx.AddVariationDependencies(nil, systemModulesTag, config.DefaultSystemModules)
685 if sdkDep.hasFrameworkLibs() {
686 ctx.AddVariationDependencies(nil, libTag, config.DefaultLibraries...)
Colin Crossbe1da472017-07-07 15:59:46 -0700687 }
Colin Cross6d8d8c62019-10-28 15:10:03 -0700688 } else if sdkDep.useModule {
Colin Cross6cef4812019-10-17 14:23:50 -0700689 ctx.AddVariationDependencies(nil, bootClasspathTag, sdkDep.bootclasspath...)
Colin Cross6cef4812019-10-17 14:23:50 -0700690 ctx.AddVariationDependencies(nil, java9LibTag, sdkDep.java9Classpath...)
Colin Cross6d8d8c62019-10-28 15:10:03 -0700691 if j.deviceProperties.EffectiveOptimizeEnabled() && sdkDep.hasStandardLibs() {
692 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultBootclasspathLibraries...)
693 ctx.AddVariationDependencies(nil, proguardRaiseTag, config.DefaultLibraries...)
694 }
Colin Cross2fe66872015-03-30 17:20:39 -0700695 }
Colin Crossdb224752020-05-14 18:05:32 -0700696 if sdkDep.systemModules != "" {
697 ctx.AddVariationDependencies(nil, systemModulesTag, sdkDep.systemModules)
698 }
Colin Cross6d8d8c62019-10-28 15:10:03 -0700699
Nan Zhangb2b33de2018-02-23 11:18:47 -0800700 if ctx.ModuleName() == "android_stubs_current" ||
701 ctx.ModuleName() == "android_system_stubs_current" ||
Nan Zhang863f05b2018-08-07 13:41:10 -0700702 ctx.ModuleName() == "android_test_stubs_current" {
Colin Cross42d48b72018-08-29 14:10:52 -0700703 ctx.AddVariationDependencies(nil, frameworkApkTag, "framework-res")
Nan Zhangb2b33de2018-02-23 11:18:47 -0800704 }
Colin Cross2fe66872015-03-30 17:20:39 -0700705 }
Colin Cross1369cdb2017-09-29 17:58:17 -0700706
Inseob Kimac1e9862019-12-09 18:15:47 +0900707 syspropPublicStubs := syspropPublicStubs(ctx.Config())
708
709 // rewriteSyspropLibs validates if a java module can link against platform's sysprop_library,
710 // and redirects dependency to public stub depending on the link type.
711 rewriteSyspropLibs := func(libs []string, prop string) []string {
712 // make a copy
713 ret := android.CopyOf(libs)
714
715 for idx, lib := range libs {
716 stub, ok := syspropPublicStubs[lib]
717
718 if !ok {
719 continue
720 }
721
722 linkType, _ := j.getLinkType(ctx.ModuleName())
Inseob Kimc5239512020-01-14 15:36:21 +0900723 // only platform modules can use internal props
724 if linkType != javaPlatform {
Inseob Kimac1e9862019-12-09 18:15:47 +0900725 ret[idx] = stub
Inseob Kimac1e9862019-12-09 18:15:47 +0900726 }
727 }
728
729 return ret
730 }
731
732 ctx.AddVariationDependencies(nil, libTag, rewriteSyspropLibs(j.properties.Libs, "libs")...)
733 ctx.AddVariationDependencies(nil, staticLibTag, rewriteSyspropLibs(j.properties.Static_libs, "static_libs")...)
Colin Crossa4f08812018-10-02 22:03:40 -0700734
Colin Cross0f7d2ef2019-10-16 11:03:10 -0700735 ctx.AddFarVariationDependencies(ctx.Config().BuildOSCommonTarget.Variations(), pluginTag, j.properties.Plugins...)
Artur Satayev9cf46692019-11-26 18:08:34 +0000736 ctx.AddFarVariationDependencies(ctx.Config().BuildOSCommonTarget.Variations(), exportedPluginTag, j.properties.Exported_plugins...)
Colin Crossbe9cdb82019-01-21 21:37:16 -0800737
Colin Crossfe17f6f2019-03-28 19:30:56 -0700738 android.ProtoDeps(ctx, &j.protoProperties)
Colin Cross6af17aa2017-09-20 12:59:05 -0700739 if j.hasSrcExt(".proto") {
740 protoDeps(ctx, &j.protoProperties)
741 }
Colin Cross93e85952017-08-15 13:34:18 -0700742
743 if j.hasSrcExt(".kt") {
744 // TODO(ccross): move this to a mutator pass that can tell if generated sources contain
745 // Kotlin files
Colin Cross0b03d972019-05-13 11:06:25 -0700746 ctx.AddVariationDependencies(nil, kotlinStdlibTag,
747 "kotlin-stdlib", "kotlin-stdlib-jdk7", "kotlin-stdlib-jdk8")
Colin Cross7788c122019-01-23 16:14:02 -0800748 if len(j.properties.Plugins) > 0 {
Colin Crossafbb1732019-01-17 15:42:52 -0800749 ctx.AddVariationDependencies(nil, kotlinAnnotationsTag, "kotlin-annotations")
750 }
Colin Cross93e85952017-08-15 13:34:18 -0700751 }
Colin Cross3144dfc2018-01-03 15:06:47 -0800752
Ulya Trafimovich38dfa0f2020-01-07 16:37:02 +0000753 // Framework libraries need special handling in static coverage builds: they should not have
754 // static dependency on jacoco, otherwise there would be multiple conflicting definitions of
755 // the same jacoco classes coming from different bootclasspath jars.
756 if inList(ctx.ModuleName(), config.InstrumentFrameworkModules) {
757 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT_FRAMEWORK") {
758 j.properties.Instrument = true
759 }
760 } else if j.shouldInstrumentStatic(ctx) {
Colin Cross42d48b72018-08-29 14:10:52 -0700761 ctx.AddVariationDependencies(nil, staticLibTag, "jacocoagent")
Colin Cross3144dfc2018-01-03 15:06:47 -0800762 }
Colin Cross6af17aa2017-09-20 12:59:05 -0700763}
764
765func hasSrcExt(srcs []string, ext string) bool {
766 for _, src := range srcs {
767 if filepath.Ext(src) == ext {
768 return true
769 }
770 }
771
772 return false
773}
774
775func (j *Module) hasSrcExt(ext string) bool {
776 return hasSrcExt(j.properties.Srcs, ext)
Colin Cross2fe66872015-03-30 17:20:39 -0700777}
778
Colin Cross46c9b8b2017-06-22 16:51:17 -0700779func (j *Module) aidlFlags(ctx android.ModuleContext, aidlPreprocess android.OptionalPath,
Colin Cross3047fa22019-04-18 10:56:44 -0700780 aidlIncludeDirs android.Paths) (string, android.Paths) {
Colin Crossc0b06f12015-04-08 13:03:43 -0700781
Colin Crossebe1a512017-11-14 13:12:14 -0800782 aidlIncludes := android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Local_include_dirs)
783 aidlIncludes = append(aidlIncludes,
784 android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)...)
785 aidlIncludes = append(aidlIncludes,
786 android.PathsForSource(ctx, j.deviceProperties.Aidl.Include_dirs)...)
Colin Crossc0b06f12015-04-08 13:03:43 -0700787
Colin Cross3047fa22019-04-18 10:56:44 -0700788 var flags []string
789 var deps android.Paths
Steven Moreland667f6882018-07-26 12:55:08 -0700790
Dan Willemsen34cc69e2015-09-23 15:26:20 -0700791 if aidlPreprocess.Valid() {
792 flags = append(flags, "-p"+aidlPreprocess.String())
Colin Cross3047fa22019-04-18 10:56:44 -0700793 deps = append(deps, aidlPreprocess.Path())
794 } else if len(aidlIncludeDirs) > 0 {
Colin Cross635c3b02016-05-18 15:37:25 -0700795 flags = append(flags, android.JoinWithPrefix(aidlIncludeDirs.Strings(), "-I"))
Colin Crossc0b06f12015-04-08 13:03:43 -0700796 }
797
Colin Cross3047fa22019-04-18 10:56:44 -0700798 if len(j.exportAidlIncludeDirs) > 0 {
799 flags = append(flags, android.JoinWithPrefix(j.exportAidlIncludeDirs.Strings(), "-I"))
800 }
801
802 if len(aidlIncludes) > 0 {
803 flags = append(flags, android.JoinWithPrefix(aidlIncludes.Strings(), "-I"))
804 }
805
Colin Cross635c3b02016-05-18 15:37:25 -0700806 flags = append(flags, "-I"+android.PathForModuleSrc(ctx).String())
Colin Cross32f38982018-02-22 11:47:25 -0800807 if src := android.ExistentPathForSource(ctx, ctx.ModuleDir(), "src"); src.Valid() {
Colin Crossd48633a2017-07-13 14:41:17 -0700808 flags = append(flags, "-I"+src.String())
809 }
Colin Crossc0b06f12015-04-08 13:03:43 -0700810
Martijn Coeneneab15642018-03-09 09:29:59 +0100811 if Bool(j.deviceProperties.Aidl.Generate_traces) {
812 flags = append(flags, "-t")
813 }
814
Olivier Gaillard0a4cfbc2018-07-16 23:37:03 +0100815 if Bool(j.deviceProperties.Aidl.Generate_get_transaction_name) {
816 flags = append(flags, "--transaction_names")
817 }
818
Colin Cross3047fa22019-04-18 10:56:44 -0700819 return strings.Join(flags, " "), deps
Colin Crossc0b06f12015-04-08 13:03:43 -0700820}
821
Colin Cross32f676a2017-09-06 13:41:06 -0700822type deps struct {
Nan Zhang581fd212018-01-10 16:06:12 -0800823 classpath classpath
Colin Cross6cef4812019-10-17 14:23:50 -0700824 java9Classpath classpath
Nan Zhang581fd212018-01-10 16:06:12 -0800825 bootClasspath classpath
Colin Cross6a77c982018-06-19 22:43:34 -0700826 processorPath classpath
Colin Crossbe9cdb82019-01-21 21:37:16 -0800827 processorClasses []string
Colin Cross6ade34f2017-09-15 13:00:47 -0700828 staticJars android.Paths
Nan Zhanged19fc32017-10-19 13:06:22 -0700829 staticHeaderJars android.Paths
Colin Cross331a1212018-08-15 20:40:52 -0700830 staticResourceJars android.Paths
Colin Cross6ade34f2017-09-15 13:00:47 -0700831 aidlIncludeDirs android.Paths
Nan Zhangb2b33de2018-02-23 11:18:47 -0800832 srcs android.Paths
Colin Cross59149b62017-10-16 18:07:29 -0700833 srcJars android.Paths
Colin Crossb77043e2019-07-16 13:57:13 -0700834 systemModules *systemModules
Colin Cross6ade34f2017-09-15 13:00:47 -0700835 aidlPreprocess android.OptionalPath
Colin Cross93e85952017-08-15 13:34:18 -0700836 kotlinStdlib android.Paths
Colin Crossafbb1732019-01-17 15:42:52 -0800837 kotlinAnnotations android.Paths
Colin Crossbe9cdb82019-01-21 21:37:16 -0800838
839 disableTurbine bool
Colin Cross32f676a2017-09-06 13:41:06 -0700840}
Colin Cross2fe66872015-03-30 17:20:39 -0700841
Colin Cross54250902017-12-05 09:28:08 -0800842func checkProducesJars(ctx android.ModuleContext, dep android.SourceFileProducer) {
843 for _, f := range dep.Srcs() {
844 if f.Ext() != ".jar" {
845 ctx.ModuleErrorf("genrule %q must generate files ending with .jar to be used as a libs or static_libs dependency",
846 ctx.OtherModuleName(dep.(blueprint.Module)))
847 }
848 }
849}
850
Jiyong Park2d492942018-03-05 17:44:10 +0900851type linkType int
852
853const (
Jiyong Park50146e92020-01-30 18:00:15 +0900854 // TODO(jiyong) rename these for better readability. Make the allowed
855 // and disallowed link types explicit
Jiyong Park2d492942018-03-05 17:44:10 +0900856 javaCore linkType = iota
857 javaSdk
858 javaSystem
Jiyong Park50146e92020-01-30 18:00:15 +0900859 javaModule
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900860 javaSystemServer
Jiyong Park2d492942018-03-05 17:44:10 +0900861 javaPlatform
862)
863
Jeongik Cha75b83b02019-11-01 15:28:00 +0900864type linkTypeContext interface {
865 android.Module
866 getLinkType(name string) (ret linkType, stubs bool)
867}
868
869func (m *Module) getLinkType(name string) (ret linkType, stubs bool) {
Anton Hanssonac103462020-05-19 12:06:48 +0100870 switch name {
871 case "core.current.stubs", "core.platform.api.stubs", "stub-annotations",
872 "private-stub-annotations-jar", "core-lambda-stubs", "core-generated-annotation-stubs":
Jiyong Park46f78fb2018-10-20 16:33:17 +0900873 return javaCore, true
Anton Hanssonac103462020-05-19 12:06:48 +0100874 case "android_stubs_current":
Jiyong Park46f78fb2018-10-20 16:33:17 +0900875 return javaSdk, true
Anton Hanssonac103462020-05-19 12:06:48 +0100876 case "android_system_stubs_current":
877 return javaSystem, true
878 case "android_module_lib_stubs_current":
Jiyong Park50146e92020-01-30 18:00:15 +0900879 return javaModule, true
Anton Hanssonac103462020-05-19 12:06:48 +0100880 case "android_system_server_stubs_current":
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900881 return javaSystemServer, true
Anton Hanssonac103462020-05-19 12:06:48 +0100882 case "android_test_stubs_current":
883 return javaSystem, true
Jiyong Park2d492942018-03-05 17:44:10 +0900884 }
Anton Hanssonac103462020-05-19 12:06:48 +0100885
Anton Hansson0bd88d02020-05-25 12:20:51 +0100886 if stub, linkType := moduleStubLinkType(name); stub {
887 return linkType, true
888 }
889
Anton Hanssonac103462020-05-19 12:06:48 +0100890 ver := m.sdkVersion()
891 switch ver.kind {
892 case sdkCore:
893 return javaCore, false
894 case sdkSystem:
895 return javaSystem, false
896 case sdkPublic:
897 return javaSdk, false
898 case sdkModule:
899 return javaModule, false
900 case sdkSystemServer:
901 return javaSystemServer, false
902 case sdkPrivate, sdkNone, sdkCorePlatform, sdkTest:
903 return javaPlatform, false
904 }
905
906 if !ver.valid() {
907 panic(fmt.Errorf("sdk_version is invalid. got %q", ver.raw))
908 }
909 return javaSdk, false
Jiyong Park2d492942018-03-05 17:44:10 +0900910}
911
Jeongik Cha75b83b02019-11-01 15:28:00 +0900912func checkLinkType(ctx android.ModuleContext, from *Module, to linkTypeContext, tag dependencyTag) {
Colin Crossf19b9bb2018-03-26 14:42:44 -0700913 if ctx.Host() {
914 return
915 }
916
Jeongik Cha75b83b02019-11-01 15:28:00 +0900917 myLinkType, stubs := from.getLinkType(ctx.ModuleName())
Jiyong Park46f78fb2018-10-20 16:33:17 +0900918 if stubs {
919 return
920 }
Jeongik Cha75b83b02019-11-01 15:28:00 +0900921 otherLinkType, _ := to.getLinkType(ctx.OtherModuleName(to))
Jiyong Park2d492942018-03-05 17:44:10 +0900922 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."
923
924 switch myLinkType {
925 case javaCore:
926 if otherLinkType != javaCore {
927 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 +0900928 ctx.OtherModuleName(to))
929 }
Jiyong Park2d492942018-03-05 17:44:10 +0900930 break
931 case javaSdk:
932 if otherLinkType != javaCore && otherLinkType != javaSdk {
933 ctx.ModuleErrorf("compiles against Android API, but dependency %q is compiling against non-public Android API."+commonMessage,
934 ctx.OtherModuleName(to))
935 }
936 break
937 case javaSystem:
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900938 if otherLinkType == javaPlatform || otherLinkType == javaModule || otherLinkType == javaSystemServer {
Jiyong Park2d492942018-03-05 17:44:10 +0900939 ctx.ModuleErrorf("compiles against system API, but dependency %q is compiling against private API."+commonMessage,
940 ctx.OtherModuleName(to))
941 }
942 break
Jiyong Park50146e92020-01-30 18:00:15 +0900943 case javaModule:
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900944 if otherLinkType == javaPlatform || otherLinkType == javaSystemServer {
Jiyong Park50146e92020-01-30 18:00:15 +0900945 ctx.ModuleErrorf("compiles against module API, but dependency %q is compiling against private API."+commonMessage,
946 ctx.OtherModuleName(to))
947 }
948 break
Jiyong Parkaae9bd12020-02-12 04:36:43 +0900949 case javaSystemServer:
950 if otherLinkType == javaPlatform {
951 ctx.ModuleErrorf("compiles against system server API, but dependency %q is compiling against private API."+commonMessage,
952 ctx.OtherModuleName(to))
953 }
954 break
Jiyong Park2d492942018-03-05 17:44:10 +0900955 case javaPlatform:
956 // no restriction on link-type
957 break
Jiyong Park750e5572018-01-31 00:20:13 +0900958 }
959}
960
Colin Cross32f676a2017-09-06 13:41:06 -0700961func (j *Module) collectDeps(ctx android.ModuleContext) deps {
962 var deps deps
Colin Crossfc3674a2017-09-18 17:41:52 -0700963
Colin Cross300f0382018-03-06 13:11:51 -0800964 if ctx.Device() {
Colin Cross83bb3162018-06-25 15:48:06 -0700965 sdkDep := decodeSdkDep(ctx, sdkContext(j))
Colin Cross300f0382018-03-06 13:11:51 -0800966 if sdkDep.invalidVersion {
Colin Cross6cef4812019-10-17 14:23:50 -0700967 ctx.AddMissingDependencies(sdkDep.bootclasspath)
968 ctx.AddMissingDependencies(sdkDep.java9Classpath)
Colin Cross300f0382018-03-06 13:11:51 -0800969 } else if sdkDep.useFiles {
970 // sdkDep.jar is actually equivalent to turbine header.jar.
Colin Cross86a60ae2018-05-29 14:44:55 -0700971 deps.classpath = append(deps.classpath, sdkDep.jars...)
Colin Cross3047fa22019-04-18 10:56:44 -0700972 deps.aidlPreprocess = sdkDep.aidl
973 } else {
974 deps.aidlPreprocess = sdkDep.aidl
Colin Cross300f0382018-03-06 13:11:51 -0800975 }
Colin Crossfc3674a2017-09-18 17:41:52 -0700976 }
977
Paul Duffin64e61992020-05-15 10:20:31 +0100978 // If this is a component library (stubs, etc.) for a java_sdk_library then
979 // add the name of that java_sdk_library to the exported sdk libs to make sure
980 // that, if necessary, a <uses-library> element for that java_sdk_library is
981 // added to the Android manifest.
982 j.exportedSdkLibs = append(j.exportedSdkLibs, j.OptionalImplicitSdkLibrary()...)
983
Colin Crossd11fcda2017-10-23 17:59:01 -0700984 ctx.VisitDirectDeps(func(module android.Module) {
Colin Cross2fe66872015-03-30 17:20:39 -0700985 otherName := ctx.OtherModuleName(module)
Colin Crossec7a0422017-07-07 14:47:12 -0700986 tag := ctx.OtherModuleDependencyTag(module)
987
Colin Crossa4f08812018-10-02 22:03:40 -0700988 if _, ok := tag.(*jniDependencyTag); ok {
Colin Crossbd01e2a2018-10-04 15:21:03 -0700989 // Handled by AndroidApp.collectAppDeps
990 return
991 }
992 if tag == certificateTag {
993 // Handled by AndroidApp.collectAppDeps
Colin Crossa4f08812018-10-02 22:03:40 -0700994 return
995 }
Artur Satayeve5ac15a2020-04-08 19:09:30 +0100996
Colin Cross54250902017-12-05 09:28:08 -0800997 switch dep := module.(type) {
Colin Cross897d2ed2019-02-11 14:03:51 -0800998 case SdkLibraryDependency:
999 switch tag {
1000 case libTag:
1001 deps.classpath = append(deps.classpath, dep.SdkHeaderJars(ctx, j.sdkVersion())...)
1002 // names of sdk libs that are directly depended are exported
Paul Duffin64e61992020-05-15 10:20:31 +01001003 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.OptionalImplicitSdkLibrary()...)
Colin Cross79c7c262019-04-17 11:11:46 -07001004 case staticLibTag:
Colin Cross897d2ed2019-02-11 14:03:51 -08001005 ctx.ModuleErrorf("dependency on java_sdk_library %q can only be in libs", otherName)
1006 }
Colin Cross54250902017-12-05 09:28:08 -08001007 case Dependency:
1008 switch tag {
1009 case bootClasspathTag:
1010 deps.bootClasspath = append(deps.bootClasspath, dep.HeaderJars()...)
Colin Cross4b964c02018-10-15 16:18:06 -07001011 case libTag, instrumentationForTag:
Colin Cross54250902017-12-05 09:28:08 -08001012 deps.classpath = append(deps.classpath, dep.HeaderJars()...)
Jiyong Park1be96912018-05-28 18:02:19 +09001013 // sdk lib names from dependencies are re-exported
1014 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
Colin Cross3047fa22019-04-18 10:56:44 -07001015 deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
Artur Satayev9cf46692019-11-26 18:08:34 +00001016 pluginJars, pluginClasses := dep.ExportedPlugins()
1017 addPlugins(&deps, pluginJars, pluginClasses...)
Colin Cross6cef4812019-10-17 14:23:50 -07001018 case java9LibTag:
1019 deps.java9Classpath = append(deps.java9Classpath, dep.HeaderJars()...)
Colin Cross54250902017-12-05 09:28:08 -08001020 case staticLibTag:
1021 deps.classpath = append(deps.classpath, dep.HeaderJars()...)
1022 deps.staticJars = append(deps.staticJars, dep.ImplementationJars()...)
1023 deps.staticHeaderJars = append(deps.staticHeaderJars, dep.HeaderJars()...)
Colin Cross331a1212018-08-15 20:40:52 -07001024 deps.staticResourceJars = append(deps.staticResourceJars, dep.ResourceJars()...)
Jiyong Park1be96912018-05-28 18:02:19 +09001025 // sdk lib names from dependencies are re-exported
1026 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
Colin Cross3047fa22019-04-18 10:56:44 -07001027 deps.aidlIncludeDirs = append(deps.aidlIncludeDirs, dep.AidlIncludeDirs()...)
Artur Satayev9cf46692019-11-26 18:08:34 +00001028 pluginJars, pluginClasses := dep.ExportedPlugins()
1029 addPlugins(&deps, pluginJars, pluginClasses...)
Colin Crossbe9cdb82019-01-21 21:37:16 -08001030 case pluginTag:
1031 if plugin, ok := dep.(*Plugin); ok {
Colin Crossbe9cdb82019-01-21 21:37:16 -08001032 if plugin.pluginProperties.Processor_class != nil {
Artur Satayev9cf46692019-11-26 18:08:34 +00001033 addPlugins(&deps, plugin.ImplementationAndResourcesJars(), *plugin.pluginProperties.Processor_class)
1034 } else {
1035 addPlugins(&deps, plugin.ImplementationAndResourcesJars())
Colin Crossbe9cdb82019-01-21 21:37:16 -08001036 }
1037 deps.disableTurbine = deps.disableTurbine || Bool(plugin.pluginProperties.Generates_api)
1038 } else {
1039 ctx.PropertyErrorf("plugins", "%q is not a java_plugin module", otherName)
1040 }
Artur Satayev9cf46692019-11-26 18:08:34 +00001041 case exportedPluginTag:
1042 if plugin, ok := dep.(*Plugin); ok {
1043 if plugin.pluginProperties.Generates_api != nil && *plugin.pluginProperties.Generates_api {
1044 ctx.PropertyErrorf("exported_plugins", "Cannot export plugins with generates_api = true, found %v", otherName)
1045 }
1046 j.exportedPluginJars = append(j.exportedPluginJars, plugin.ImplementationAndResourcesJars()...)
1047 if plugin.pluginProperties.Processor_class != nil {
1048 j.exportedPluginClasses = append(j.exportedPluginClasses, *plugin.pluginProperties.Processor_class)
1049 }
1050 } else {
1051 ctx.PropertyErrorf("exported_plugins", "%q is not a java_plugin module", otherName)
1052 }
Nan Zhangb2b33de2018-02-23 11:18:47 -08001053 case frameworkApkTag:
1054 if ctx.ModuleName() == "android_stubs_current" ||
1055 ctx.ModuleName() == "android_system_stubs_current" ||
Nan Zhang863f05b2018-08-07 13:41:10 -07001056 ctx.ModuleName() == "android_test_stubs_current" {
Nan Zhangb2b33de2018-02-23 11:18:47 -08001057 // framework stubs.jar need to depend on framework-res.apk, in order to pull the
1058 // resource files out of there for aapt.
1059 //
1060 // Normally the package rule runs aapt, which includes the resource,
1061 // but we're not running that in our package rule so just copy in the
1062 // resource files here.
Colin Cross331a1212018-08-15 20:40:52 -07001063 deps.staticResourceJars = append(deps.staticResourceJars, dep.(*AndroidApp).exportPackage)
Nan Zhangb2b33de2018-02-23 11:18:47 -08001064 }
Colin Cross54250902017-12-05 09:28:08 -08001065 case kotlinStdlibTag:
Colin Cross0b03d972019-05-13 11:06:25 -07001066 deps.kotlinStdlib = append(deps.kotlinStdlib, dep.HeaderJars()...)
Colin Crossafbb1732019-01-17 15:42:52 -08001067 case kotlinAnnotationsTag:
1068 deps.kotlinAnnotations = dep.HeaderJars()
Colin Cross54250902017-12-05 09:28:08 -08001069 }
1070
Colin Cross54250902017-12-05 09:28:08 -08001071 case android.SourceFileProducer:
1072 switch tag {
1073 case libTag:
1074 checkProducesJars(ctx, dep)
1075 deps.classpath = append(deps.classpath, dep.Srcs()...)
1076 case staticLibTag:
1077 checkProducesJars(ctx, dep)
1078 deps.classpath = append(deps.classpath, dep.Srcs()...)
1079 deps.staticJars = append(deps.staticJars, dep.Srcs()...)
1080 deps.staticHeaderJars = append(deps.staticHeaderJars, dep.Srcs()...)
Colin Cross54250902017-12-05 09:28:08 -08001081 }
1082 default:
Colin Crossec7a0422017-07-07 14:47:12 -07001083 switch tag {
Paul Duffin68289b02019-09-20 13:50:52 +01001084 case bootClasspathTag:
1085 // If a system modules dependency has been added to the bootclasspath
1086 // then add its libs to the bootclasspath.
Paul Duffin83a2d962019-11-19 19:44:10 +00001087 sm := module.(SystemModulesProvider)
1088 deps.bootClasspath = append(deps.bootClasspath, sm.HeaderJars()...)
Paul Duffin68289b02019-09-20 13:50:52 +01001089
Colin Cross1369cdb2017-09-29 17:58:17 -07001090 case systemModulesTag:
1091 if deps.systemModules != nil {
1092 panic("Found two system module dependencies")
1093 }
Paul Duffin83a2d962019-11-19 19:44:10 +00001094 sm := module.(SystemModulesProvider)
1095 outputDir, outputDeps := sm.OutputDirAndDeps()
1096 deps.systemModules = &systemModules{outputDir, outputDeps}
Colin Cross2fe66872015-03-30 17:20:39 -07001097 }
Colin Crossec7a0422017-07-07 14:47:12 -07001098 }
Colin Cross2fe66872015-03-30 17:20:39 -07001099 })
1100
Jiyong Park1be96912018-05-28 18:02:19 +09001101 j.exportedSdkLibs = android.FirstUniqueStrings(j.exportedSdkLibs)
1102
Colin Cross32f676a2017-09-06 13:41:06 -07001103 return deps
Colin Cross2fe66872015-03-30 17:20:39 -07001104}
1105
Artur Satayev9cf46692019-11-26 18:08:34 +00001106func addPlugins(deps *deps, pluginJars android.Paths, pluginClasses ...string) {
1107 deps.processorPath = append(deps.processorPath, pluginJars...)
1108 deps.processorClasses = append(deps.processorClasses, pluginClasses...)
1109}
1110
Colin Cross1e743852019-10-28 11:37:20 -07001111func getJavaVersion(ctx android.ModuleContext, javaVersion string, sdkContext sdkContext) javaVersion {
Nan Zhang357466b2018-04-17 17:38:36 -07001112 if javaVersion != "" {
Colin Cross1e743852019-10-28 11:37:20 -07001113 return normalizeJavaVersion(ctx, javaVersion)
Colin Crossdb224752020-05-14 18:05:32 -07001114 } else if ctx.Device() {
1115 return sdkContext.sdkVersion().defaultJavaLanguageVersion(ctx)
Nan Zhang357466b2018-04-17 17:38:36 -07001116 } else {
Colin Cross1e743852019-10-28 11:37:20 -07001117 return JAVA_VERSION_9
Nan Zhang357466b2018-04-17 17:38:36 -07001118 }
Nan Zhang357466b2018-04-17 17:38:36 -07001119}
1120
Colin Cross1e743852019-10-28 11:37:20 -07001121type javaVersion int
1122
1123const (
1124 JAVA_VERSION_UNSUPPORTED = 0
1125 JAVA_VERSION_6 = 6
1126 JAVA_VERSION_7 = 7
1127 JAVA_VERSION_8 = 8
1128 JAVA_VERSION_9 = 9
1129)
1130
1131func (v javaVersion) String() string {
1132 switch v {
1133 case JAVA_VERSION_6:
1134 return "1.6"
1135 case JAVA_VERSION_7:
1136 return "1.7"
1137 case JAVA_VERSION_8:
1138 return "1.8"
1139 case JAVA_VERSION_9:
1140 return "1.9"
1141 default:
1142 return "unsupported"
1143 }
1144}
1145
1146// Returns true if javac targeting this version uses system modules instead of a bootclasspath.
1147func (v javaVersion) usesJavaModules() bool {
1148 return v >= 9
1149}
1150
1151func normalizeJavaVersion(ctx android.BaseModuleContext, javaVersion string) javaVersion {
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001152 switch javaVersion {
1153 case "1.6", "6":
Colin Cross1e743852019-10-28 11:37:20 -07001154 return JAVA_VERSION_6
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001155 case "1.7", "7":
Colin Cross1e743852019-10-28 11:37:20 -07001156 return JAVA_VERSION_7
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001157 case "1.8", "8":
Colin Cross1e743852019-10-28 11:37:20 -07001158 return JAVA_VERSION_8
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001159 case "1.9", "9":
Colin Cross1e743852019-10-28 11:37:20 -07001160 return JAVA_VERSION_9
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001161 case "10", "11":
1162 ctx.PropertyErrorf("java_version", "Java language levels above 9 are not supported")
Colin Cross1e743852019-10-28 11:37:20 -07001163 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001164 default:
1165 ctx.PropertyErrorf("java_version", "Unrecognized Java language level")
Colin Cross1e743852019-10-28 11:37:20 -07001166 return JAVA_VERSION_UNSUPPORTED
Pete Gillin4e8b48a2019-07-12 13:16:17 +01001167 }
1168}
1169
Nan Zhanged19fc32017-10-19 13:06:22 -07001170func (j *Module) collectBuilderFlags(ctx android.ModuleContext, deps deps) javaBuilderFlags {
Colin Crossc0b06f12015-04-08 13:03:43 -07001171
Colin Crossf03c82b2015-04-13 13:53:40 -07001172 var flags javaBuilderFlags
1173
Tobias Thierer06dd04f2018-09-11 16:21:05 +01001174 // javaVersion flag.
1175 flags.javaVersion = getJavaVersion(ctx, String(j.properties.Java_version), sdkContext(j))
1176
Nan Zhanged19fc32017-10-19 13:06:22 -07001177 // javac flags.
Colin Crossf03c82b2015-04-13 13:53:40 -07001178 javacFlags := j.properties.Javacflags
Colin Cross1e743852019-10-28 11:37:20 -07001179 if flags.javaVersion.usesJavaModules() {
Colin Cross1369cdb2017-09-29 17:58:17 -07001180 javacFlags = append(javacFlags, j.properties.Openjdk9.Javacflags...)
Nan Zhanged19fc32017-10-19 13:06:22 -07001181 }
Colin Cross6510f912017-11-29 00:27:14 -08001182 if ctx.Config().MinimizeJavaDebugInfo() {
Colin Cross126a25c2017-10-31 13:55:34 -07001183 // Override the -g flag passed globally to remove local variable debug info to reduce
1184 // disk and memory usage.
1185 javacFlags = append(javacFlags, "-g:source,lines")
1186 }
Colin Crossc228a702019-11-06 16:18:05 -08001187 javacFlags = append(javacFlags, "-Xlint:-dep-ann")
Colin Cross64162712017-08-08 13:17:59 -07001188
Colin Cross66548102018-06-19 22:47:35 -07001189 if ctx.Config().RunErrorProne() {
1190 if config.ErrorProneClasspath == nil {
1191 ctx.ModuleErrorf("cannot build with Error Prone, missing external/error_prone?")
1192 }
1193
1194 errorProneFlags := []string{
1195 "-Xplugin:ErrorProne",
1196 "${config.ErrorProneChecks}",
1197 }
1198 errorProneFlags = append(errorProneFlags, j.properties.Errorprone.Javacflags...)
1199
1200 flags.errorProneExtraJavacFlags = "${config.ErrorProneFlags} " +
1201 "'" + strings.Join(errorProneFlags, " ") + "'"
1202 flags.errorProneProcessorPath = classpath(android.PathsForSource(ctx, config.ErrorProneClasspath))
Andreas Gampef3e5b552018-01-22 21:27:21 -08001203 }
1204
Nan Zhanged19fc32017-10-19 13:06:22 -07001205 // classpath
Nan Zhang581fd212018-01-10 16:06:12 -08001206 flags.bootClasspath = append(flags.bootClasspath, deps.bootClasspath...)
1207 flags.classpath = append(flags.classpath, deps.classpath...)
Colin Cross6cef4812019-10-17 14:23:50 -07001208 flags.java9Classpath = append(flags.java9Classpath, deps.java9Classpath...)
Colin Cross6a77c982018-06-19 22:43:34 -07001209 flags.processorPath = append(flags.processorPath, deps.processorPath...)
Colin Cross7fdd2b72018-01-02 18:14:25 -08001210
Colin Crossd99540b2020-04-22 11:44:34 -07001211 flags.processors = append(flags.processors, deps.processorClasses...)
1212 flags.processors = android.FirstUniqueStrings(flags.processors)
Colin Crossbe9cdb82019-01-21 21:37:16 -08001213
Colin Cross1e743852019-10-28 11:37:20 -07001214 if len(flags.bootClasspath) == 0 && ctx.Host() && !flags.javaVersion.usesJavaModules() &&
1215 decodeSdkDep(ctx, sdkContext(j)).hasStandardLibs() {
Colin Cross7fdd2b72018-01-02 18:14:25 -08001216 // Give host-side tools a version of OpenJDK's standard libraries
1217 // close to what they're targeting. As of Dec 2017, AOSP is only
1218 // bundling OpenJDK 8 and 9, so nothing < 8 is available.
1219 //
1220 // When building with OpenJDK 8, the following should have no
1221 // effect since those jars would be available by default.
1222 //
1223 // When building with OpenJDK 9 but targeting a version < 1.8,
1224 // putting them on the bootclasspath means that:
1225 // a) code can't (accidentally) refer to OpenJDK 9 specific APIs
1226 // b) references to existing APIs are not reinterpreted in an
1227 // OpenJDK 9-specific way, eg. calls to subclasses of
1228 // java.nio.Buffer as in http://b/70862583
1229 java8Home := ctx.Config().Getenv("ANDROID_JAVA8_HOME")
1230 flags.bootClasspath = append(flags.bootClasspath,
1231 android.PathForSource(ctx, java8Home, "jre/lib/jce.jar"),
1232 android.PathForSource(ctx, java8Home, "jre/lib/rt.jar"))
Nan Zhang5f8cb422018-02-06 10:34:32 -08001233 if Bool(j.properties.Use_tools_jar) {
1234 flags.bootClasspath = append(flags.bootClasspath,
1235 android.PathForSource(ctx, java8Home, "lib/tools.jar"))
1236 }
Colin Cross7fdd2b72018-01-02 18:14:25 -08001237 }
1238
Colin Cross1e743852019-10-28 11:37:20 -07001239 if j.properties.Patch_module != nil && flags.javaVersion.usesJavaModules() {
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001240 // Manually specify build directory in case it is not under the repo root.
1241 // (javac doesn't seem to expand into symbolc links when searching for patch-module targets, so
1242 // just adding a symlink under the root doesn't help.)
1243 patchPaths := ".:" + ctx.Config().BuildDir()
1244 classPath := flags.classpath.FormJavaClassPath("")
1245 if classPath != "" {
1246 patchPaths += ":" + classPath
1247 }
1248 javacFlags = append(javacFlags, "--patch-module="+String(j.properties.Patch_module)+"="+patchPaths)
Colin Cross81440082018-08-15 20:21:55 -07001249 }
1250
Nan Zhanged19fc32017-10-19 13:06:22 -07001251 // systemModules
Colin Crossb77043e2019-07-16 13:57:13 -07001252 flags.systemModules = deps.systemModules
Colin Cross1369cdb2017-09-29 17:58:17 -07001253
Nan Zhanged19fc32017-10-19 13:06:22 -07001254 // aidl flags.
Colin Cross3047fa22019-04-18 10:56:44 -07001255 flags.aidlFlags, flags.aidlDeps = j.aidlFlags(ctx, deps.aidlPreprocess, deps.aidlIncludeDirs)
Colin Cross2fe66872015-03-30 17:20:39 -07001256
Colin Cross81440082018-08-15 20:21:55 -07001257 if len(javacFlags) > 0 {
1258 // optimization.
1259 ctx.Variable(pctx, "javacFlags", strings.Join(javacFlags, " "))
1260 flags.javacFlags = "$javacFlags"
1261 }
1262
Nan Zhanged19fc32017-10-19 13:06:22 -07001263 return flags
1264}
Colin Crossc0b06f12015-04-08 13:03:43 -07001265
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001266func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) {
Colin Crossebe1a512017-11-14 13:12:14 -08001267 j.exportAidlIncludeDirs = android.PathsForModuleSrc(ctx, j.deviceProperties.Aidl.Export_include_dirs)
Nan Zhanged19fc32017-10-19 13:06:22 -07001268
1269 deps := j.collectDeps(ctx)
1270 flags := j.collectBuilderFlags(ctx, deps)
1271
Colin Cross1e743852019-10-28 11:37:20 -07001272 if flags.javaVersion.usesJavaModules() {
Nan Zhanged19fc32017-10-19 13:06:22 -07001273 j.properties.Srcs = append(j.properties.Srcs, j.properties.Openjdk9.Srcs...)
1274 }
Colin Cross8a497952019-03-05 22:25:09 -08001275 srcFiles := android.PathsForModuleSrcExcludes(ctx, j.properties.Srcs, j.properties.Exclude_srcs)
Colin Cross6af17aa2017-09-20 12:59:05 -07001276 if hasSrcExt(srcFiles.Strings(), ".proto") {
Colin Cross0f2ee152017-12-14 15:22:43 -08001277 flags = protoFlags(ctx, &j.properties, &j.protoProperties, flags)
Colin Cross6af17aa2017-09-20 12:59:05 -07001278 }
1279
Colin Crossaf050172017-11-15 23:01:59 -08001280 srcFiles = j.genSources(ctx, srcFiles, flags)
1281
1282 srcJars := srcFiles.FilterByExt(".srcjar")
Colin Cross59149b62017-10-16 18:07:29 -07001283 srcJars = append(srcJars, deps.srcJars...)
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001284 if aaptSrcJar != nil {
1285 srcJars = append(srcJars, aaptSrcJar)
1286 }
Colin Crossb7a63242015-04-16 14:09:14 -07001287
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001288 if j.properties.Jarjar_rules != nil {
Colin Cross8a497952019-03-05 22:25:09 -08001289 j.expandJarjarRules = android.PathForModuleSrc(ctx, *j.properties.Jarjar_rules)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001290 }
1291
Colin Cross1ee23172017-10-18 14:44:18 -07001292 jarName := ctx.ModuleName() + ".jar"
1293
Przemyslaw Szczepaniak4b5fe9d2018-02-13 14:32:54 +00001294 javaSrcFiles := srcFiles.FilterByExt(".java")
1295 var uniqueSrcFiles android.Paths
1296 set := make(map[string]bool)
1297 for _, v := range javaSrcFiles {
1298 if _, found := set[v.String()]; !found {
1299 set[v.String()] = true
1300 uniqueSrcFiles = append(uniqueSrcFiles, v)
1301 }
1302 }
1303
patricktu242faad2019-09-24 15:41:30 +08001304 // Collect .java files for AIDEGen
1305 j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, uniqueSrcFiles.Strings()...)
1306
Colin Cross55f63ea2018-08-27 12:37:09 -07001307 var kotlinJars android.Paths
1308
Colin Cross93e85952017-08-15 13:34:18 -07001309 if srcFiles.HasExt(".kt") {
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001310 // user defined kotlin flags.
1311 kotlincFlags := j.properties.Kotlincflags
1312 CheckKotlincFlags(ctx, kotlincFlags)
1313
Colin Cross93e85952017-08-15 13:34:18 -07001314 // If there are kotlin files, compile them first but pass all the kotlin and java files
1315 // kotlinc will use the java files to resolve types referenced by the kotlin files, but
1316 // won't emit any classes for them.
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001317 kotlincFlags = append(kotlincFlags, "-no-stdlib")
Colin Cross93e85952017-08-15 13:34:18 -07001318 if ctx.Device() {
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001319 kotlincFlags = append(kotlincFlags, "-no-jdk")
1320 }
1321 if len(kotlincFlags) > 0 {
1322 // optimization.
1323 ctx.Variable(pctx, "kotlincFlags", strings.Join(kotlincFlags, " "))
1324 flags.kotlincFlags += "$kotlincFlags"
Colin Cross93e85952017-08-15 13:34:18 -07001325 }
1326
Przemyslaw Szczepaniak4b5fe9d2018-02-13 14:32:54 +00001327 var kotlinSrcFiles android.Paths
1328 kotlinSrcFiles = append(kotlinSrcFiles, uniqueSrcFiles...)
1329 kotlinSrcFiles = append(kotlinSrcFiles, srcFiles.FilterByExt(".kt")...)
1330
patricktu242faad2019-09-24 15:41:30 +08001331 // Collect .kt files for AIDEGen
1332 j.expandIDEInfoCompiledSrcs = append(j.expandIDEInfoCompiledSrcs, srcFiles.FilterByExt(".kt").Strings()...)
1333
Colin Crossafbb1732019-01-17 15:42:52 -08001334 flags.classpath = append(flags.classpath, deps.kotlinStdlib...)
1335 flags.classpath = append(flags.classpath, deps.kotlinAnnotations...)
1336
1337 flags.kotlincClasspath = append(flags.kotlincClasspath, flags.bootClasspath...)
1338 flags.kotlincClasspath = append(flags.kotlincClasspath, flags.classpath...)
1339
1340 if len(flags.processorPath) > 0 {
1341 // Use kapt for annotation processing
1342 kaptSrcJar := android.PathForModuleOut(ctx, "kapt", "kapt-sources.jar")
Colin Cross3791b452020-06-18 15:46:32 -07001343 kaptResJar := android.PathForModuleOut(ctx, "kapt", "kapt-res.jar")
1344 kotlinKapt(ctx, kaptSrcJar, kaptResJar, kotlinSrcFiles, srcJars, flags)
Colin Crossafbb1732019-01-17 15:42:52 -08001345 srcJars = append(srcJars, kaptSrcJar)
Colin Cross3791b452020-06-18 15:46:32 -07001346 kotlinJars = append(kotlinJars, kaptResJar)
Colin Crossafbb1732019-01-17 15:42:52 -08001347 // Disable annotation processing in javac, it's already been handled by kapt
1348 flags.processorPath = nil
Colin Crossd99540b2020-04-22 11:44:34 -07001349 flags.processors = nil
Colin Crossafbb1732019-01-17 15:42:52 -08001350 }
Colin Cross93e85952017-08-15 13:34:18 -07001351
Colin Cross1ee23172017-10-18 14:44:18 -07001352 kotlinJar := android.PathForModuleOut(ctx, "kotlin", jarName)
Colin Cross21fc9bb2019-01-18 15:05:09 -08001353 kotlinCompile(ctx, kotlinJar, kotlinSrcFiles, srcJars, flags)
Colin Cross93e85952017-08-15 13:34:18 -07001354 if ctx.Failed() {
1355 return
1356 }
1357
1358 // Make javac rule depend on the kotlinc rule
1359 flags.classpath = append(flags.classpath, kotlinJar)
Przemyslaw Szczepaniak66c0c402018-03-08 13:21:55 +00001360
Colin Cross55f63ea2018-08-27 12:37:09 -07001361 kotlinJars = append(kotlinJars, kotlinJar)
Colin Crossaaf58062020-06-18 15:52:01 -07001362 // Jar kotlin classes into the final jar after javac
1363 if BoolDefault(j.properties.Static_kotlin_stdlib, true) {
1364 kotlinJars = append(kotlinJars, deps.kotlinStdlib...)
1365 }
Colin Cross93e85952017-08-15 13:34:18 -07001366 }
1367
Colin Cross55f63ea2018-08-27 12:37:09 -07001368 jars := append(android.Paths(nil), kotlinJars...)
1369
Colin Cross5ab4e6d2017-11-22 16:20:45 -08001370 // Store the list of .java files that was passed to javac
1371 j.compiledJavaSrcs = uniqueSrcFiles
1372 j.compiledSrcJars = srcJars
1373
Nan Zhang61eaedb2017-11-02 13:28:15 -07001374 enable_sharding := false
Colin Crossf5a66282020-02-21 08:16:41 -08001375 var headerJarFileWithoutJarjar android.Path
Colin Crossbe9cdb82019-01-21 21:37:16 -08001376 if ctx.Device() && !ctx.Config().IsEnvFalse("TURBINE_ENABLED") && !deps.disableTurbine {
Nan Zhang61eaedb2017-11-02 13:28:15 -07001377 if j.properties.Javac_shard_size != nil && *(j.properties.Javac_shard_size) > 0 {
1378 enable_sharding = true
Ashley Rosee36efcf2019-01-16 17:34:08 -05001379 // Formerly, there was a check here that prevented annotation processors
1380 // from being used when sharding was enabled, as some annotation processors
1381 // do not function correctly in sharded environments. It was removed to
1382 // allow for the use of annotation processors that do function correctly
1383 // with sharding enabled. See: b/77284273.
Nan Zhang61eaedb2017-11-02 13:28:15 -07001384 }
Colin Crossf5a66282020-02-21 08:16:41 -08001385 headerJarFileWithoutJarjar, j.headerJarFile =
1386 j.compileJavaHeader(ctx, uniqueSrcFiles, srcJars, deps, flags, jarName, kotlinJars)
Colin Crossf19b9bb2018-03-26 14:42:44 -07001387 if ctx.Failed() {
1388 return
Nan Zhanged19fc32017-10-19 13:06:22 -07001389 }
1390 }
Colin Cross8eadbf02017-10-24 17:46:00 -07001391 if len(uniqueSrcFiles) > 0 || len(srcJars) > 0 {
Colin Crossd6891432017-09-27 17:39:56 -07001392 var extraJarDeps android.Paths
Colin Cross66548102018-06-19 22:47:35 -07001393 if ctx.Config().RunErrorProne() {
Colin Crossc6bbef32017-08-14 14:16:06 -07001394 // If error-prone is enabled, add an additional rule to compile the java files into
1395 // a separate set of classes (so that they don't overwrite the normal ones and require
Colin Crossd6891432017-09-27 17:39:56 -07001396 // a rebuild when error-prone is turned off).
Colin Crossc6bbef32017-08-14 14:16:06 -07001397 // TODO(ccross): Once we always compile with javac9 we may be able to conditionally
1398 // enable error-prone without affecting the output class files.
Colin Cross1ee23172017-10-18 14:44:18 -07001399 errorprone := android.PathForModuleOut(ctx, "errorprone", jarName)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001400 RunErrorProne(ctx, errorprone, uniqueSrcFiles, srcJars, flags)
Colin Crossc6bbef32017-08-14 14:16:06 -07001401 extraJarDeps = append(extraJarDeps, errorprone)
1402 }
1403
Nan Zhang61eaedb2017-11-02 13:28:15 -07001404 if enable_sharding {
Colin Crossf5a66282020-02-21 08:16:41 -08001405 flags.classpath = append(flags.classpath, headerJarFileWithoutJarjar)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001406 shardSize := int(*(j.properties.Javac_shard_size))
1407 var shardSrcs []android.Paths
1408 if len(uniqueSrcFiles) > 0 {
Colin Cross0a2f7192019-09-23 14:33:09 -07001409 shardSrcs = android.ShardPaths(uniqueSrcFiles, shardSize)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001410 for idx, shardSrc := range shardSrcs {
Colin Cross3b706fd2019-09-05 16:44:18 -07001411 classes := j.compileJavaClasses(ctx, jarName, idx, shardSrc,
1412 nil, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001413 jars = append(jars, classes)
1414 }
1415 }
1416 if len(srcJars) > 0 {
Colin Cross3b706fd2019-09-05 16:44:18 -07001417 classes := j.compileJavaClasses(ctx, jarName, len(shardSrcs),
1418 nil, srcJars, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001419 jars = append(jars, classes)
1420 }
1421 } else {
Colin Cross3b706fd2019-09-05 16:44:18 -07001422 classes := j.compileJavaClasses(ctx, jarName, -1, uniqueSrcFiles, srcJars, flags, extraJarDeps)
Nan Zhang61eaedb2017-11-02 13:28:15 -07001423 jars = append(jars, classes)
1424 }
Colin Crossd6891432017-09-27 17:39:56 -07001425 if ctx.Failed() {
1426 return
1427 }
Colin Cross2fe66872015-03-30 17:20:39 -07001428 }
1429
Colin Cross0c4ce212019-05-03 15:28:19 -07001430 j.srcJarArgs, j.srcJarDeps = resourcePathsToJarArgs(srcFiles), srcFiles
1431
1432 var includeSrcJar android.WritablePath
1433 if Bool(j.properties.Include_srcs) {
1434 includeSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+".srcjar")
1435 TransformResourcesToJar(ctx, includeSrcJar, j.srcJarArgs, j.srcJarDeps)
1436 }
1437
Colin Crosscedd4762018-09-13 11:26:19 -07001438 dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs,
1439 j.properties.Exclude_java_resource_dirs, j.properties.Exclude_java_resources)
Colin Cross0f37af02017-09-27 17:42:05 -07001440 fileArgs, fileDeps := ResourceFilesToJarArgs(ctx, j.properties.Java_resources, j.properties.Exclude_java_resources)
Colin Cross988708c2019-05-06 14:04:11 -07001441 extraArgs, extraDeps := resourcePathsToJarArgs(j.extraResources), j.extraResources
Colin Cross0f37af02017-09-27 17:42:05 -07001442
1443 var resArgs []string
1444 var resDeps android.Paths
1445
1446 resArgs = append(resArgs, dirArgs...)
1447 resDeps = append(resDeps, dirDeps...)
1448
1449 resArgs = append(resArgs, fileArgs...)
1450 resDeps = append(resDeps, fileDeps...)
1451
Colin Cross988708c2019-05-06 14:04:11 -07001452 resArgs = append(resArgs, extraArgs...)
1453 resDeps = append(resDeps, extraDeps...)
1454
Colin Cross40a36712017-09-27 17:41:35 -07001455 if len(resArgs) > 0 {
Colin Cross1ee23172017-10-18 14:44:18 -07001456 resourceJar := android.PathForModuleOut(ctx, "res", jarName)
Colin Crosse9a275b2017-10-16 17:09:48 -07001457 TransformResourcesToJar(ctx, resourceJar, resArgs, resDeps)
Colin Cross331a1212018-08-15 20:40:52 -07001458 j.resourceJar = resourceJar
Colin Cross65bf4f22015-04-03 16:54:17 -07001459 if ctx.Failed() {
1460 return
1461 }
1462 }
1463
Colin Cross0c4ce212019-05-03 15:28:19 -07001464 var resourceJars android.Paths
1465 if j.resourceJar != nil {
1466 resourceJars = append(resourceJars, j.resourceJar)
1467 }
1468 if Bool(j.properties.Include_srcs) {
1469 resourceJars = append(resourceJars, includeSrcJar)
1470 }
1471 resourceJars = append(resourceJars, deps.staticResourceJars...)
Colin Cross331a1212018-08-15 20:40:52 -07001472
Colin Cross0c4ce212019-05-03 15:28:19 -07001473 if len(resourceJars) > 1 {
Colin Cross331a1212018-08-15 20:40:52 -07001474 combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName)
Colin Cross0c4ce212019-05-03 15:28:19 -07001475 TransformJarsToJar(ctx, combinedJar, "for resources", resourceJars, android.OptionalPath{},
Colin Cross331a1212018-08-15 20:40:52 -07001476 false, nil, nil)
1477 j.resourceJar = combinedJar
Colin Cross0c4ce212019-05-03 15:28:19 -07001478 } else if len(resourceJars) == 1 {
1479 j.resourceJar = resourceJars[0]
Colin Cross331a1212018-08-15 20:40:52 -07001480 }
1481
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001482 if len(deps.staticJars) > 0 {
1483 jars = append(jars, deps.staticJars...)
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001484 }
Colin Cross0a6e0072017-08-30 14:24:55 -07001485
Colin Cross094054a2018-10-17 15:10:48 -07001486 manifest := j.overrideManifest
1487 if !manifest.Valid() && j.properties.Manifest != nil {
Colin Cross8a497952019-03-05 22:25:09 -08001488 manifest = android.OptionalPathForPath(android.PathForModuleSrc(ctx, *j.properties.Manifest))
Colin Cross366938f2017-12-11 16:29:02 -08001489 }
Colin Cross635acc92017-09-12 22:50:46 -07001490
Colin Cross8a497952019-03-05 22:25:09 -08001491 services := android.PathsForModuleSrc(ctx, j.properties.Services)
Alex Light7f004a72019-02-21 13:27:37 -08001492 if len(services) > 0 {
1493 servicesJar := android.PathForModuleOut(ctx, "services", jarName)
1494 var zipargs []string
1495 for _, file := range services {
1496 serviceFile := file.String()
1497 zipargs = append(zipargs, "-C", filepath.Dir(serviceFile), "-f", serviceFile)
1498 }
Kousik Kumarc05da0a2020-05-20 11:27:16 -07001499 rule := zip
1500 args := map[string]string{
1501 "jarArgs": "-P META-INF/services/ " + strings.Join(proptools.NinjaAndShellEscapeList(zipargs), " "),
1502 }
1503 if ctx.Config().IsEnvTrue("RBE_ZIP") {
1504 rule = zipRE
1505 args["implicits"] = strings.Join(services.Strings(), ",")
1506 }
Alex Light7f004a72019-02-21 13:27:37 -08001507 ctx.Build(pctx, android.BuildParams{
Kousik Kumarc05da0a2020-05-20 11:27:16 -07001508 Rule: rule,
Alex Light7f004a72019-02-21 13:27:37 -08001509 Output: servicesJar,
1510 Implicits: services,
Kousik Kumarc05da0a2020-05-20 11:27:16 -07001511 Args: args,
Alex Light7f004a72019-02-21 13:27:37 -08001512 })
1513 jars = append(jars, servicesJar)
1514 }
1515
Colin Cross0a6e0072017-08-30 14:24:55 -07001516 // Combine the classes built from sources, any manifests, and any static libraries into
Nan Zhanged19fc32017-10-19 13:06:22 -07001517 // classes.jar. If there is only one input jar this step will be skipped.
Colin Cross3063b782018-08-15 11:19:12 -07001518 var outputFile android.ModuleOutPath
Colin Crosse9a275b2017-10-16 17:09:48 -07001519
1520 if len(jars) == 1 && !manifest.Valid() {
Colin Cross3063b782018-08-15 11:19:12 -07001521 if moduleOutPath, ok := jars[0].(android.ModuleOutPath); ok {
1522 // Optimization: skip the combine step if there is nothing to do
1523 // TODO(ccross): this leaves any module-info.class files, but those should only come from
1524 // prebuilt dependencies until we support modules in the platform build, so there shouldn't be
1525 // any if len(jars) == 1.
1526 outputFile = moduleOutPath
1527 } else {
1528 combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
1529 ctx.Build(pctx, android.BuildParams{
1530 Rule: android.Cp,
1531 Input: jars[0],
1532 Output: combinedJar,
1533 })
1534 outputFile = combinedJar
1535 }
Colin Crosse9a275b2017-10-16 17:09:48 -07001536 } else {
Colin Cross1ee23172017-10-18 14:44:18 -07001537 combinedJar := android.PathForModuleOut(ctx, "combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07001538 TransformJarsToJar(ctx, combinedJar, "for javac", jars, manifest,
Colin Cross9b38aef2018-08-27 15:42:25 -07001539 false, nil, nil)
Colin Crosse9a275b2017-10-16 17:09:48 -07001540 outputFile = combinedJar
1541 }
Colin Cross0a6e0072017-08-30 14:24:55 -07001542
Colin Cross331a1212018-08-15 20:40:52 -07001543 // jarjar implementation jar if necessary
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001544 if j.expandJarjarRules != nil {
Colin Cross8649b262017-09-27 18:03:17 -07001545 // Transform classes.jar into classes-jarjar.jar
Colin Cross1ee23172017-10-18 14:44:18 -07001546 jarjarFile := android.PathForModuleOut(ctx, "jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001547 TransformJarJar(ctx, jarjarFile, outputFile, j.expandJarjarRules)
Colin Crosse9a275b2017-10-16 17:09:48 -07001548 outputFile = jarjarFile
Colin Cross331a1212018-08-15 20:40:52 -07001549
1550 // jarjar resource jar if necessary
1551 if j.resourceJar != nil {
1552 resourceJarJarFile := android.PathForModuleOut(ctx, "res-jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001553 TransformJarJar(ctx, resourceJarJarFile, j.resourceJar, j.expandJarjarRules)
Colin Cross331a1212018-08-15 20:40:52 -07001554 j.resourceJar = resourceJarJarFile
1555 }
1556
Colin Cross0a6e0072017-08-30 14:24:55 -07001557 if ctx.Failed() {
1558 return
1559 }
1560 }
Vladimir Marko0975ee02019-04-02 10:29:55 +01001561
1562 // Check package restrictions if necessary.
1563 if len(j.properties.Permitted_packages) > 0 {
Tej Singh83839722020-06-03 18:45:54 +00001564 // Check packages and copy to package-checked file.
1565 pkgckFile := android.PathForModuleOut(ctx, "package-check.stamp")
1566 CheckJarPackages(ctx, pkgckFile, outputFile, j.properties.Permitted_packages)
1567 j.additionalCheckedModules = append(j.additionalCheckedModules, pkgckFile)
Vladimir Marko0975ee02019-04-02 10:29:55 +01001568
1569 if ctx.Failed() {
1570 return
1571 }
1572 }
1573
Nan Zhanged19fc32017-10-19 13:06:22 -07001574 j.implementationJarFile = outputFile
1575 if j.headerJarFile == nil {
1576 j.headerJarFile = j.implementationJarFile
1577 }
Colin Cross2fe66872015-03-30 17:20:39 -07001578
Jiyong Park28826602020-02-21 16:04:53 +09001579 // Force enable the instrumentation for java code that is built for APEXes ...
1580 // except for the jacocoagent itself (because instrumenting jacocoagent using jacocoagent
1581 // doesn't make sense)
1582 isJacocoAgent := ctx.ModuleName() == "jacocoagent"
1583 if android.DirectlyInAnyApex(ctx, ctx.ModuleName()) && !isJacocoAgent && !j.IsForPlatform() {
Jiyong Park81aaa0c2020-02-18 12:50:44 +00001584 j.properties.Instrument = true
1585 }
1586
Colin Cross3144dfc2018-01-03 15:06:47 -08001587 if j.shouldInstrument(ctx) {
Colin Crosscb933592017-11-22 13:49:43 -08001588 outputFile = j.instrument(ctx, flags, outputFile, jarName)
1589 }
1590
Colin Cross331a1212018-08-15 20:40:52 -07001591 // merge implementation jar with resources if necessary
1592 implementationAndResourcesJar := outputFile
1593 if j.resourceJar != nil {
Colin Cross08a409d2019-04-29 10:22:44 -07001594 jars := android.Paths{j.resourceJar, implementationAndResourcesJar}
Colin Cross331a1212018-08-15 20:40:52 -07001595 combinedJar := android.PathForModuleOut(ctx, "withres", jarName)
Colin Cross08a409d2019-04-29 10:22:44 -07001596 TransformJarsToJar(ctx, combinedJar, "for resources", jars, manifest,
Colin Cross331a1212018-08-15 20:40:52 -07001597 false, nil, nil)
1598 implementationAndResourcesJar = combinedJar
1599 }
1600
1601 j.implementationAndResourcesJar = implementationAndResourcesJar
1602
Jiyong Park6b21c7d2020-02-11 09:16:01 +09001603 // Enable dex compilation for the APEX variants, unless it is disabled explicitly
1604 if android.DirectlyInAnyApex(ctx, ctx.ModuleName()) && !j.IsForPlatform() {
1605 if j.deviceProperties.Compile_dex == nil {
1606 j.deviceProperties.Compile_dex = proptools.BoolPtr(true)
1607 }
1608 if j.deviceProperties.Hostdex == nil {
1609 j.deviceProperties.Hostdex = proptools.BoolPtr(true)
1610 }
1611 }
1612
Jaewoong Jungc27ab662019-05-30 15:51:14 -07001613 if ctx.Device() && j.hasCode(ctx) &&
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001614 (Bool(j.properties.Installable) || Bool(j.deviceProperties.Compile_dex)) {
Colin Cross8faf8fc2019-01-16 15:15:52 -08001615 // Dex compilation
Colin Cross3063b782018-08-15 11:19:12 -07001616 var dexOutputFile android.ModuleOutPath
David Brazdil17ef5632018-06-27 10:27:45 +01001617 dexOutputFile = j.compileDex(ctx, flags, outputFile, jarName)
Colin Cross2fe66872015-03-30 17:20:39 -07001618 if ctx.Failed() {
1619 return
1620 }
Colin Cross331a1212018-08-15 20:40:52 -07001621
Jiyong Park09cb6292019-07-15 15:29:23 +09001622 // Hidden API CSV generation and dex encoding
1623 dexOutputFile = j.hiddenAPI.hiddenAPI(ctx, dexOutputFile, j.implementationJarFile,
David Srbecky98c71222020-05-20 22:20:28 +01001624 proptools.Bool(j.deviceProperties.Uncompress_dex))
Colin Cross8faf8fc2019-01-16 15:15:52 -08001625
Colin Cross331a1212018-08-15 20:40:52 -07001626 // merge dex jar with resources if necessary
1627 if j.resourceJar != nil {
1628 jars := android.Paths{dexOutputFile, j.resourceJar}
1629 combinedJar := android.PathForModuleOut(ctx, "dex-withres", jarName)
1630 TransformJarsToJar(ctx, combinedJar, "for dex resources", jars, android.OptionalPath{},
1631 false, nil, nil)
David Srbecky98c71222020-05-20 22:20:28 +01001632 if *j.deviceProperties.Uncompress_dex {
Nicolas Geoffrayf3438722019-01-23 15:57:21 +00001633 combinedAlignedJar := android.PathForModuleOut(ctx, "dex-withres-aligned", jarName)
1634 TransformZipAlign(ctx, combinedAlignedJar, combinedJar)
1635 dexOutputFile = combinedAlignedJar
1636 } else {
1637 dexOutputFile = combinedJar
1638 }
Colin Cross331a1212018-08-15 20:40:52 -07001639 }
1640
1641 j.dexJarFile = dexOutputFile
1642
Colin Cross8faf8fc2019-01-16 15:15:52 -08001643 // Dexpreopting
Colin Cross43f08db2018-11-12 10:13:39 -08001644 dexOutputFile = j.dexpreopt(ctx, dexOutputFile)
1645
1646 j.maybeStrippedDexJarFile = dexOutputFile
1647
Colin Cross3063b782018-08-15 11:19:12 -07001648 outputFile = dexOutputFile
Colin Cross43f08db2018-11-12 10:13:39 -08001649
1650 if ctx.Failed() {
1651 return
1652 }
Colin Cross331a1212018-08-15 20:40:52 -07001653 } else {
1654 outputFile = implementationAndResourcesJar
Colin Cross2fe66872015-03-30 17:20:39 -07001655 }
Colin Cross331a1212018-08-15 20:40:52 -07001656
Colin Cross1e28e3c2020-06-02 20:09:13 -07001657 if ctx.Device() {
1658 lintSDKVersionString := func(sdkSpec sdkSpec) string {
1659 if v := sdkSpec.version; v.isNumbered() {
1660 return v.String()
1661 } else {
1662 return ctx.Config().DefaultAppTargetSdk()
1663 }
1664 }
1665
1666 j.linter.name = ctx.ModuleName()
1667 j.linter.srcs = srcFiles
1668 j.linter.srcJars = srcJars
1669 j.linter.classpath = append(append(android.Paths(nil), flags.bootClasspath...), flags.classpath...)
1670 j.linter.classes = j.implementationJarFile
1671 j.linter.minSdkVersion = lintSDKVersionString(j.minSdkVersion())
1672 j.linter.targetSdkVersion = lintSDKVersionString(j.targetSdkVersion())
1673 j.linter.compileSdkVersion = lintSDKVersionString(j.sdkVersion())
1674 j.linter.javaLanguageLevel = flags.javaVersion.String()
1675 j.linter.kotlinLanguageLevel = "1.3"
1676 j.linter.lint(ctx)
1677 }
1678
Colin Crossb7a63242015-04-16 14:09:14 -07001679 ctx.CheckbuildFile(outputFile)
Colin Cross3063b782018-08-15 11:19:12 -07001680
1681 // Save the output file with no relative path so that it doesn't end up in a subdirectory when used as a resource
1682 j.outputFile = outputFile.WithoutRel()
Colin Cross2fe66872015-03-30 17:20:39 -07001683}
1684
Colin Cross3b706fd2019-09-05 16:44:18 -07001685func (j *Module) compileJavaClasses(ctx android.ModuleContext, jarName string, idx int,
1686 srcFiles, srcJars android.Paths, flags javaBuilderFlags, extraJarDeps android.Paths) android.WritablePath {
1687
1688 kzipName := pathtools.ReplaceExtension(jarName, "kzip")
1689 if idx >= 0 {
1690 kzipName = strings.TrimSuffix(jarName, filepath.Ext(jarName)) + strconv.Itoa(idx) + ".kzip"
1691 jarName += strconv.Itoa(idx)
1692 }
1693
1694 classes := android.PathForModuleOut(ctx, "javac", jarName)
1695 TransformJavaToClasses(ctx, classes, idx, srcFiles, srcJars, flags, extraJarDeps)
1696
1697 if ctx.Config().EmitXrefRules() {
1698 extractionFile := android.PathForModuleOut(ctx, kzipName)
1699 emitXrefRule(ctx, extractionFile, idx, srcFiles, srcJars, flags, extraJarDeps)
1700 j.kytheFiles = append(j.kytheFiles, extractionFile)
1701 }
1702
1703 return classes
1704}
1705
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001706// Check for invalid kotlinc flags. Only use this for flags explicitly passed by the user,
1707// since some of these flags may be used internally.
1708func CheckKotlincFlags(ctx android.ModuleContext, flags []string) {
1709 for _, flag := range flags {
1710 flag = strings.TrimSpace(flag)
1711
1712 if !strings.HasPrefix(flag, "-") {
1713 ctx.PropertyErrorf("kotlincflags", "Flag `%s` must start with `-`", flag)
1714 } else if strings.HasPrefix(flag, "-Xintellij-plugin-root") {
1715 ctx.PropertyErrorf("kotlincflags",
1716 "Bad flag: `%s`, only use internal compiler for consistency.", flag)
1717 } else if inList(flag, config.KotlincIllegalFlags) {
1718 ctx.PropertyErrorf("kotlincflags", "Flag `%s` already used by build system", flag)
1719 } else if flag == "-include-runtime" {
1720 ctx.PropertyErrorf("kotlincflags", "Bad flag: `%s`, do not include runtime.", flag)
1721 } else {
1722 args := strings.Split(flag, " ")
1723 if args[0] == "-kotlin-home" {
1724 ctx.PropertyErrorf("kotlincflags",
1725 "Bad flag: `%s`, kotlin home already set to default (path to kotlinc in the repo).", flag)
1726 }
1727 }
1728 }
1729}
1730
Colin Cross8eadbf02017-10-24 17:46:00 -07001731func (j *Module) compileJavaHeader(ctx android.ModuleContext, srcFiles, srcJars android.Paths,
Colin Crossf5a66282020-02-21 08:16:41 -08001732 deps deps, flags javaBuilderFlags, jarName string,
1733 extraJars android.Paths) (headerJar, jarjarHeaderJar android.Path) {
Nan Zhanged19fc32017-10-19 13:06:22 -07001734
1735 var jars android.Paths
Colin Cross8eadbf02017-10-24 17:46:00 -07001736 if len(srcFiles) > 0 || len(srcJars) > 0 {
Nan Zhanged19fc32017-10-19 13:06:22 -07001737 // Compile java sources into turbine.jar.
1738 turbineJar := android.PathForModuleOut(ctx, "turbine", jarName)
1739 TransformJavaToHeaderClasses(ctx, turbineJar, srcFiles, srcJars, flags)
1740 if ctx.Failed() {
Colin Crossf5a66282020-02-21 08:16:41 -08001741 return nil, nil
Nan Zhanged19fc32017-10-19 13:06:22 -07001742 }
1743 jars = append(jars, turbineJar)
1744 }
1745
Colin Cross55f63ea2018-08-27 12:37:09 -07001746 jars = append(jars, extraJars...)
1747
Nan Zhanged19fc32017-10-19 13:06:22 -07001748 // Combine any static header libraries into classes-header.jar. If there is only
1749 // one input jar this step will be skipped.
Nan Zhanged19fc32017-10-19 13:06:22 -07001750 jars = append(jars, deps.staticHeaderJars...)
1751
Colin Cross5c6ecc12017-10-23 18:12:27 -07001752 // we cannot skip the combine step for now if there is only one jar
1753 // since we have to strip META-INF/TRANSITIVE dir from turbine.jar
1754 combinedJar := android.PathForModuleOut(ctx, "turbine-combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07001755 TransformJarsToJar(ctx, combinedJar, "for turbine", jars, android.OptionalPath{},
Colin Cross6c6e6cd2019-05-08 14:30:12 -07001756 false, nil, []string{"META-INF/TRANSITIVE"})
Colin Cross5c6ecc12017-10-23 18:12:27 -07001757 headerJar = combinedJar
Colin Crossf5a66282020-02-21 08:16:41 -08001758 jarjarHeaderJar = combinedJar
Nan Zhanged19fc32017-10-19 13:06:22 -07001759
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001760 if j.expandJarjarRules != nil {
Nan Zhanged19fc32017-10-19 13:06:22 -07001761 // Transform classes.jar into classes-jarjar.jar
1762 jarjarFile := android.PathForModuleOut(ctx, "turbine-jarjar", jarName)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001763 TransformJarJar(ctx, jarjarFile, headerJar, j.expandJarjarRules)
Colin Crossf5a66282020-02-21 08:16:41 -08001764 jarjarHeaderJar = jarjarFile
Nan Zhanged19fc32017-10-19 13:06:22 -07001765 if ctx.Failed() {
Colin Crossf5a66282020-02-21 08:16:41 -08001766 return nil, nil
Nan Zhanged19fc32017-10-19 13:06:22 -07001767 }
1768 }
1769
Colin Crossf5a66282020-02-21 08:16:41 -08001770 return headerJar, jarjarHeaderJar
Nan Zhanged19fc32017-10-19 13:06:22 -07001771}
1772
Colin Crosscb933592017-11-22 13:49:43 -08001773func (j *Module) instrument(ctx android.ModuleContext, flags javaBuilderFlags,
Colin Cross3063b782018-08-15 11:19:12 -07001774 classesJar android.Path, jarName string) android.ModuleOutPath {
Colin Crosscb933592017-11-22 13:49:43 -08001775
Colin Cross7a3139e2017-12-19 13:57:50 -08001776 specs := j.jacocoModuleToZipCommand(ctx)
Colin Crosscb933592017-11-22 13:49:43 -08001777
Colin Cross84c38822018-01-03 15:59:46 -08001778 jacocoReportClassesFile := android.PathForModuleOut(ctx, "jacoco-report-classes", jarName)
Colin Crosscb933592017-11-22 13:49:43 -08001779 instrumentedJar := android.PathForModuleOut(ctx, "jacoco", jarName)
1780
1781 jacocoInstrumentJar(ctx, instrumentedJar, jacocoReportClassesFile, classesJar, specs)
1782
1783 j.jacocoReportClassesFile = jacocoReportClassesFile
1784
1785 return instrumentedJar
1786}
1787
albaltai36ff7dc2018-12-25 14:35:23 +08001788var _ Dependency = (*Module)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07001789
Nan Zhanged19fc32017-10-19 13:06:22 -07001790func (j *Module) HeaderJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001791 if j.headerJarFile == nil {
1792 return nil
1793 }
Nan Zhanged19fc32017-10-19 13:06:22 -07001794 return android.Paths{j.headerJarFile}
1795}
1796
1797func (j *Module) ImplementationJars() android.Paths {
shinwang9e4c07a2018-12-24 15:41:04 +08001798 if j.implementationJarFile == nil {
1799 return nil
1800 }
Nan Zhanged19fc32017-10-19 13:06:22 -07001801 return android.Paths{j.implementationJarFile}
Colin Cross2fe66872015-03-30 17:20:39 -07001802}
1803
Colin Crossf24a22a2019-01-31 14:12:44 -08001804func (j *Module) DexJar() android.Path {
1805 return j.dexJarFile
1806}
1807
Colin Cross331a1212018-08-15 20:40:52 -07001808func (j *Module) ResourceJars() android.Paths {
1809 if j.resourceJar == nil {
1810 return nil
1811 }
1812 return android.Paths{j.resourceJar}
1813}
1814
1815func (j *Module) ImplementationAndResourcesJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001816 if j.implementationAndResourcesJar == nil {
1817 return nil
1818 }
Colin Cross331a1212018-08-15 20:40:52 -07001819 return android.Paths{j.implementationAndResourcesJar}
1820}
1821
Colin Cross46c9b8b2017-06-22 16:51:17 -07001822func (j *Module) AidlIncludeDirs() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08001823 // exportAidlIncludeDirs is type android.Paths already
Colin Crossc0b06f12015-04-08 13:03:43 -07001824 return j.exportAidlIncludeDirs
1825}
1826
Jiyong Park1be96912018-05-28 18:02:19 +09001827func (j *Module) ExportedSdkLibs() []string {
albaltai36ff7dc2018-12-25 14:35:23 +08001828 // exportedSdkLibs is type []string
Jiyong Park1be96912018-05-28 18:02:19 +09001829 return j.exportedSdkLibs
1830}
1831
Artur Satayev9cf46692019-11-26 18:08:34 +00001832func (j *Module) ExportedPlugins() (android.Paths, []string) {
1833 return j.exportedPluginJars, j.exportedPluginClasses
1834}
1835
Colin Cross0c4ce212019-05-03 15:28:19 -07001836func (j *Module) SrcJarArgs() ([]string, android.Paths) {
1837 return j.srcJarArgs, j.srcJarDeps
1838}
1839
Colin Cross46c9b8b2017-06-22 16:51:17 -07001840var _ logtagsProducer = (*Module)(nil)
Colin Crossf05fe972015-04-10 17:45:20 -07001841
Colin Cross46c9b8b2017-06-22 16:51:17 -07001842func (j *Module) logtags() android.Paths {
Colin Crossf05fe972015-04-10 17:45:20 -07001843 return j.logtagsSrcs
1844}
1845
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001846// Collect information for opening IDE project files in java/jdeps.go.
1847func (j *Module) IDEInfo(dpInfo *android.IdeInfo) {
1848 dpInfo.Deps = append(dpInfo.Deps, j.CompilerDeps()...)
1849 dpInfo.Srcs = append(dpInfo.Srcs, j.expandIDEInfoCompiledSrcs...)
patricktu18c82ff2019-05-10 15:48:50 +08001850 dpInfo.SrcJars = append(dpInfo.SrcJars, j.compiledSrcJars.Strings()...)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001851 dpInfo.Aidl_include_dirs = append(dpInfo.Aidl_include_dirs, j.deviceProperties.Aidl.Include_dirs...)
Steven Morelandc4efd9c2019-01-18 11:51:25 -08001852 if j.expandJarjarRules != nil {
1853 dpInfo.Jarjar_rules = append(dpInfo.Jarjar_rules, j.expandJarjarRules.String())
Brandon Lee5d45c6f2018-08-15 15:35:38 -07001854 }
1855}
1856
1857func (j *Module) CompilerDeps() []string {
1858 jdeps := []string{}
1859 jdeps = append(jdeps, j.properties.Libs...)
1860 jdeps = append(jdeps, j.properties.Static_libs...)
1861 return jdeps
1862}
1863
Jaewoong Jungc27ab662019-05-30 15:51:14 -07001864func (j *Module) hasCode(ctx android.ModuleContext) bool {
1865 srcFiles := android.PathsForModuleSrcExcludes(ctx, j.properties.Srcs, j.properties.Exclude_srcs)
1866 return len(srcFiles) > 0 || len(ctx.GetDirectDepsWithTag(staticLibTag)) > 0
1867}
1868
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001869func (j *Module) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Paul Duffinc8f2f182020-05-17 08:34:50 +01001870 return j.depIsInSameApex(ctx, dep)
Jiyong Parka7bc8ad2019-10-15 15:20:07 +09001871}
1872
Jiyong Park0b238752019-10-29 11:23:10 +09001873func (j *Module) Stem() string {
1874 return proptools.StringDefault(j.deviceProperties.Stem, j.Name())
1875}
1876
Jiyong Park618922e2020-01-08 13:35:43 +09001877func (j *Module) JacocoReportClassesFile() android.Path {
1878 return j.jacocoReportClassesFile
1879}
1880
Martin Stjernholm6d415272020-01-31 17:10:36 +00001881func (j *Module) IsInstallable() bool {
1882 return Bool(j.properties.Installable)
1883}
1884
Colin Cross2fe66872015-03-30 17:20:39 -07001885//
1886// Java libraries (.jar file)
1887//
1888
Anton Hansson1e65f942020-03-27 19:39:48 +00001889type LibraryProperties struct {
1890 Dist struct {
1891 // The tag of the output of this module that should be output.
1892 Tag *string `android:"arch_variant"`
1893 } `android:"arch_variant"`
1894}
1895
Colin Crossf506d872017-07-19 15:53:04 -07001896type Library struct {
Colin Cross46c9b8b2017-06-22 16:51:17 -07001897 Module
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001898
Anton Hansson1e65f942020-03-27 19:39:48 +00001899 libraryProperties LibraryProperties
1900
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001901 InstallMixin func(ctx android.ModuleContext, installPath android.Path) (extraInstallDeps android.Paths)
Colin Cross2fe66872015-03-30 17:20:39 -07001902}
1903
Paul Duffina105cf92020-05-29 11:24:51 +01001904// Provides access to the list of permitted packages from updatable boot jars.
1905type PermittedPackagesForUpdatableBootJars interface {
1906 PermittedPackagesForUpdatableBootJars() []string
1907}
1908
1909var _ PermittedPackagesForUpdatableBootJars = (*Library)(nil)
1910
1911func (j *Library) PermittedPackagesForUpdatableBootJars() []string {
1912 return j.properties.Permitted_packages
1913}
1914
Colin Cross42be7612019-02-21 18:12:14 -08001915func shouldUncompressDex(ctx android.ModuleContext, dexpreopter *dexpreopter) bool {
Ulya Trafimovichf491dde2020-01-24 12:19:45 +00001916 // Store uncompressed (and aligned) any dex files from jars in APEXes.
1917 if am, ok := ctx.Module().(android.ApexModule); ok && !am.IsForPlatform() {
1918 return true
1919 }
1920
Nicolas Geoffrayfa6e9ec2019-02-12 13:12:16 +00001921 // Store uncompressed (and do not strip) dex files from boot class path jars.
1922 if inList(ctx.ModuleName(), ctx.Config().BootJars()) {
1923 return true
1924 }
1925
1926 // Store uncompressed dex files that are preopted on /system.
Colin Cross42be7612019-02-21 18:12:14 -08001927 if !dexpreopter.dexpreoptDisabled(ctx) && (ctx.Host() || !odexOnSystemOther(ctx, dexpreopter.installPath)) {
Vladimir Markoe8b00d62018-12-21 15:54:16 +00001928 return true
1929 }
Colin Cross083a2aa2019-02-06 16:37:12 -08001930 if ctx.Config().UncompressPrivAppDex() &&
1931 inList(ctx.ModuleName(), ctx.Config().ModulesLoadedByPrivilegedModules()) {
1932 return true
1933 }
1934
Colin Cross2fc72f62018-12-21 12:59:54 -08001935 return false
1936}
1937
Colin Crossf506d872017-07-19 15:53:04 -07001938func (j *Library) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Artur Satayeve5ac15a2020-04-08 19:09:30 +01001939 j.checkSdkVersions(ctx)
Jiyong Park0b238752019-10-29 11:23:10 +09001940 j.dexpreopter.installPath = android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar")
Colin Cross43f08db2018-11-12 10:13:39 -08001941 j.dexpreopter.isSDKLibrary = j.deviceProperties.IsSDKLibrary
David Srbecky98c71222020-05-20 22:20:28 +01001942 if j.deviceProperties.Uncompress_dex == nil {
1943 // If the value was not force-set by the user, use reasonable default based on the module.
1944 j.deviceProperties.Uncompress_dex = proptools.BoolPtr(shouldUncompressDex(ctx, &j.dexpreopter))
1945 }
1946 j.dexpreopter.uncompressedDex = *j.deviceProperties.Uncompress_dex
Jaewoong Junga24af3b2019-05-13 09:23:20 -07001947 j.compile(ctx, nil)
Colin Crossb7a63242015-04-16 14:09:14 -07001948
Jiyong Park7f7766d2019-07-25 22:02:35 +09001949 exclusivelyForApex := android.InAnyApex(ctx.ModuleName()) && !j.IsForPlatform()
1950 if (Bool(j.properties.Installable) || ctx.Host()) && !exclusivelyForApex {
Colin Crossf0f2e2c2019-10-15 16:36:40 -07001951 var extraInstallDeps android.Paths
1952 if j.InstallMixin != nil {
1953 extraInstallDeps = j.InstallMixin(ctx, j.outputFile)
1954 }
Colin Cross2c429dc2017-08-31 16:45:16 -07001955 j.installFile = ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
Jiyong Parked50ca82020-05-28 23:46:55 +09001956 j.Stem()+".jar", j.outputFile, extraInstallDeps...)
Colin Cross2c429dc2017-08-31 16:45:16 -07001957 }
Anton Hansson1e65f942020-03-27 19:39:48 +00001958
1959 // Verify Dist.Tag is set to a supported output
1960 if j.libraryProperties.Dist.Tag != nil {
1961 distFiles, err := j.OutputFiles(*j.libraryProperties.Dist.Tag)
1962 if err != nil {
1963 ctx.PropertyErrorf("dist.tag", "%s", err.Error())
1964 }
1965 j.distFile = distFiles[0]
1966 }
Colin Crossb7a63242015-04-16 14:09:14 -07001967}
1968
Colin Crossf506d872017-07-19 15:53:04 -07001969func (j *Library) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross46c9b8b2017-06-22 16:51:17 -07001970 j.deps(ctx)
1971}
1972
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001973const (
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001974 aidlIncludeDir = "aidl"
1975 javaDir = "java"
1976 jarFileSuffix = ".jar"
1977 testConfigSuffix = "-AndroidTest.xml"
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001978)
1979
Paul Duffina0dbf432019-12-05 11:25:53 +00001980// path to the jar file of a java library. Relative to <sdk_root>/<api_dir>
Paul Duffin9b358d72020-03-02 10:16:35 +00001981func sdkSnapshotFilePathForJar(osPrefix, name string) string {
1982 return sdkSnapshotFilePathForMember(osPrefix, name, jarFileSuffix)
Paul Duffin1b82e6a2019-12-03 18:06:47 +00001983}
1984
Paul Duffin9b358d72020-03-02 10:16:35 +00001985func sdkSnapshotFilePathForMember(osPrefix, name string, suffix string) string {
1986 return filepath.Join(javaDir, osPrefix, name+suffix)
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00001987}
1988
Paul Duffin13879572019-11-28 14:31:38 +00001989type librarySdkMemberType struct {
Paul Duffin255f18e2019-12-13 11:22:16 +00001990 android.SdkMemberTypeBase
Paul Duffin2b9e3d32020-02-28 14:39:53 +00001991
1992 // Function to retrieve the appropriate output jar (implementation or header) from
1993 // the library.
1994 jarToExportGetter func(j *Library) android.Path
Paul Duffin13879572019-11-28 14:31:38 +00001995}
1996
1997func (mt *librarySdkMemberType) AddDependencies(mctx android.BottomUpMutatorContext, dependencyTag blueprint.DependencyTag, names []string) {
1998 mctx.AddVariationDependencies(nil, dependencyTag, names...)
1999}
2000
2001func (mt *librarySdkMemberType) IsInstance(module android.Module) bool {
2002 _, ok := module.(*Library)
2003 return ok
2004}
2005
Paul Duffin17ab8832020-03-19 16:11:18 +00002006func (mt *librarySdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
2007 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_import")
Paul Duffind76209b2020-03-02 11:33:02 +00002008}
Paul Duffina0dbf432019-12-05 11:25:53 +00002009
Paul Duffind76209b2020-03-02 11:33:02 +00002010func (mt *librarySdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
Paul Duffinc9103932020-03-17 21:04:24 +00002011 return &librarySdkMemberProperties{}
Paul Duffind76209b2020-03-02 11:33:02 +00002012}
2013
2014type librarySdkMemberProperties struct {
2015 android.SdkMemberPropertiesBase
2016
Paul Duffin08385bf2020-05-06 10:23:19 +01002017 JarToExport android.Path `android:"arch_variant"`
Paul Duffinc9103932020-03-17 21:04:24 +00002018 AidlIncludeDirs android.Paths
Paul Duffind76209b2020-03-02 11:33:02 +00002019}
2020
Paul Duffin17ab8832020-03-19 16:11:18 +00002021func (p *librarySdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffin13879572019-11-28 14:31:38 +00002022 j := variant.(*Library)
2023
Paul Duffinc9103932020-03-17 21:04:24 +00002024 p.JarToExport = ctx.MemberType().(*librarySdkMemberType).jarToExportGetter(j)
2025 p.AidlIncludeDirs = j.AidlIncludeDirs()
Paul Duffind76209b2020-03-02 11:33:02 +00002026}
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00002027
Paul Duffin17ab8832020-03-19 16:11:18 +00002028func (p *librarySdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffinc9103932020-03-17 21:04:24 +00002029 builder := ctx.SnapshotBuilder()
Paul Duffin17ab8832020-03-19 16:11:18 +00002030
Paul Duffinc9103932020-03-17 21:04:24 +00002031 exportedJar := p.JarToExport
2032 if exportedJar != nil {
2033 snapshotRelativeJavaLibPath := sdkSnapshotFilePathForJar(p.OsPrefix(), ctx.Name())
Paul Duffind76209b2020-03-02 11:33:02 +00002034 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
2035
Paul Duffinc9103932020-03-17 21:04:24 +00002036 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
2037 }
2038
2039 aidlIncludeDirs := p.AidlIncludeDirs
2040 if len(aidlIncludeDirs) != 0 {
2041 sdkModuleContext := ctx.SdkModuleContext()
2042 for _, dir := range aidlIncludeDirs {
Paul Duffind76209b2020-03-02 11:33:02 +00002043 // TODO(jiyong): copy parcelable declarations only
2044 aidlFiles, _ := sdkModuleContext.GlobWithDeps(dir.String()+"/**/*.aidl", nil)
2045 for _, file := range aidlFiles {
2046 builder.CopyToSnapshot(android.PathForSource(sdkModuleContext, file), filepath.Join(aidlIncludeDir, file))
2047 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00002048 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00002049
Paul Duffinc9103932020-03-17 21:04:24 +00002050 // TODO(b/151933053) - add aidl include dirs property
Paul Duffind76209b2020-03-02 11:33:02 +00002051 }
Paul Duffin0e0cf1d2019-11-12 19:39:25 +00002052}
2053
Paul Duffin2b9e3d32020-02-28 14:39:53 +00002054var javaHeaderLibsSdkMemberType android.SdkMemberType = &librarySdkMemberType{
2055 android.SdkMemberTypeBase{
2056 PropertyName: "java_header_libs",
2057 SupportsSdk: true,
Paul Duffin7b81f5e2020-01-13 21:03:22 +00002058 },
Paul Duffin2b9e3d32020-02-28 14:39:53 +00002059 func(j *Library) android.Path {
Paul Duffina0dbf432019-12-05 11:25:53 +00002060 headerJars := j.HeaderJars()
2061 if len(headerJars) != 1 {
2062 panic(fmt.Errorf("there must be only one header jar from %q", j.Name()))
2063 }
2064
2065 return headerJars[0]
Paul Duffin2b9e3d32020-02-28 14:39:53 +00002066 },
Paul Duffina0dbf432019-12-05 11:25:53 +00002067}
2068
Colin Cross1b16b0e2019-02-12 14:41:32 -08002069// java_library builds and links sources into a `.jar` file for the device, and possibly for the host as well.
2070//
2071// By default, a java_library has a single variant that produces a `.jar` file containing `.class` files that were
2072// compiled against the device bootclasspath. This jar is not suitable for installing on a device, but can be used
2073// as a `static_libs` dependency of another module.
2074//
2075// Specifying `installable: true` will product a `.jar` file containing `classes.dex` files, suitable for installing on
2076// a device.
2077//
2078// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
2079// compiled against the host bootclasspath.
Colin Cross9ae1b922018-06-26 17:59:05 -07002080func LibraryFactory() android.Module {
2081 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -07002082
Colin Cross1c14b4e2020-06-15 16:09:53 -07002083 module.addHostAndDeviceProperties()
2084 module.AddProperties(&module.libraryProperties)
Colin Cross2fe66872015-03-30 17:20:39 -07002085
Paul Duffin64e61992020-05-15 10:20:31 +01002086 module.initModuleAndImport(&module.ModuleBase)
2087
Jiyong Park7f7766d2019-07-25 22:02:35 +09002088 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09002089 android.InitSdkAwareModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002090 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross9ae1b922018-06-26 17:59:05 -07002091 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002092}
2093
Colin Cross1b16b0e2019-02-12 14:41:32 -08002094// java_library_static is an obsolete alias for java_library.
2095func LibraryStaticFactory() android.Module {
2096 return LibraryFactory()
2097}
2098
2099// java_library_host builds and links sources into a `.jar` file for the host.
2100//
2101// A java_library_host has a single variant that produces a `.jar` file containing `.class` files that were
2102// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002103func LibraryHostFactory() android.Module {
2104 module := &Library{}
Colin Cross2fe66872015-03-30 17:20:39 -07002105
Colin Cross1c14b4e2020-06-15 16:09:53 -07002106 module.addHostProperties()
Colin Cross36242852017-06-23 15:06:31 -07002107
Colin Cross9ae1b922018-06-26 17:59:05 -07002108 module.Module.properties.Installable = proptools.BoolPtr(true)
2109
Jiyong Park7f7766d2019-07-25 22:02:35 +09002110 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002111 InitJavaModule(module, android.HostSupported)
Colin Cross36242852017-06-23 15:06:31 -07002112 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002113}
2114
2115//
Colin Crossb628ea52018-08-14 16:42:33 -07002116// Java Tests
Colin Cross05638fc2018-04-09 18:40:24 -07002117//
2118
2119type testProperties struct {
Colin Cross05638fc2018-04-09 18:40:24 -07002120 // list of compatibility suites (for example "cts", "vts") that the module should be
2121 // installed into.
2122 Test_suites []string `android:"arch_variant"`
Julien Despreze146e392018-08-02 15:00:46 -07002123
2124 // the name of the test configuration (for example "AndroidTest.xml") that should be
2125 // installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -08002126 Test_config *string `android:"path,arch_variant"`
Colin Crossd96ca352018-08-10 16:06:24 -07002127
Jack He33338892018-09-19 02:21:28 -07002128 // the name of the test configuration template (for example "AndroidTestTemplate.xml") that
2129 // should be installed with the module.
Colin Cross27b922f2019-03-04 22:35:41 -08002130 Test_config_template *string `android:"path,arch_variant"`
Jack He33338892018-09-19 02:21:28 -07002131
Colin Crossd96ca352018-08-10 16:06:24 -07002132 // list of files or filegroup modules that provide data that should be installed alongside
2133 // the test
Colin Cross27b922f2019-03-04 22:35:41 -08002134 Data []string `android:"path"`
Dan Shi6ffaaa82019-09-26 11:41:36 -07002135
2136 // Flag to indicate whether or not to create test config automatically. If AndroidTest.xml
2137 // doesn't exist next to the Android.bp, this attribute doesn't need to be set to true
2138 // explicitly.
2139 Auto_gen_config *bool
easoncyleeba606252020-04-30 14:57:06 +08002140
2141 // Add parameterized mainline modules to auto generated test config. The options will be
2142 // handled by TradeFed to do downloading and installing the specified modules on the device.
2143 Test_mainline_modules []string
Colin Cross05638fc2018-04-09 18:40:24 -07002144}
2145
Paul Duffin42df1442019-03-20 12:45:53 +00002146type testHelperLibraryProperties struct {
2147 // list of compatibility suites (for example "cts", "vts") that the module should be
2148 // installed into.
2149 Test_suites []string `android:"arch_variant"`
2150}
2151
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002152type prebuiltTestProperties struct {
2153 // list of compatibility suites (for example "cts", "vts") that the module should be
2154 // installed into.
2155 Test_suites []string `android:"arch_variant"`
2156
2157 // the name of the test configuration (for example "AndroidTest.xml") that should be
2158 // installed with the module.
2159 Test_config *string `android:"path,arch_variant"`
2160}
2161
Colin Cross05638fc2018-04-09 18:40:24 -07002162type Test struct {
2163 Library
2164
2165 testProperties testProperties
Colin Cross303e21f2018-08-07 16:49:25 -07002166
2167 testConfig android.Path
Colin Crossd96ca352018-08-10 16:06:24 -07002168 data android.Paths
Colin Cross303e21f2018-08-07 16:49:25 -07002169}
2170
Paul Duffin42df1442019-03-20 12:45:53 +00002171type TestHelperLibrary struct {
2172 Library
2173
2174 testHelperLibraryProperties testHelperLibraryProperties
2175}
2176
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002177type JavaTestImport struct {
2178 Import
2179
2180 prebuiltTestProperties prebuiltTestProperties
2181
2182 testConfig android.Path
2183}
2184
Colin Cross303e21f2018-08-07 16:49:25 -07002185func (j *Test) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Dan Shi6ffaaa82019-09-26 11:41:36 -07002186 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.testProperties.Test_config, j.testProperties.Test_config_template,
2187 j.testProperties.Test_suites, j.testProperties.Auto_gen_config)
Colin Cross8a497952019-03-05 22:25:09 -08002188 j.data = android.PathsForModuleSrc(ctx, j.testProperties.Data)
Colin Cross303e21f2018-08-07 16:49:25 -07002189
2190 j.Library.GenerateAndroidBuildActions(ctx)
Colin Cross05638fc2018-04-09 18:40:24 -07002191}
2192
Paul Duffin42df1442019-03-20 12:45:53 +00002193func (j *TestHelperLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2194 j.Library.GenerateAndroidBuildActions(ctx)
2195}
2196
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002197func (j *JavaTestImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2198 j.testConfig = tradefed.AutoGenJavaTestConfig(ctx, j.prebuiltTestProperties.Test_config, nil,
2199 j.prebuiltTestProperties.Test_suites, nil)
2200
2201 j.Import.GenerateAndroidBuildActions(ctx)
2202}
2203
2204type testSdkMemberType struct {
2205 android.SdkMemberTypeBase
2206}
2207
2208func (mt *testSdkMemberType) AddDependencies(mctx android.BottomUpMutatorContext, dependencyTag blueprint.DependencyTag, names []string) {
2209 mctx.AddVariationDependencies(nil, dependencyTag, names...)
2210}
2211
2212func (mt *testSdkMemberType) IsInstance(module android.Module) bool {
2213 _, ok := module.(*Test)
2214 return ok
2215}
2216
Paul Duffin17ab8832020-03-19 16:11:18 +00002217func (mt *testSdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule {
2218 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_test_import")
Paul Duffind76209b2020-03-02 11:33:02 +00002219}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002220
Paul Duffind76209b2020-03-02 11:33:02 +00002221func (mt *testSdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties {
2222 return &testSdkMemberProperties{}
2223}
2224
2225type testSdkMemberProperties struct {
2226 android.SdkMemberPropertiesBase
2227
Paul Duffinc9103932020-03-17 21:04:24 +00002228 JarToExport android.Path
2229 TestConfig android.Path
Paul Duffind76209b2020-03-02 11:33:02 +00002230}
2231
Paul Duffin17ab8832020-03-19 16:11:18 +00002232func (p *testSdkMemberProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) {
Paul Duffind76209b2020-03-02 11:33:02 +00002233 test := variant.(*Test)
2234
2235 implementationJars := test.ImplementationJars()
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002236 if len(implementationJars) != 1 {
Paul Duffind76209b2020-03-02 11:33:02 +00002237 panic(fmt.Errorf("there must be only one implementation jar from %q", test.Name()))
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002238 }
2239
Paul Duffinc9103932020-03-17 21:04:24 +00002240 p.JarToExport = implementationJars[0]
2241 p.TestConfig = test.testConfig
Paul Duffind76209b2020-03-02 11:33:02 +00002242}
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002243
Paul Duffin17ab8832020-03-19 16:11:18 +00002244func (p *testSdkMemberProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) {
Paul Duffinc9103932020-03-17 21:04:24 +00002245 builder := ctx.SnapshotBuilder()
Paul Duffin17ab8832020-03-19 16:11:18 +00002246
Paul Duffinc9103932020-03-17 21:04:24 +00002247 exportedJar := p.JarToExport
2248 if exportedJar != nil {
2249 snapshotRelativeJavaLibPath := sdkSnapshotFilePathForJar(p.OsPrefix(), ctx.Name())
2250 builder.CopyToSnapshot(exportedJar, snapshotRelativeJavaLibPath)
Paul Duffind76209b2020-03-02 11:33:02 +00002251
2252 propertySet.AddProperty("jars", []string{snapshotRelativeJavaLibPath})
Paul Duffinc9103932020-03-17 21:04:24 +00002253 }
2254
2255 testConfig := p.TestConfig
2256 if testConfig != nil {
2257 snapshotRelativeTestConfigPath := sdkSnapshotFilePathForMember(p.OsPrefix(), ctx.Name(), testConfigSuffix)
2258 builder.CopyToSnapshot(testConfig, snapshotRelativeTestConfigPath)
Paul Duffind76209b2020-03-02 11:33:02 +00002259 propertySet.AddProperty("test_config", snapshotRelativeTestConfigPath)
2260 }
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002261}
2262
Colin Cross1b16b0e2019-02-12 14:41:32 -08002263// java_test builds a and links sources into a `.jar` file for the device, and possibly for the host as well, and
2264// creates an `AndroidTest.xml` file to allow running the test with `atest` or a `TEST_MAPPING` file.
2265//
2266// By default, a java_test has a single variant that produces a `.jar` file containing `classes.dex` files that were
2267// compiled against the device bootclasspath.
2268//
2269// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
2270// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07002271func TestFactory() android.Module {
2272 module := &Test{}
2273
Colin Cross1c14b4e2020-06-15 16:09:53 -07002274 module.addHostAndDeviceProperties()
2275 module.AddProperties(&module.testProperties)
Colin Cross05638fc2018-04-09 18:40:24 -07002276
Colin Cross9ae1b922018-06-26 17:59:05 -07002277 module.Module.properties.Installable = proptools.BoolPtr(true)
Colin Crosse3026872019-01-05 22:30:13 -08002278 module.Module.dexpreopter.isTest = true
Colin Cross1e28e3c2020-06-02 20:09:13 -07002279 module.Module.linter.test = true
Colin Cross9ae1b922018-06-26 17:59:05 -07002280
Colin Cross05638fc2018-04-09 18:40:24 -07002281 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross05638fc2018-04-09 18:40:24 -07002282 return module
2283}
2284
Paul Duffin42df1442019-03-20 12:45:53 +00002285// java_test_helper_library creates a java library and makes sure that it is added to the appropriate test suite.
2286func TestHelperLibraryFactory() android.Module {
2287 module := &TestHelperLibrary{}
2288
Colin Cross1c14b4e2020-06-15 16:09:53 -07002289 module.addHostAndDeviceProperties()
2290 module.AddProperties(&module.testHelperLibraryProperties)
Paul Duffin42df1442019-03-20 12:45:53 +00002291
Colin Cross9a4abed2019-04-24 13:19:28 -07002292 module.Module.properties.Installable = proptools.BoolPtr(true)
2293 module.Module.dexpreopter.isTest = true
Colin Cross1e28e3c2020-06-02 20:09:13 -07002294 module.Module.linter.test = true
Colin Cross9a4abed2019-04-24 13:19:28 -07002295
Paul Duffin42df1442019-03-20 12:45:53 +00002296 InitJavaModule(module, android.HostAndDeviceSupported)
2297 return module
2298}
2299
Paul Duffin1b82e6a2019-12-03 18:06:47 +00002300// java_test_import imports one or more `.jar` files into the build graph as if they were built by a java_test module
2301// and makes sure that it is added to the appropriate test suite.
2302//
2303// By default, a java_test_import has a single variant that expects a `.jar` file containing `.class` files that were
2304// compiled against an Android classpath.
2305//
2306// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
2307// for host modules.
2308func JavaTestImportFactory() android.Module {
2309 module := &JavaTestImport{}
2310
2311 module.AddProperties(
2312 &module.Import.properties,
2313 &module.prebuiltTestProperties)
2314
2315 module.Import.properties.Installable = proptools.BoolPtr(true)
2316
2317 android.InitPrebuiltModule(module, &module.properties.Jars)
2318 android.InitApexModule(module)
2319 android.InitSdkAwareModule(module)
2320 InitJavaModule(module, android.HostAndDeviceSupported)
2321 return module
2322}
2323
Colin Cross1b16b0e2019-02-12 14:41:32 -08002324// java_test_host builds a and links sources into a `.jar` file for the host, and creates an `AndroidTest.xml` file to
2325// allow running the test with `atest` or a `TEST_MAPPING` file.
2326//
2327// A java_test_host has a single variant that produces a `.jar` file containing `.class` files that were
2328// compiled against the host bootclasspath.
Colin Cross05638fc2018-04-09 18:40:24 -07002329func TestHostFactory() android.Module {
2330 module := &Test{}
2331
Colin Cross1c14b4e2020-06-15 16:09:53 -07002332 module.addHostProperties()
2333 module.AddProperties(&module.testProperties)
Colin Cross05638fc2018-04-09 18:40:24 -07002334
Colin Cross9ae1b922018-06-26 17:59:05 -07002335 module.Module.properties.Installable = proptools.BoolPtr(true)
2336
Colin Cross05638fc2018-04-09 18:40:24 -07002337 InitJavaModule(module, android.HostSupported)
Colin Cross05638fc2018-04-09 18:40:24 -07002338 return module
2339}
2340
2341//
Colin Cross2fe66872015-03-30 17:20:39 -07002342// Java Binaries (.jar file plus wrapper script)
2343//
2344
Colin Crossf506d872017-07-19 15:53:04 -07002345type binaryProperties struct {
Colin Cross7d5136f2015-05-11 13:39:40 -07002346 // installable script to execute the resulting jar
Colin Cross27b922f2019-03-04 22:35:41 -08002347 Wrapper *string `android:"path"`
Colin Cross094054a2018-10-17 15:10:48 -07002348
2349 // Name of the class containing main to be inserted into the manifest as Main-Class.
2350 Main_class *string
Colin Cross7d5136f2015-05-11 13:39:40 -07002351}
2352
Colin Crossf506d872017-07-19 15:53:04 -07002353type Binary struct {
2354 Library
Colin Cross2fe66872015-03-30 17:20:39 -07002355
Colin Crossf506d872017-07-19 15:53:04 -07002356 binaryProperties binaryProperties
Colin Cross10a03492017-08-10 17:09:43 -07002357
Colin Cross6b4a32d2017-12-05 13:42:45 -08002358 isWrapperVariant bool
2359
Colin Crossc3315992017-12-08 19:12:36 -08002360 wrapperFile android.Path
Colin Cross70dda7e2019-10-01 22:05:35 -07002361 binaryFile android.InstallPath
Colin Cross2fe66872015-03-30 17:20:39 -07002362}
2363
Alex Light24237172017-10-26 09:46:21 -07002364func (j *Binary) HostToolPath() android.OptionalPath {
2365 return android.OptionalPathForPath(j.binaryFile)
2366}
2367
Colin Crossf506d872017-07-19 15:53:04 -07002368func (j *Binary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002369 if ctx.Arch().ArchType == android.Common {
2370 // Compile the jar
Colin Cross094054a2018-10-17 15:10:48 -07002371 if j.binaryProperties.Main_class != nil {
2372 if j.properties.Manifest != nil {
2373 ctx.PropertyErrorf("main_class", "main_class cannot be used when manifest is set")
2374 }
2375 manifestFile := android.PathForModuleOut(ctx, "manifest.txt")
2376 GenerateMainClassManifest(ctx, manifestFile, String(j.binaryProperties.Main_class))
2377 j.overrideManifest = android.OptionalPathForPath(manifestFile)
2378 }
2379
Colin Cross6b4a32d2017-12-05 13:42:45 -08002380 j.Library.GenerateAndroidBuildActions(ctx)
Nan Zhang3c807db2017-11-03 14:53:31 -07002381 } else {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002382 // Handle the binary wrapper
2383 j.isWrapperVariant = true
2384
Colin Cross366938f2017-12-11 16:29:02 -08002385 if j.binaryProperties.Wrapper != nil {
Colin Cross8a497952019-03-05 22:25:09 -08002386 j.wrapperFile = android.PathForModuleSrc(ctx, *j.binaryProperties.Wrapper)
Colin Cross6b4a32d2017-12-05 13:42:45 -08002387 } else {
2388 j.wrapperFile = android.PathForSource(ctx, "build/soong/scripts/jar-wrapper.sh")
2389 }
2390
2391 // Depend on the installed jar so that the wrapper doesn't get executed by
2392 // another build rule before the jar has been installed.
2393 jarFile := ctx.PrimaryModule().(*Binary).installFile
2394
2395 j.binaryFile = ctx.InstallExecutable(android.PathForModuleInstall(ctx, "bin"),
2396 ctx.ModuleName(), j.wrapperFile, jarFile)
Nan Zhang3c807db2017-11-03 14:53:31 -07002397 }
Colin Cross2fe66872015-03-30 17:20:39 -07002398}
2399
Colin Crossf506d872017-07-19 15:53:04 -07002400func (j *Binary) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross6b4a32d2017-12-05 13:42:45 -08002401 if ctx.Arch().ArchType == android.Common {
2402 j.deps(ctx)
2403 }
Colin Cross46c9b8b2017-06-22 16:51:17 -07002404}
2405
Colin Cross1b16b0e2019-02-12 14:41:32 -08002406// java_binary builds a `.jar` file and a shell script that executes it for the device, and possibly for the host
2407// as well.
2408//
2409// By default, a java_binary has a single variant that produces a `.jar` file containing `classes.dex` files that were
2410// compiled against the device bootclasspath.
2411//
2412// Specifying `host_supported: true` will produce two variants, one compiled against the device bootclasspath and one
2413// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002414func BinaryFactory() android.Module {
2415 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07002416
Colin Cross1c14b4e2020-06-15 16:09:53 -07002417 module.addHostAndDeviceProperties()
2418 module.AddProperties(&module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07002419
Colin Cross9ae1b922018-06-26 17:59:05 -07002420 module.Module.properties.Installable = proptools.BoolPtr(true)
2421
Colin Cross6b4a32d2017-12-05 13:42:45 -08002422 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommonFirst)
2423 android.InitDefaultableModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002424 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002425}
2426
Colin Cross1b16b0e2019-02-12 14:41:32 -08002427// java_binary_host builds a `.jar` file and a shell script that executes it for the host.
2428//
2429// A java_binary_host has a single variant that produces a `.jar` file containing `.class` files that were
2430// compiled against the host bootclasspath.
Colin Crossf506d872017-07-19 15:53:04 -07002431func BinaryHostFactory() android.Module {
2432 module := &Binary{}
Colin Cross2fe66872015-03-30 17:20:39 -07002433
Colin Cross1c14b4e2020-06-15 16:09:53 -07002434 module.addHostProperties()
2435 module.AddProperties(&module.binaryProperties)
Colin Cross36242852017-06-23 15:06:31 -07002436
Colin Cross9ae1b922018-06-26 17:59:05 -07002437 module.Module.properties.Installable = proptools.BoolPtr(true)
2438
Colin Cross6b4a32d2017-12-05 13:42:45 -08002439 android.InitAndroidArchModule(module, android.HostSupported, android.MultilibCommonFirst)
2440 android.InitDefaultableModule(module)
Colin Cross36242852017-06-23 15:06:31 -07002441 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002442}
2443
2444//
2445// Java prebuilts
2446//
2447
Colin Cross74d73e22017-08-02 11:05:49 -07002448type ImportProperties struct {
Paul Duffin9b358d72020-03-02 10:16:35 +00002449 Jars []string `android:"path,arch_variant"`
Colin Cross461bd1a2017-10-20 13:59:18 -07002450
Nan Zhangea568a42017-11-08 21:20:04 -08002451 Sdk_version *string
Colin Cross535e2cf2017-10-20 17:57:49 -07002452
2453 Installable *bool
Jiyong Park1be96912018-05-28 18:02:19 +09002454
2455 // List of shared java libs that this module has dependencies to
2456 Libs []string
Colin Cross37f6d792018-07-12 12:28:41 -07002457
2458 // List of files to remove from the jar file(s)
2459 Exclude_files []string
2460
2461 // List of directories to remove from the jar file(s)
2462 Exclude_dirs []string
Nan Zhang4c819fb2018-08-27 18:31:46 -07002463
2464 // if set to true, run Jetifier against .jar file. Defaults to false.
Colin Cross1001a792019-03-21 22:21:39 -07002465 Jetifier *bool
Jiyong Park4c4c0242019-10-21 14:53:15 +09002466
2467 // set the name of the output
2468 Stem *string
Colin Cross74d73e22017-08-02 11:05:49 -07002469}
2470
2471type Import struct {
Colin Cross635c3b02016-05-18 15:37:25 -07002472 android.ModuleBase
Colin Cross48de9a42018-10-02 13:53:33 -07002473 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002474 android.ApexModuleBase
Colin Crossec7a0422017-07-07 14:47:12 -07002475 prebuilt android.Prebuilt
Jiyong Parkd1063c12019-07-17 20:08:41 +09002476 android.SdkBase
Colin Cross2fe66872015-03-30 17:20:39 -07002477
Paul Duffinc8f2f182020-05-17 08:34:50 +01002478 // Functionality common to Module and Import.
2479 embeddableInModuleAndImport
2480
Colin Cross74d73e22017-08-02 11:05:49 -07002481 properties ImportProperties
2482
Colin Cross0a6e0072017-08-30 14:24:55 -07002483 combinedClasspathFile android.Path
Jiyong Park1be96912018-05-28 18:02:19 +09002484 exportedSdkLibs []string
Colin Cross2fe66872015-03-30 17:20:39 -07002485}
2486
Jiyong Park6a927c42020-01-21 02:03:43 +09002487func (j *Import) sdkVersion() sdkSpec {
2488 return sdkSpecFrom(String(j.properties.Sdk_version))
Colin Cross83bb3162018-06-25 15:48:06 -07002489}
2490
Jiyong Park6a927c42020-01-21 02:03:43 +09002491func (j *Import) minSdkVersion() sdkSpec {
Colin Cross83bb3162018-06-25 15:48:06 -07002492 return j.sdkVersion()
2493}
2494
Artur Satayev388d39b2020-04-27 18:53:18 +01002495func (j *Import) MinSdkVersion() string {
2496 return j.minSdkVersion().version.String()
2497}
2498
Colin Cross74d73e22017-08-02 11:05:49 -07002499func (j *Import) Prebuilt() *android.Prebuilt {
Colin Crossec7a0422017-07-07 14:47:12 -07002500 return &j.prebuilt
2501}
2502
Colin Cross74d73e22017-08-02 11:05:49 -07002503func (j *Import) PrebuiltSrcs() []string {
2504 return j.properties.Jars
2505}
2506
2507func (j *Import) Name() string {
Colin Cross5ea9bcc2017-07-27 15:41:32 -07002508 return j.prebuilt.Name(j.ModuleBase.Name())
2509}
2510
Jiyong Park0b238752019-10-29 11:23:10 +09002511func (j *Import) Stem() string {
2512 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
2513}
2514
Jiyong Park618922e2020-01-08 13:35:43 +09002515func (a *Import) JacocoReportClassesFile() android.Path {
2516 return nil
2517}
2518
Colin Cross74d73e22017-08-02 11:05:49 -07002519func (j *Import) DepsMutator(ctx android.BottomUpMutatorContext) {
Colin Cross42d48b72018-08-29 14:10:52 -07002520 ctx.AddVariationDependencies(nil, libTag, j.properties.Libs...)
Colin Cross1e676be2016-10-12 14:38:15 -07002521}
2522
Colin Cross74d73e22017-08-02 11:05:49 -07002523func (j *Import) GenerateAndroidBuildActions(ctx android.ModuleContext) {
Colin Cross8a497952019-03-05 22:25:09 -08002524 jars := android.PathsForModuleSrc(ctx, j.properties.Jars)
Colin Crosse1d62a82015-04-03 16:53:05 -07002525
Jiyong Park0b238752019-10-29 11:23:10 +09002526 jarName := j.Stem() + ".jar"
Nan Zhang4c819fb2018-08-27 18:31:46 -07002527 outputFile := android.PathForModuleOut(ctx, "combined", jarName)
Colin Cross37f6d792018-07-12 12:28:41 -07002528 TransformJarsToJar(ctx, outputFile, "for prebuilts", jars, android.OptionalPath{},
2529 false, j.properties.Exclude_files, j.properties.Exclude_dirs)
Colin Cross1001a792019-03-21 22:21:39 -07002530 if Bool(j.properties.Jetifier) {
Nan Zhang4c819fb2018-08-27 18:31:46 -07002531 inputFile := outputFile
2532 outputFile = android.PathForModuleOut(ctx, "jetifier", jarName)
2533 TransformJetifier(ctx, outputFile, inputFile)
2534 }
Colin Crosse9a275b2017-10-16 17:09:48 -07002535 j.combinedClasspathFile = outputFile
Jiyong Park1be96912018-05-28 18:02:19 +09002536
Paul Duffin64e61992020-05-15 10:20:31 +01002537 // If this is a component library (impl, stubs, etc.) for a java_sdk_library then
2538 // add the name of that java_sdk_library to the exported sdk libs to make sure
2539 // that, if necessary, a <uses-library> element for that java_sdk_library is
2540 // added to the Android manifest.
2541 j.exportedSdkLibs = append(j.exportedSdkLibs, j.OptionalImplicitSdkLibrary()...)
2542
Jiyong Park1be96912018-05-28 18:02:19 +09002543 ctx.VisitDirectDeps(func(module android.Module) {
2544 otherName := ctx.OtherModuleName(module)
2545 tag := ctx.OtherModuleDependencyTag(module)
2546
2547 switch dep := module.(type) {
2548 case Dependency:
2549 switch tag {
2550 case libTag, staticLibTag:
2551 // sdk lib names from dependencies are re-exported
2552 j.exportedSdkLibs = append(j.exportedSdkLibs, dep.ExportedSdkLibs()...)
2553 }
2554 case SdkLibraryDependency:
2555 switch tag {
2556 case libTag:
2557 // names of sdk libs that are directly depended are exported
2558 j.exportedSdkLibs = append(j.exportedSdkLibs, otherName)
2559 }
2560 }
2561 })
2562
2563 j.exportedSdkLibs = android.FirstUniqueStrings(j.exportedSdkLibs)
Nan Zhang4973ecf2018-08-10 13:42:12 -07002564 if Bool(j.properties.Installable) {
2565 ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
Jiyong Park4c4c0242019-10-21 14:53:15 +09002566 jarName, outputFile)
Nan Zhang4973ecf2018-08-10 13:42:12 -07002567 }
Colin Cross2fe66872015-03-30 17:20:39 -07002568}
2569
Colin Cross74d73e22017-08-02 11:05:49 -07002570var _ Dependency = (*Import)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07002571
Nan Zhanged19fc32017-10-19 13:06:22 -07002572func (j *Import) HeaderJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08002573 if j.combinedClasspathFile == nil {
2574 return nil
2575 }
Colin Cross37f6d792018-07-12 12:28:41 -07002576 return android.Paths{j.combinedClasspathFile}
Nan Zhanged19fc32017-10-19 13:06:22 -07002577}
2578
2579func (j *Import) ImplementationJars() android.Paths {
shinwang9e4c07a2018-12-24 15:41:04 +08002580 if j.combinedClasspathFile == nil {
2581 return nil
2582 }
Colin Cross37f6d792018-07-12 12:28:41 -07002583 return android.Paths{j.combinedClasspathFile}
Colin Cross2fe66872015-03-30 17:20:39 -07002584}
2585
Colin Cross331a1212018-08-15 20:40:52 -07002586func (j *Import) ResourceJars() android.Paths {
2587 return nil
2588}
2589
2590func (j *Import) ImplementationAndResourcesJars() android.Paths {
albaltai36ff7dc2018-12-25 14:35:23 +08002591 if j.combinedClasspathFile == nil {
2592 return nil
2593 }
Colin Cross331a1212018-08-15 20:40:52 -07002594 return android.Paths{j.combinedClasspathFile}
2595}
2596
Colin Crossf24a22a2019-01-31 14:12:44 -08002597func (j *Import) DexJar() android.Path {
2598 return nil
2599}
2600
Colin Cross74d73e22017-08-02 11:05:49 -07002601func (j *Import) AidlIncludeDirs() android.Paths {
Colin Crossc0b06f12015-04-08 13:03:43 -07002602 return nil
2603}
2604
Jiyong Park1be96912018-05-28 18:02:19 +09002605func (j *Import) ExportedSdkLibs() []string {
2606 return j.exportedSdkLibs
2607}
2608
Artur Satayev9cf46692019-11-26 18:08:34 +00002609func (j *Import) ExportedPlugins() (android.Paths, []string) {
2610 return nil, nil
2611}
2612
Colin Cross0c4ce212019-05-03 15:28:19 -07002613func (j *Import) SrcJarArgs() ([]string, android.Paths) {
2614 return nil, nil
2615}
2616
Jiyong Park0f80c182020-01-31 02:49:53 +09002617func (j *Import) DepIsInSameApex(ctx android.BaseModuleContext, dep android.Module) bool {
Paul Duffinc8f2f182020-05-17 08:34:50 +01002618 return j.depIsInSameApex(ctx, dep)
Jiyong Park0f80c182020-01-31 02:49:53 +09002619}
2620
albaltai36ff7dc2018-12-25 14:35:23 +08002621// Add compile time check for interface implementation
2622var _ android.IDEInfo = (*Import)(nil)
2623var _ android.IDECustomizedModuleName = (*Import)(nil)
2624
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002625// Collect information for opening IDE project files in java/jdeps.go.
2626const (
2627 removedPrefix = "prebuilt_"
2628)
2629
2630func (j *Import) IDEInfo(dpInfo *android.IdeInfo) {
2631 dpInfo.Jars = append(dpInfo.Jars, j.PrebuiltSrcs()...)
2632}
2633
2634func (j *Import) IDECustomizedModuleName() string {
2635 // TODO(b/113562217): Extract the base module name from the Import name, often the Import name
2636 // has a prefix "prebuilt_". Remove the prefix explicitly if needed until we find a better
2637 // solution to get the Import name.
2638 name := j.Name()
2639 if strings.HasPrefix(name, removedPrefix) {
patricktubb640e02018-10-11 18:33:16 +08002640 name = strings.TrimPrefix(name, removedPrefix)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002641 }
2642 return name
2643}
2644
Colin Cross74d73e22017-08-02 11:05:49 -07002645var _ android.PrebuiltInterface = (*Import)(nil)
Colin Cross2fe66872015-03-30 17:20:39 -07002646
Colin Cross1b16b0e2019-02-12 14:41:32 -08002647// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library module.
2648//
2649// By default, a java_import has a single variant that expects a `.jar` file containing `.class` files that were
2650// compiled against an Android classpath.
2651//
2652// Specifying `host_supported: true` will produce two variants, one for use as a dependency of device modules and one
2653// for host modules.
Colin Cross74d73e22017-08-02 11:05:49 -07002654func ImportFactory() android.Module {
2655 module := &Import{}
Colin Cross36242852017-06-23 15:06:31 -07002656
Colin Cross74d73e22017-08-02 11:05:49 -07002657 module.AddProperties(&module.properties)
2658
Paul Duffin64e61992020-05-15 10:20:31 +01002659 module.initModuleAndImport(&module.ModuleBase)
2660
Colin Cross74d73e22017-08-02 11:05:49 -07002661 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002662 android.InitApexModule(module)
Jiyong Parkd1063c12019-07-17 20:08:41 +09002663 android.InitSdkAwareModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002664 InitJavaModule(module, android.HostAndDeviceSupported)
Colin Cross36242852017-06-23 15:06:31 -07002665 return module
Colin Cross2fe66872015-03-30 17:20:39 -07002666}
2667
Colin Cross1b16b0e2019-02-12 14:41:32 -08002668// java_import imports one or more `.jar` files into the build graph as if they were built by a java_library_host
2669// module.
2670//
2671// A java_import_host has a single variant that expects a `.jar` file containing `.class` files that were
2672// compiled against a host bootclasspath.
Colin Cross74d73e22017-08-02 11:05:49 -07002673func ImportFactoryHost() android.Module {
2674 module := &Import{}
2675
2676 module.AddProperties(&module.properties)
2677
2678 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002679 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002680 InitJavaModule(module, android.HostSupported)
Colin Cross74d73e22017-08-02 11:05:49 -07002681 return module
2682}
2683
Colin Cross42be7612019-02-21 18:12:14 -08002684// dex_import module
2685
2686type DexImportProperties struct {
Colin Cross5cfc70d2019-07-15 13:36:55 -07002687 Jars []string `android:"path"`
Jiyong Park4c4c0242019-10-21 14:53:15 +09002688
2689 // set the name of the output
2690 Stem *string
Colin Cross42be7612019-02-21 18:12:14 -08002691}
2692
2693type DexImport struct {
2694 android.ModuleBase
2695 android.DefaultableModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002696 android.ApexModuleBase
Colin Cross42be7612019-02-21 18:12:14 -08002697 prebuilt android.Prebuilt
2698
2699 properties DexImportProperties
2700
2701 dexJarFile android.Path
2702 maybeStrippedDexJarFile android.Path
2703
2704 dexpreopter
2705}
2706
2707func (j *DexImport) Prebuilt() *android.Prebuilt {
2708 return &j.prebuilt
2709}
2710
2711func (j *DexImport) PrebuiltSrcs() []string {
2712 return j.properties.Jars
2713}
2714
2715func (j *DexImport) Name() string {
2716 return j.prebuilt.Name(j.ModuleBase.Name())
2717}
2718
Jiyong Park0b238752019-10-29 11:23:10 +09002719func (j *DexImport) Stem() string {
2720 return proptools.StringDefault(j.properties.Stem, j.ModuleBase.Name())
2721}
2722
Jiyong Park2cd081c2020-06-01 21:39:15 +09002723func (a *DexImport) JacocoReportClassesFile() android.Path {
2724 return nil
2725}
2726
Martin Stjernholm6d415272020-01-31 17:10:36 +00002727func (j *DexImport) IsInstallable() bool {
2728 return true
2729}
2730
Colin Cross42be7612019-02-21 18:12:14 -08002731func (j *DexImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
2732 if len(j.properties.Jars) != 1 {
2733 ctx.PropertyErrorf("jars", "exactly one jar must be provided")
2734 }
2735
Jiyong Park0b238752019-10-29 11:23:10 +09002736 j.dexpreopter.installPath = android.PathForModuleInstall(ctx, "framework", j.Stem()+".jar")
Colin Cross42be7612019-02-21 18:12:14 -08002737 j.dexpreopter.uncompressedDex = shouldUncompressDex(ctx, &j.dexpreopter)
2738
2739 inputJar := ctx.ExpandSource(j.properties.Jars[0], "jars")
2740 dexOutputFile := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar")
2741
2742 if j.dexpreopter.uncompressedDex {
2743 rule := android.NewRuleBuilder()
2744
2745 temporary := android.PathForModuleOut(ctx, ctx.ModuleName()+".jar.unaligned")
2746 rule.Temporary(temporary)
2747
2748 // use zip2zip to uncompress classes*.dex files
2749 rule.Command().
Colin Crossee94d6a2019-07-08 17:08:34 -07002750 BuiltTool(ctx, "zip2zip").
Colin Cross42be7612019-02-21 18:12:14 -08002751 FlagWithInput("-i ", inputJar).
2752 FlagWithOutput("-o ", temporary).
2753 FlagWithArg("-0 ", "'classes*.dex'")
2754
2755 // use zipalign to align uncompressed classes*.dex files
2756 rule.Command().
Colin Crossee94d6a2019-07-08 17:08:34 -07002757 BuiltTool(ctx, "zipalign").
Colin Cross42be7612019-02-21 18:12:14 -08002758 Flag("-f").
2759 Text("4").
2760 Input(temporary).
2761 Output(dexOutputFile)
2762
2763 rule.DeleteTemporaryFiles()
2764
2765 rule.Build(pctx, ctx, "uncompress_dex", "uncompress dex")
2766 } else {
2767 ctx.Build(pctx, android.BuildParams{
2768 Rule: android.Cp,
2769 Input: inputJar,
2770 Output: dexOutputFile,
2771 })
2772 }
2773
2774 j.dexJarFile = dexOutputFile
2775
2776 dexOutputFile = j.dexpreopt(ctx, dexOutputFile)
2777
2778 j.maybeStrippedDexJarFile = dexOutputFile
2779
Jiyong Parkafd3d112020-06-08 19:24:09 +09002780 if j.IsForPlatform() {
2781 ctx.InstallFile(android.PathForModuleInstall(ctx, "framework"),
2782 j.Stem()+".jar", dexOutputFile)
2783 }
Colin Cross42be7612019-02-21 18:12:14 -08002784}
2785
2786func (j *DexImport) DexJar() android.Path {
2787 return j.dexJarFile
2788}
2789
2790// dex_import imports a `.jar` file containing classes.dex files.
2791//
2792// A dex_import module cannot be used as a dependency of a java_* or android_* module, it can only be installed
2793// to the device.
2794func DexImportFactory() android.Module {
2795 module := &DexImport{}
2796
2797 module.AddProperties(&module.properties)
2798
2799 android.InitPrebuiltModule(module, &module.properties.Jars)
Jiyong Park7f7766d2019-07-25 22:02:35 +09002800 android.InitApexModule(module)
Jooyung Han18020ea2019-11-13 10:50:48 +09002801 InitJavaModule(module, android.DeviceSupported)
Colin Cross42be7612019-02-21 18:12:14 -08002802 return module
2803}
2804
Colin Cross89536d42017-07-07 14:35:50 -07002805//
2806// Defaults
2807//
2808type Defaults struct {
2809 android.ModuleBase
2810 android.DefaultsModuleBase
Jiyong Park7f7766d2019-07-25 22:02:35 +09002811 android.ApexModuleBase
Colin Cross89536d42017-07-07 14:35:50 -07002812}
2813
Colin Cross1b16b0e2019-02-12 14:41:32 -08002814// java_defaults provides a set of properties that can be inherited by other java or android modules.
2815//
2816// A module can use the properties from a java_defaults module using `defaults: ["defaults_module_name"]`. Each
2817// property in the defaults module that exists in the depending module will be prepended to the depending module's
2818// value for that property.
2819//
2820// Example:
2821//
2822// java_defaults {
2823// name: "example_defaults",
2824// srcs: ["common/**/*.java"],
2825// javacflags: ["-Xlint:all"],
2826// aaptflags: ["--auto-add-overlay"],
2827// }
2828//
2829// java_library {
2830// name: "example",
2831// defaults: ["example_defaults"],
2832// srcs: ["example/**/*.java"],
2833// }
2834//
2835// is functionally identical to:
2836//
2837// java_library {
2838// name: "example",
2839// srcs: [
2840// "common/**/*.java",
2841// "example/**/*.java",
2842// ],
2843// javacflags: ["-Xlint:all"],
2844// }
Colin Cross89536d42017-07-07 14:35:50 -07002845func defaultsFactory() android.Module {
2846 return DefaultsFactory()
2847}
2848
Paul Duffin47357662019-12-05 14:07:14 +00002849func DefaultsFactory() android.Module {
Colin Cross89536d42017-07-07 14:35:50 -07002850 module := &Defaults{}
2851
Colin Cross89536d42017-07-07 14:35:50 -07002852 module.AddProperties(
2853 &CompilerProperties{},
2854 &CompilerDeviceProperties{},
Colin Cross43f08db2018-11-12 10:13:39 -08002855 &DexpreoptProperties{},
Dan Willemsen6424d172018-03-08 13:27:59 -08002856 &android.ProtoProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002857 &aaptProperties{},
2858 &androidLibraryProperties{},
2859 &appProperties{},
2860 &appTestProperties{},
Jaewoong Jung525443a2019-02-28 15:35:54 -08002861 &overridableAppProperties{},
Colin Cross48de9a42018-10-02 13:53:33 -07002862 &ImportProperties{},
2863 &AARImportProperties{},
2864 &sdkLibraryProperties{},
Paul Duffin1a724e62020-05-08 13:44:43 +01002865 &commonToSdkLibraryAndImportProperties{},
Colin Cross42be7612019-02-21 18:12:14 -08002866 &DexImportProperties{},
Jooyung Han18020ea2019-11-13 10:50:48 +09002867 &android.ApexProperties{},
Jaewoong Jung062ed7e2020-04-26 15:10:51 -07002868 &RuntimeResourceOverlayProperties{},
Colin Cross1e28e3c2020-06-02 20:09:13 -07002869 &LintProperties{},
Colin Cross89536d42017-07-07 14:35:50 -07002870 )
2871
2872 android.InitDefaultsModule(module)
Colin Cross89536d42017-07-07 14:35:50 -07002873 return module
2874}
Nan Zhangea568a42017-11-08 21:20:04 -08002875
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002876func kytheExtractJavaFactory() android.Singleton {
2877 return &kytheExtractJavaSingleton{}
2878}
2879
2880type kytheExtractJavaSingleton struct {
2881}
2882
2883func (ks *kytheExtractJavaSingleton) GenerateBuildActions(ctx android.SingletonContext) {
2884 var xrefTargets android.Paths
2885 ctx.VisitAllModules(func(module android.Module) {
2886 if javaModule, ok := module.(xref); ok {
2887 xrefTargets = append(xrefTargets, javaModule.XrefJavaFiles()...)
2888 }
2889 })
2890 // TODO(asmundak): perhaps emit a rule to output a warning if there were no xrefTargets
2891 if len(xrefTargets) > 0 {
Colin Cross98552072020-06-04 13:25:17 -07002892 ctx.Phony("xref_java", xrefTargets...)
Sasha Smundak2a4549e2018-11-05 16:49:08 -08002893 }
2894}
2895
Nan Zhangea568a42017-11-08 21:20:04 -08002896var Bool = proptools.Bool
Colin Cross38b40df2018-04-10 16:14:46 -07002897var BoolDefault = proptools.BoolDefault
Nan Zhangea568a42017-11-08 21:20:04 -08002898var String = proptools.String
Colin Cross0d0ba592018-02-20 13:33:42 -08002899var inList = android.InList