blob: 5bab6e44286b99914ec437fa5d63e874de23b361 [file] [log] [blame]
Colin Cross3f40fa42015-01-30 17:27:36 -08001// 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
Colin Cross635c3b02016-05-18 15:37:25 -070015package android
Colin Cross3f40fa42015-01-30 17:27:36 -080016
17import (
Colin Cross6ff51382015-12-17 16:39:19 -080018 "fmt"
Bob Badour4101c712022-02-09 11:54:35 -080019 "net/url"
Colin Cross3f40fa42015-01-30 17:27:36 -080020 "path/filepath"
Liz Kammer9525e712022-01-05 13:46:24 -050021 "reflect"
Colin Crossd6fd0132023-11-06 13:54:06 -080022 "slices"
Bob Badour4101c712022-02-09 11:54:35 -080023 "sort"
Colin Cross6ff51382015-12-17 16:39:19 -080024 "strings"
Tahsin Loqman77dc7d02022-12-19 16:27:25 +000025
Colin Crossf6566ed2015-03-24 11:13:38 -070026 "github.com/google/blueprint"
Colin Crossfe4bc362018-09-12 10:02:13 -070027 "github.com/google/blueprint/proptools"
Colin Cross3f40fa42015-01-30 17:27:36 -080028)
29
30var (
31 DeviceSharedLibrary = "shared_library"
32 DeviceStaticLibrary = "static_library"
Joe Onorato349ae8d2024-02-05 22:46:00 +000033 jarJarPrefixHandler func(ctx ModuleContext)
Colin Cross3f40fa42015-01-30 17:27:36 -080034)
35
Colin Cross635c3b02016-05-18 15:37:25 -070036type Module interface {
Colin Cross3f40fa42015-01-30 17:27:36 -080037 blueprint.Module
38
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070039 // GenerateAndroidBuildActions is analogous to Blueprints' GenerateBuildActions,
40 // but GenerateAndroidBuildActions also has access to Android-specific information.
41 // For more information, see Module.GenerateBuildActions within Blueprint's module_ctx.go
Colin Cross635c3b02016-05-18 15:37:25 -070042 GenerateAndroidBuildActions(ModuleContext)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070043
Paul Duffin44f1d842020-06-26 20:17:02 +010044 // Add dependencies to the components of a module, i.e. modules that are created
45 // by the module and which are considered to be part of the creating module.
46 //
47 // This is called before prebuilts are renamed so as to allow a dependency to be
48 // added directly to a prebuilt child module instead of depending on a source module
49 // and relying on prebuilt processing to switch to the prebuilt module if preferred.
50 //
51 // A dependency on a prebuilt must include the "prebuilt_" prefix.
52 ComponentDepsMutator(ctx BottomUpMutatorContext)
53
Colin Cross1e676be2016-10-12 14:38:15 -070054 DepsMutator(BottomUpMutatorContext)
Colin Cross3f40fa42015-01-30 17:27:36 -080055
Colin Cross635c3b02016-05-18 15:37:25 -070056 base() *ModuleBase
Inseob Kimeec88e12020-01-22 11:11:29 +090057 Disable()
Cole Fausta963b942024-04-11 17:43:00 -070058 Enabled(ctx ConfigAndErrorContext) bool
Colin Crossa1ad8d12016-06-01 17:09:44 -070059 Target() Target
Paul Duffinc04fb9e2021-03-01 12:25:10 +000060 MultiTargets() []Target
Paul Duffinb42fa672021-09-09 16:37:49 +010061
62 // ImageVariation returns the image variation of this module.
63 //
64 // The returned structure has its Mutator field set to "image" and its Variation field set to the
65 // image variation, e.g. recovery, ramdisk, etc.. The Variation field is "" for host modules and
66 // device modules that have no image variation.
67 ImageVariation() blueprint.Variation
68
Anton Hansson1ee62c02020-06-30 11:51:53 +010069 Owner() string
Dan Willemsen782a2d12015-12-21 14:55:28 -080070 InstallInData() bool
Jaewoong Jung0949f312019-09-11 10:25:18 -070071 InstallInTestcases() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -070072 InstallInSanitizerDir() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -080073 InstallInRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -070074 InstallInVendorRamdisk() bool
Inseob Kim08758f02021-04-08 21:13:22 +090075 InstallInDebugRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +090076 InstallInRecovery() bool
Colin Cross90ba5f42019-10-02 11:10:58 -070077 InstallInRoot() bool
Colin Crossea30d852023-11-29 16:00:16 -080078 InstallInOdm() bool
79 InstallInProduct() bool
Kiyoung Kimae11c232021-07-19 11:38:04 +090080 InstallInVendor() bool
Jiyong Park87788b52020-09-01 12:37:45 +090081 InstallForceOS() (*OsType, *ArchType)
Jiyong Parkce243632023-02-17 18:22:25 +090082 PartitionTag(DeviceConfig) string
Colin Crossa9c8c9f2020-12-16 10:20:23 -080083 HideFromMake()
84 IsHideFromMake() bool
Martin Stjernholm9e7f45e2020-12-23 03:50:30 +000085 IsSkipInstall() bool
Iván Budnik295da162023-03-10 16:11:26 +000086 MakeUninstallable()
Liz Kammer5ca3a622020-08-05 15:40:41 -070087 ReplacedByPrebuilt()
88 IsReplacedByPrebuilt() bool
Jiyong Park374510b2018-03-19 18:23:01 +090089 ExportedToMake() bool
Inseob Kim8471cda2019-11-15 09:59:12 +090090 InitRc() Paths
91 VintfFragments() Paths
Justin Yun1871f902023-04-07 20:13:19 +090092 EffectiveLicenseKinds() []string
Justin Yun885a7de2021-06-29 20:34:53 +090093 EffectiveLicenseFiles() Paths
Colin Cross36242852017-06-23 15:06:31 -070094
95 AddProperties(props ...interface{})
96 GetProperties() []interface{}
Colin Crosscec81712017-07-13 14:43:27 -070097
Colin Crossae887032017-10-23 17:16:14 -070098 BuildParamsForTests() []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -080099 RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800100 VariablesForTests() map[string]string
Paul Duffine2453c72019-05-31 14:00:04 +0100101
Colin Cross9a362232019-07-01 15:32:45 -0700102 // String returns a string that includes the module name and variants for printing during debugging.
103 String() string
104
Paul Duffine2453c72019-05-31 14:00:04 +0100105 // Get the qualified module id for this module.
106 qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName
107
108 // Get information about the properties that can contain visibility rules.
109 visibilityProperties() []visibilityProperty
Paul Duffin63c6e182019-07-24 14:24:38 +0100110
Cole Faust43ddd082024-06-17 12:32:40 -0700111 RequiredModuleNames(ctx ConfigAndErrorContext) []string
Jiyong Park6a8cf5f2019-12-30 16:31:09 +0900112 HostRequiredModuleNames() []string
113 TargetRequiredModuleNames() []string
Colin Cross897266e2020-02-13 13:22:08 -0800114
Jiyong Park4dc2a1a2020-09-28 17:46:22 +0900115 FilesToInstall() InstallPaths
Jiyong Park073ea552020-11-09 14:08:34 +0900116 PackagingSpecs() []PackagingSpec
Colin Crossffe6b9d2020-12-01 15:40:06 -0800117
118 // TransitivePackagingSpecs returns the PackagingSpecs for this module and any transitive
119 // dependencies with dependency tags for which IsInstallDepNeeded() returns true.
120 TransitivePackagingSpecs() []PackagingSpec
Cole Faust02987bd2024-03-21 17:58:43 -0700121
122 ConfigurableEvaluator(ctx ConfigAndErrorContext) proptools.ConfigurableEvaluator
Paul Duffine2453c72019-05-31 14:00:04 +0100123}
124
125// Qualified id for a module
126type qualifiedModuleName struct {
127 // The package (i.e. directory) in which the module is defined, without trailing /
128 pkg string
129
130 // The name of the module, empty string if package.
131 name string
132}
133
134func (q qualifiedModuleName) String() string {
135 if q.name == "" {
136 return "//" + q.pkg
137 }
138 return "//" + q.pkg + ":" + q.name
139}
140
Paul Duffine484f472019-06-20 16:38:08 +0100141func (q qualifiedModuleName) isRootPackage() bool {
142 return q.pkg == "" && q.name == ""
143}
144
Paul Duffine2453c72019-05-31 14:00:04 +0100145// Get the id for the package containing this module.
146func (q qualifiedModuleName) getContainingPackageId() qualifiedModuleName {
147 pkg := q.pkg
148 if q.name == "" {
Paul Duffine484f472019-06-20 16:38:08 +0100149 if pkg == "" {
150 panic(fmt.Errorf("Cannot get containing package id of root package"))
151 }
152
153 index := strings.LastIndex(pkg, "/")
154 if index == -1 {
155 pkg = ""
156 } else {
157 pkg = pkg[:index]
158 }
Paul Duffine2453c72019-05-31 14:00:04 +0100159 }
160 return newPackageId(pkg)
161}
162
163func newPackageId(pkg string) qualifiedModuleName {
164 // A qualified id for a package module has no name.
165 return qualifiedModuleName{pkg: pkg, name: ""}
Colin Cross3f40fa42015-01-30 17:27:36 -0800166}
167
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000168type Dist struct {
169 // Copy the output of this module to the $DIST_DIR when `dist` is specified on the
170 // command line and any of these targets are also on the command line, or otherwise
171 // built
172 Targets []string `android:"arch_variant"`
173
174 // The name of the output artifact. This defaults to the basename of the output of
175 // the module.
176 Dest *string `android:"arch_variant"`
177
178 // The directory within the dist directory to store the artifact. Defaults to the
179 // top level directory ("").
180 Dir *string `android:"arch_variant"`
181
182 // A suffix to add to the artifact file name (before any extension).
183 Suffix *string `android:"arch_variant"`
184
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000185 // If true, then the artifact file will be appended with _<product name>. For
186 // example, if the product is coral and the module is an android_app module
187 // of name foo, then the artifact would be foo_coral.apk. If false, there is
188 // no change to the artifact file name.
189 Append_artifact_with_product *bool `android:"arch_variant"`
190
Paul Duffin74f05592020-11-25 16:37:46 +0000191 // A string tag to select the OutputFiles associated with the tag.
192 //
193 // If no tag is specified then it will select the default dist paths provided
194 // by the module type. If a tag of "" is specified then it will return the
195 // default output files provided by the modules, i.e. the result of calling
196 // OutputFiles("").
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000197 Tag *string `android:"arch_variant"`
198}
199
Bob Badour4101c712022-02-09 11:54:35 -0800200// NamedPath associates a path with a name. e.g. a license text path with a package name
201type NamedPath struct {
202 Path Path
203 Name string
204}
205
206// String returns an escaped string representing the `NamedPath`.
207func (p NamedPath) String() string {
208 if len(p.Name) > 0 {
209 return p.Path.String() + ":" + url.QueryEscape(p.Name)
210 }
211 return p.Path.String()
212}
213
214// NamedPaths describes a list of paths each associated with a name.
215type NamedPaths []NamedPath
216
217// Strings returns a list of escaped strings representing each `NamedPath` in the list.
218func (l NamedPaths) Strings() []string {
219 result := make([]string, 0, len(l))
220 for _, p := range l {
221 result = append(result, p.String())
222 }
223 return result
224}
225
226// SortedUniqueNamedPaths modifies `l` in place to return the sorted unique subset.
227func SortedUniqueNamedPaths(l NamedPaths) NamedPaths {
228 if len(l) == 0 {
229 return l
230 }
231 sort.Slice(l, func(i, j int) bool {
232 return l[i].String() < l[j].String()
233 })
234 k := 0
235 for i := 1; i < len(l); i++ {
236 if l[i].String() == l[k].String() {
237 continue
238 }
239 k++
240 if k < i {
241 l[k] = l[i]
242 }
243 }
244 return l[:k+1]
245}
246
Colin Crossfc754582016-05-17 16:34:16 -0700247type nameProperties struct {
248 // The name of the module. Must be unique across all modules.
Nan Zhang0007d812017-11-07 10:57:05 -0800249 Name *string
Colin Crossfc754582016-05-17 16:34:16 -0700250}
251
Colin Cross08d6f8f2020-11-19 02:33:19 +0000252type commonProperties struct {
Dan Willemsen0effe062015-11-30 16:06:01 -0800253 // emit build rules for this module
Paul Duffin54d9bb72020-02-12 10:20:56 +0000254 //
255 // Disabling a module should only be done for those modules that cannot be built
256 // in the current environment. Modules that can build in the current environment
257 // but are not usually required (e.g. superceded by a prebuilt) should not be
258 // disabled as that will prevent them from being built by the checkbuild target
259 // and so prevent early detection of changes that have broken those modules.
Cole Fausta963b942024-04-11 17:43:00 -0700260 Enabled proptools.Configurable[bool] `android:"arch_variant,replace_instead_of_append"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800261
Paul Duffin2e61fa62019-03-28 14:10:57 +0000262 // Controls the visibility of this module to other modules. Allowable values are one or more of
263 // these formats:
264 //
265 // ["//visibility:public"]: Anyone can use this module.
266 // ["//visibility:private"]: Only rules in the module's package (not its subpackages) can use
267 // this module.
Paul Duffin51084ff2020-05-05 19:19:22 +0100268 // ["//visibility:override"]: Discards any rules inherited from defaults or a creating module.
269 // Can only be used at the beginning of a list of visibility rules.
Paul Duffin2e61fa62019-03-28 14:10:57 +0000270 // ["//some/package:__pkg__", "//other/package:__pkg__"]: Only modules in some/package and
271 // other/package (defined in some/package/*.bp and other/package/*.bp) have access to
272 // this module. Note that sub-packages do not have access to the rule; for example,
273 // //some/package/foo:bar or //other/package/testing:bla wouldn't have access. __pkg__
274 // is a special module and must be used verbatim. It represents all of the modules in the
275 // package.
276 // ["//project:__subpackages__", "//other:__subpackages__"]: Only modules in packages project
277 // or other or in one of their sub-packages have access to this module. For example,
278 // //project:rule, //project/library:lib or //other/testing/internal:munge are allowed
279 // to depend on this rule (but not //independent:evil)
280 // ["//project"]: This is shorthand for ["//project:__pkg__"]
281 // [":__subpackages__"]: This is shorthand for ["//project:__subpackages__"] where
282 // //project is the module's package. e.g. using [":__subpackages__"] in
283 // packages/apps/Settings/Android.bp is equivalent to
284 // //packages/apps/Settings:__subpackages__.
285 // ["//visibility:legacy_public"]: The default visibility, behaves as //visibility:public
286 // for now. It is an error if it is used in a module.
Paul Duffine2453c72019-05-31 14:00:04 +0100287 //
288 // If a module does not specify the `visibility` property then it uses the
289 // `default_visibility` property of the `package` module in the module's package.
290 //
291 // If the `default_visibility` property is not set for the module's package then
Paul Duffine484f472019-06-20 16:38:08 +0100292 // it will use the `default_visibility` of its closest ancestor package for which
293 // a `default_visibility` property is specified.
294 //
295 // If no `default_visibility` property can be found then the module uses the
296 // global default of `//visibility:legacy_public`.
Paul Duffine2453c72019-05-31 14:00:04 +0100297 //
Paul Duffin95d53b52019-07-24 13:45:05 +0100298 // The `visibility` property has no effect on a defaults module although it does
299 // apply to any non-defaults module that uses it. To set the visibility of a
300 // defaults module, use the `defaults_visibility` property on the defaults module;
301 // not to be confused with the `default_visibility` property on the package module.
302 //
Elliott Hughes10363162024-01-09 22:02:03 +0000303 // See https://android.googlesource.com/platform/build/soong/+/main/README.md#visibility for
Paul Duffin2e61fa62019-03-28 14:10:57 +0000304 // more details.
305 Visibility []string
306
Bob Badour37af0462021-01-07 03:34:31 +0000307 // Describes the licenses applicable to this module. Must reference license modules.
308 Licenses []string
309
310 // Flattened from direct license dependencies. Equal to Licenses unless particular module adds more.
311 Effective_licenses []string `blueprint:"mutated"`
312 // Override of module name when reporting licenses
313 Effective_package_name *string `blueprint:"mutated"`
314 // Notice files
Bob Badour4101c712022-02-09 11:54:35 -0800315 Effective_license_text NamedPaths `blueprint:"mutated"`
Bob Badour37af0462021-01-07 03:34:31 +0000316 // License names
317 Effective_license_kinds []string `blueprint:"mutated"`
318 // License conditions
319 Effective_license_conditions []string `blueprint:"mutated"`
320
Colin Cross7d5136f2015-05-11 13:39:40 -0700321 // control whether this module compiles for 32-bit, 64-bit, or both. Possible values
Colin Cross3f40fa42015-01-30 17:27:36 -0800322 // are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
323 // architectures), or "first" (compile for 64-bit on a 64-bit platform, and 32-bit on a 32-bit
Roland Levillain24bb2e62020-09-22 11:18:38 +0000324 // platform).
Colin Cross7d716ba2017-11-01 10:38:29 -0700325 Compile_multilib *string `android:"arch_variant"`
Colin Cross69617d32016-09-06 10:39:07 -0700326
327 Target struct {
328 Host struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700329 Compile_multilib *string
Colin Cross69617d32016-09-06 10:39:07 -0700330 }
331 Android struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700332 Compile_multilib *string
Colin Cross69617d32016-09-06 10:39:07 -0700333 }
334 }
335
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000336 // If set to true then the archMutator will create variants for each arch specific target
337 // (e.g. 32/64) that the module is required to produce. If set to false then it will only
338 // create a variant for the architecture and will list the additional arch specific targets
339 // that the variant needs to produce in the CompileMultiTargets property.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700340 UseTargetVariants bool `blueprint:"mutated"`
341 Default_multilib string `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800342
Dan Willemsen782a2d12015-12-21 14:55:28 -0800343 // whether this is a proprietary vendor module, and should be installed into /vendor
Colin Cross7d716ba2017-11-01 10:38:29 -0700344 Proprietary *bool
Dan Willemsen782a2d12015-12-21 14:55:28 -0800345
Colin Cross55708f32017-03-20 13:23:34 -0700346 // vendor who owns this module
Dan Willemsenefac4a82017-07-18 19:42:09 -0700347 Owner *string
Colin Cross55708f32017-03-20 13:23:34 -0700348
Jiyong Park2db76922017-11-08 16:03:48 +0900349 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
350 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
351 // Use `soc_specific` instead for better meaning.
Colin Cross7d716ba2017-11-01 10:38:29 -0700352 Vendor *bool
Dan Willemsenaa118f92017-04-06 12:49:58 -0700353
Jiyong Park2db76922017-11-08 16:03:48 +0900354 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
355 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
356 Soc_specific *bool
357
358 // whether this module is specific to a device, not only for SoC, but also for off-chip
359 // peripherals. When set to true, it is installed into /odm (or /vendor/odm if odm partition
360 // does not exist, or /system/vendor/odm if both odm and vendor partitions do not exist).
361 // This implies `soc_specific:true`.
362 Device_specific *bool
363
364 // whether this module is specific to a software configuration of a product (e.g. country,
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +0900365 // network operator, etc). When set to true, it is installed into /product (or
366 // /system/product if product partition does not exist).
Jiyong Park2db76922017-11-08 16:03:48 +0900367 Product_specific *bool
368
Justin Yund5f6c822019-06-25 16:47:17 +0900369 // whether this module extends system. When set to true, it is installed into /system_ext
370 // (or /system/system_ext if system_ext partition does not exist).
371 System_ext_specific *bool
372
Jiyong Parkf9332f12018-02-01 00:54:12 +0900373 // Whether this module is installed to recovery partition
374 Recovery *bool
375
Yifan Hong1b3348d2020-01-21 15:53:22 -0800376 // Whether this module is installed to ramdisk
377 Ramdisk *bool
378
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700379 // Whether this module is installed to vendor ramdisk
380 Vendor_ramdisk *bool
381
Inseob Kim08758f02021-04-08 21:13:22 +0900382 // Whether this module is installed to debug ramdisk
383 Debug_ramdisk *bool
384
Jaewoong Jung8e93aba2021-03-02 16:58:08 -0800385 // Whether this module is built for non-native architectures (also known as native bridge binary)
dimitry1f33e402019-03-26 12:39:31 +0100386 Native_bridge_supported *bool `android:"arch_variant"`
387
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700388 // init.rc files to be installed if this module is installed
Colin Cross0bab8772020-09-25 14:01:21 -0700389 Init_rc []string `android:"arch_variant,path"`
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700390
Steven Moreland57a23d22018-04-04 15:42:19 -0700391 // VINTF manifest fragments to be installed if this module is installed
Colin Cross27b922f2019-03-04 22:35:41 -0800392 Vintf_fragments []string `android:"path"`
Steven Moreland57a23d22018-04-04 15:42:19 -0700393
Chris Wolfe998306e2016-08-15 14:47:23 -0400394 // names of other modules to install if this module is installed
Cole Faust43ddd082024-06-17 12:32:40 -0700395 Required proptools.Configurable[[]string] `android:"arch_variant"`
Chris Wolfe998306e2016-08-15 14:47:23 -0400396
Sasha Smundakb6d23052019-04-01 18:37:36 -0700397 // names of other modules to install on host if this module is installed
398 Host_required []string `android:"arch_variant"`
399
400 // names of other modules to install on target if this module is installed
401 Target_required []string `android:"arch_variant"`
402
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000403 // The OsType of artifacts that this module variant is responsible for creating.
404 //
405 // Set by osMutator
406 CompileOS OsType `blueprint:"mutated"`
407
Cole Faust0aa21cc2024-03-20 12:28:03 -0700408 // Set to true after the arch mutator has run on this module and set CompileTarget,
409 // CompileMultiTargets, and CompilePrimary
410 ArchReady bool `blueprint:"mutated"`
411
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000412 // The Target of artifacts that this module variant is responsible for creating.
413 //
414 // Set by archMutator
415 CompileTarget Target `blueprint:"mutated"`
416
417 // The additional arch specific targets (e.g. 32/64 bit) that this module variant is
418 // responsible for creating.
419 //
420 // By default this is nil as, where necessary, separate variants are created for the
421 // different multilib types supported and that information is encapsulated in the
422 // CompileTarget so the module variant simply needs to create artifacts for that.
423 //
424 // However, if UseTargetVariants is set to false (e.g. by
425 // InitAndroidMultiTargetsArchModule) then no separate variants are created for the
426 // multilib targets. Instead a single variant is created for the architecture and
427 // this contains the multilib specific targets that this variant should create.
428 //
429 // Set by archMutator
Colin Crossee0bc3b2018-10-02 22:01:37 -0700430 CompileMultiTargets []Target `blueprint:"mutated"`
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000431
432 // True if the module variant's CompileTarget is the primary target
433 //
434 // Set by archMutator
435 CompilePrimary bool `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800436
437 // Set by InitAndroidModule
438 HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
Dan Willemsen0b24c742016-10-04 15:13:37 -0700439 ArchSpecific bool `blueprint:"mutated"`
Colin Crossce75d2c2016-10-06 16:12:58 -0700440
Paul Duffin1356d8c2020-02-25 19:26:33 +0000441 // If set to true then a CommonOS variant will be created which will have dependencies
442 // on all its OsType specific variants. Used by sdk/module_exports to create a snapshot
443 // that covers all os and architecture variants.
444 //
445 // The OsType specific variants can be retrieved by calling
446 // GetOsSpecificVariantsOfCommonOSVariant
447 //
448 // Set at module initialization time by calling InitCommonOSAndroidMultiTargetsArchModule
449 CreateCommonOSVariant bool `blueprint:"mutated"`
450
451 // If set to true then this variant is the CommonOS variant that has dependencies on its
452 // OsType specific variants.
453 //
454 // Set by osMutator.
455 CommonOSVariant bool `blueprint:"mutated"`
456
Jiyong Park3f627e62024-05-01 16:14:38 +0900457 // When set to true, this module is not installed to the full install path (ex: under
458 // out/target/product/<name>/<partition>). It can be installed only to the packaging
459 // modules like android_filesystem.
460 No_full_install *bool
461
Colin Crossa9c8c9f2020-12-16 10:20:23 -0800462 // When HideFromMake is set to true, no entry for this variant will be emitted in the
463 // generated Android.mk file.
464 HideFromMake bool `blueprint:"mutated"`
465
466 // When SkipInstall is set to true, calls to ctx.InstallFile, ctx.InstallExecutable,
467 // ctx.InstallSymlink and ctx.InstallAbsoluteSymlink act like calls to ctx.PackageFile
468 // and don't create a rule to install the file.
Colin Crossce75d2c2016-10-06 16:12:58 -0700469 SkipInstall bool `blueprint:"mutated"`
Jeff Gaston088e29e2017-11-29 16:47:17 -0800470
Colin Crossbd3a16b2023-04-25 11:30:51 -0700471 // UninstallableApexPlatformVariant is set by MakeUninstallable called by the apex
472 // mutator. MakeUninstallable also sets HideFromMake. UninstallableApexPlatformVariant
473 // is used to avoid adding install or packaging dependencies into libraries provided
474 // by apexes.
475 UninstallableApexPlatformVariant bool `blueprint:"mutated"`
476
Liz Kammer5ca3a622020-08-05 15:40:41 -0700477 // Whether the module has been replaced by a prebuilt
478 ReplacedByPrebuilt bool `blueprint:"mutated"`
479
Justin Yun32f053b2020-07-31 23:07:17 +0900480 // Disabled by mutators. If set to true, it overrides Enabled property.
481 ForcedDisabled bool `blueprint:"mutated"`
482
Jeff Gaston088e29e2017-11-29 16:47:17 -0800483 NamespaceExportedToMake bool `blueprint:"mutated"`
Colin Cross6c4f21f2019-06-06 15:41:36 -0700484
Liz Kammerc13f7852023-05-17 13:01:48 -0400485 MissingDeps []string `blueprint:"mutated"`
486 CheckedMissingDeps bool `blueprint:"mutated"`
Colin Cross9a362232019-07-01 15:32:45 -0700487
488 // Name and variant strings stored by mutators to enable Module.String()
489 DebugName string `blueprint:"mutated"`
490 DebugMutators []string `blueprint:"mutated"`
491 DebugVariations []string `blueprint:"mutated"`
Colin Cross7228ecd2019-11-18 16:00:16 -0800492
Colin Crossa6845402020-11-16 15:08:19 -0800493 // ImageVariation is set by ImageMutator to specify which image this variation is for,
494 // for example "" for core or "recovery" for recovery. It will often be set to one of the
495 // constants in image.go, but can also be set to a custom value by individual module types.
Colin Cross7228ecd2019-11-18 16:00:16 -0800496 ImageVariation string `blueprint:"mutated"`
Liz Kammer2ada09a2021-08-11 00:17:36 -0400497
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800498 // The team (defined by the owner/vendor) who owns the property.
499 Team *string `android:"path"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800500}
501
Paul Duffined875132020-09-02 13:08:57 +0100502type distProperties struct {
503 // configuration to distribute output files from this module to the distribution
504 // directory (default: $OUT/dist, configurable with $DIST_DIR)
505 Dist Dist `android:"arch_variant"`
506
507 // a list of configurations to distribute output files from this module to the
508 // distribution directory (default: $OUT/dist, configurable with $DIST_DIR)
509 Dists []Dist `android:"arch_variant"`
510}
511
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800512type TeamDepTagType struct {
513 blueprint.BaseDependencyTag
514}
515
516var teamDepTag = TeamDepTagType{}
517
Jiyong Park8bcf3c62024-03-18 18:37:10 +0900518// Dependency tag for required, host_required, and target_required modules.
519var RequiredDepTag = struct {
520 blueprint.BaseDependencyTag
521 InstallAlwaysNeededDependencyTag
522 // Requiring disabled module has been supported (as a side effect of this being implemented
523 // in Make). We may want to make it an error, but for now, let's keep the existing behavior.
524 AlwaysAllowDisabledModuleDependencyTag
525}{}
526
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800527// CommonTestOptions represents the common `test_options` properties in
528// Android.bp.
529type CommonTestOptions struct {
530 // If the test is a hostside (no device required) unittest that shall be run
531 // during presubmit check.
532 Unit_test *bool
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800533
534 // Tags provide additional metadata to customize test execution by downstream
535 // test runners. The tags have no special meaning to Soong.
536 Tags []string
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800537}
538
539// SetAndroidMkEntries sets AndroidMkEntries according to the value of base
540// `test_options`.
541func (t *CommonTestOptions) SetAndroidMkEntries(entries *AndroidMkEntries) {
542 entries.SetBoolIfTrue("LOCAL_IS_UNIT_TEST", Bool(t.Unit_test))
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800543 if len(t.Tags) > 0 {
544 entries.AddStrings("LOCAL_TEST_OPTIONS_TAGS", t.Tags...)
545 }
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800546}
547
Paul Duffin74f05592020-11-25 16:37:46 +0000548// The key to use in TaggedDistFiles when a Dist structure does not specify a
549// tag property. This intentionally does not use "" as the default because that
550// would mean that an empty tag would have a different meaning when used in a dist
551// structure that when used to reference a specific set of output paths using the
552// :module{tag} syntax, which passes tag to the OutputFiles(tag) method.
553const DefaultDistTag = "<default-dist-tag>"
554
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000555// A map of OutputFile tag keys to Paths, for disting purposes.
556type TaggedDistFiles map[string]Paths
557
Paul Duffin74f05592020-11-25 16:37:46 +0000558// addPathsForTag adds a mapping from the tag to the paths. If the map is nil
559// then it will create a map, update it and then return it. If a mapping already
560// exists for the tag then the paths are appended to the end of the current list
561// of paths, ignoring any duplicates.
562func (t TaggedDistFiles) addPathsForTag(tag string, paths ...Path) TaggedDistFiles {
563 if t == nil {
564 t = make(TaggedDistFiles)
565 }
566
567 for _, distFile := range paths {
568 if distFile != nil && !t[tag].containsPath(distFile) {
569 t[tag] = append(t[tag], distFile)
570 }
571 }
572
573 return t
574}
575
576// merge merges the entries from the other TaggedDistFiles object into this one.
577// If the TaggedDistFiles is nil then it will create a new instance, merge the
578// other into it, and then return it.
579func (t TaggedDistFiles) merge(other TaggedDistFiles) TaggedDistFiles {
580 for tag, paths := range other {
581 t = t.addPathsForTag(tag, paths...)
582 }
583
584 return t
585}
586
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000587func MakeDefaultDistFiles(paths ...Path) TaggedDistFiles {
Sasha Smundake198eaf2022-08-04 13:07:02 -0700588 for _, p := range paths {
589 if p == nil {
Jingwen Chen7b27ca72020-07-24 09:13:49 +0000590 panic("The path to a dist file cannot be nil.")
591 }
592 }
593
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000594 // The default OutputFile tag is the empty "" string.
Paul Duffin74f05592020-11-25 16:37:46 +0000595 return TaggedDistFiles{DefaultDistTag: paths}
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000596}
597
Colin Cross3f40fa42015-01-30 17:27:36 -0800598type hostAndDeviceProperties struct {
Colin Cross4e81d702018-11-09 10:36:55 -0800599 // If set to true, build a variant of the module for the host. Defaults to false.
600 Host_supported *bool
601
602 // If set to true, build a variant of the module for the device. Defaults to true.
Colin Crossa4190c12016-07-12 13:11:25 -0700603 Device_supported *bool
Colin Cross3f40fa42015-01-30 17:27:36 -0800604}
605
Colin Crossc472d572015-03-17 15:06:21 -0700606type Multilib string
607
608const (
Colin Cross6b4a32d2017-12-05 13:42:45 -0800609 MultilibBoth Multilib = "both"
610 MultilibFirst Multilib = "first"
611 MultilibCommon Multilib = "common"
612 MultilibCommonFirst Multilib = "common_first"
Colin Crossc472d572015-03-17 15:06:21 -0700613)
614
Colin Crossa1ad8d12016-06-01 17:09:44 -0700615type HostOrDeviceSupported int
616
617const (
Colin Cross34037c62020-11-17 13:19:17 -0800618 hostSupported = 1 << iota
619 hostCrossSupported
620 deviceSupported
621 hostDefault
622 deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700623
624 // Host and HostCross are built by default. Device is not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800625 HostSupported = hostSupported | hostCrossSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700626
627 // Host is built by default. HostCross and Device are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800628 HostSupportedNoCross = hostSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700629
630 // Device is built by default. Host and HostCross are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800631 DeviceSupported = deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700632
Liz Kammer8631cc72021-08-23 21:12:07 +0000633 // By default, _only_ device variant is built. Device variant can be disabled with `device_supported: false`
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700634 // Host and HostCross are disabled by default and can be enabled with `host_supported: true`
Colin Cross34037c62020-11-17 13:19:17 -0800635 HostAndDeviceSupported = hostSupported | hostCrossSupported | deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700636
637 // Host, HostCross, and Device are built by default.
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700638 // Building Device can be disabled with `device_supported: false`
639 // Building Host and HostCross can be disabled with `host_supported: false`
Colin Cross34037c62020-11-17 13:19:17 -0800640 HostAndDeviceDefault = hostSupported | hostCrossSupported | hostDefault |
641 deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700642
643 // Nothing is supported. This is not exposed to the user, but used to mark a
644 // host only module as unsupported when the module type is not supported on
645 // the host OS. E.g. benchmarks are supported on Linux but not Darwin.
Colin Cross34037c62020-11-17 13:19:17 -0800646 NeitherHostNorDeviceSupported = 0
Colin Crossa1ad8d12016-06-01 17:09:44 -0700647)
648
Jiyong Park2db76922017-11-08 16:03:48 +0900649type moduleKind int
650
651const (
652 platformModule moduleKind = iota
653 deviceSpecificModule
654 socSpecificModule
655 productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +0900656 systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +0900657)
658
659func (k moduleKind) String() string {
660 switch k {
661 case platformModule:
662 return "platform"
663 case deviceSpecificModule:
664 return "device-specific"
665 case socSpecificModule:
666 return "soc-specific"
667 case productSpecificModule:
668 return "product-specific"
Justin Yund5f6c822019-06-25 16:47:17 +0900669 case systemExtSpecificModule:
670 return "systemext-specific"
Jiyong Park2db76922017-11-08 16:03:48 +0900671 default:
672 panic(fmt.Errorf("unknown module kind %d", k))
673 }
674}
675
Colin Cross9d34f352019-11-22 16:03:51 -0800676func initAndroidModuleBase(m Module) {
677 m.base().module = m
678}
679
Colin Crossa6845402020-11-16 15:08:19 -0800680// InitAndroidModule initializes the Module as an Android module that is not architecture-specific.
681// It adds the common properties, for example "name" and "enabled".
Colin Cross36242852017-06-23 15:06:31 -0700682func InitAndroidModule(m Module) {
Colin Cross9d34f352019-11-22 16:03:51 -0800683 initAndroidModuleBase(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800684 base := m.base()
Colin Cross5049f022015-03-18 13:28:46 -0700685
Colin Cross36242852017-06-23 15:06:31 -0700686 m.AddProperties(
Colin Crossfc754582016-05-17 16:34:16 -0700687 &base.nameProperties,
Paul Duffined875132020-09-02 13:08:57 +0100688 &base.commonProperties,
689 &base.distProperties)
Colin Cross18c46802019-09-24 22:19:02 -0700690
Colin Crosseabaedd2020-02-06 17:01:55 -0800691 initProductVariableModule(m)
Colin Cross18c46802019-09-24 22:19:02 -0700692
Paul Duffin63c6e182019-07-24 14:24:38 +0100693 // The default_visibility property needs to be checked and parsed by the visibility module during
Paul Duffin5ec73ec2020-05-01 17:52:01 +0100694 // its checking and parsing phases so make it the primary visibility property.
695 setPrimaryVisibilityProperty(m, "visibility", &base.commonProperties.Visibility)
Bob Badour37af0462021-01-07 03:34:31 +0000696
697 // The default_applicable_licenses property needs to be checked and parsed by the licenses module during
698 // its checking and parsing phases so make it the primary licenses property.
699 setPrimaryLicensesProperty(m, "licenses", &base.commonProperties.Licenses)
Colin Cross5049f022015-03-18 13:28:46 -0700700}
701
Colin Crossa6845402020-11-16 15:08:19 -0800702// InitAndroidArchModule initializes the Module as an Android module that is architecture-specific.
703// It adds the common properties, for example "name" and "enabled", as well as runtime generated
704// property structs for architecture-specific versions of generic properties tagged with
705// `android:"arch_variant"`.
706//
Colin Crossd079e0b2022-08-16 10:27:33 -0700707// InitAndroidModule should not be called if InitAndroidArchModule was called.
Colin Cross36242852017-06-23 15:06:31 -0700708func InitAndroidArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
709 InitAndroidModule(m)
Colin Cross5049f022015-03-18 13:28:46 -0700710
711 base := m.base()
Colin Cross3f40fa42015-01-30 17:27:36 -0800712 base.commonProperties.HostOrDeviceSupported = hod
Colin Cross69617d32016-09-06 10:39:07 -0700713 base.commonProperties.Default_multilib = string(defaultMultilib)
Dan Willemsen0b24c742016-10-04 15:13:37 -0700714 base.commonProperties.ArchSpecific = true
Colin Crossee0bc3b2018-10-02 22:01:37 -0700715 base.commonProperties.UseTargetVariants = true
Colin Cross3f40fa42015-01-30 17:27:36 -0800716
Colin Cross34037c62020-11-17 13:19:17 -0800717 if hod&hostSupported != 0 && hod&deviceSupported != 0 {
Colin Cross36242852017-06-23 15:06:31 -0700718 m.AddProperties(&base.hostAndDeviceProperties)
Colin Cross3f40fa42015-01-30 17:27:36 -0800719 }
720
Colin Crossa6845402020-11-16 15:08:19 -0800721 initArchModule(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800722}
723
Colin Crossa6845402020-11-16 15:08:19 -0800724// InitAndroidMultiTargetsArchModule initializes the Module as an Android module that is
725// architecture-specific, but will only have a single variant per OS that handles all the
726// architectures simultaneously. The list of Targets that it must handle will be available from
727// ModuleContext.MultiTargets. It adds the common properties, for example "name" and "enabled", as
728// well as runtime generated property structs for architecture-specific versions of generic
729// properties tagged with `android:"arch_variant"`.
730//
731// InitAndroidModule or InitAndroidArchModule should not be called if
732// InitAndroidMultiTargetsArchModule was called.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700733func InitAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
734 InitAndroidArchModule(m, hod, defaultMultilib)
735 m.base().commonProperties.UseTargetVariants = false
736}
737
Colin Crossa6845402020-11-16 15:08:19 -0800738// InitCommonOSAndroidMultiTargetsArchModule initializes the Module as an Android module that is
739// architecture-specific, but will only have a single variant per OS that handles all the
740// architectures simultaneously, and will also have an additional CommonOS variant that has
741// dependencies on all the OS-specific variants. The list of Targets that it must handle will be
742// available from ModuleContext.MultiTargets. It adds the common properties, for example "name" and
743// "enabled", as well as runtime generated property structs for architecture-specific versions of
744// generic properties tagged with `android:"arch_variant"`.
745//
746// InitAndroidModule, InitAndroidArchModule or InitAndroidMultiTargetsArchModule should not be
747// called if InitCommonOSAndroidMultiTargetsArchModule was called.
Paul Duffin1356d8c2020-02-25 19:26:33 +0000748func InitCommonOSAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
749 InitAndroidArchModule(m, hod, defaultMultilib)
750 m.base().commonProperties.UseTargetVariants = false
751 m.base().commonProperties.CreateCommonOSVariant = true
752}
753
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800754// A ModuleBase object contains the properties that are common to all Android
Colin Cross3f40fa42015-01-30 17:27:36 -0800755// modules. It should be included as an anonymous field in every module
756// struct definition. InitAndroidModule should then be called from the module's
757// factory function, and the return values from InitAndroidModule should be
758// returned from the factory function.
759//
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800760// The ModuleBase type is responsible for implementing the GenerateBuildActions
761// method to support the blueprint.Module interface. This method will then call
762// the module's GenerateAndroidBuildActions method once for each build variant
Colin Cross25de6c32019-06-06 14:29:25 -0700763// that is to be built. GenerateAndroidBuildActions is passed a ModuleContext
764// rather than the usual blueprint.ModuleContext.
765// ModuleContext exposes extra functionality specific to the Android build
Colin Cross3f40fa42015-01-30 17:27:36 -0800766// system including details about the particular build variant that is to be
767// generated.
768//
769// For example:
770//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800771// import (
772// "android/soong/android"
773// )
Colin Cross3f40fa42015-01-30 17:27:36 -0800774//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800775// type myModule struct {
776// android.ModuleBase
777// properties struct {
778// MyProperty string
779// }
780// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800781//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800782// func NewMyModule() android.Module {
783// m := &myModule{}
784// m.AddProperties(&m.properties)
785// android.InitAndroidModule(m)
786// return m
787// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800788//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800789// func (m *myModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
790// // Get the CPU architecture for the current build variant.
791// variantArch := ctx.Arch()
Colin Cross3f40fa42015-01-30 17:27:36 -0800792//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800793// // ...
794// }
Colin Cross635c3b02016-05-18 15:37:25 -0700795type ModuleBase struct {
Colin Cross3f40fa42015-01-30 17:27:36 -0800796 // Putting the curiously recurring thing pointing to the thing that contains
797 // the thing pattern to good use.
Colin Cross36242852017-06-23 15:06:31 -0700798 // TODO: remove this
Colin Cross635c3b02016-05-18 15:37:25 -0700799 module Module
Colin Cross3f40fa42015-01-30 17:27:36 -0800800
Colin Crossfc754582016-05-17 16:34:16 -0700801 nameProperties nameProperties
Colin Cross3f40fa42015-01-30 17:27:36 -0800802 commonProperties commonProperties
Paul Duffined875132020-09-02 13:08:57 +0100803 distProperties distProperties
Colin Cross18c46802019-09-24 22:19:02 -0700804 variableProperties interface{}
Colin Cross3f40fa42015-01-30 17:27:36 -0800805 hostAndDeviceProperties hostAndDeviceProperties
Jingwen Chen5d864492021-02-24 07:20:12 -0500806
Usta851a3272022-01-05 23:42:33 -0500807 // Arch specific versions of structs in GetProperties() prior to
808 // initialization in InitAndroidArchModule, lets call it `generalProperties`.
809 // The outer index has the same order as generalProperties and the inner index
810 // chooses the props specific to the architecture. The interface{} value is an
811 // archPropRoot that is filled with arch specific values by the arch mutator.
Jingwen Chen5d864492021-02-24 07:20:12 -0500812 archProperties [][]interface{}
813
Paul Duffin63c6e182019-07-24 14:24:38 +0100814 // Information about all the properties on the module that contains visibility rules that need
815 // checking.
816 visibilityPropertyInfo []visibilityProperty
817
818 // The primary visibility property, may be nil, that controls access to the module.
819 primaryVisibilityProperty visibilityProperty
820
Bob Badour37af0462021-01-07 03:34:31 +0000821 // The primary licenses property, may be nil, records license metadata for the module.
822 primaryLicensesProperty applicableLicensesProperty
823
Colin Crossffe6b9d2020-12-01 15:40:06 -0800824 noAddressSanitizer bool
825 installFiles InstallPaths
Colin Crossc85750b2022-04-21 12:50:51 -0700826 installFilesDepSet *DepSet[InstallPath]
Colin Crossffe6b9d2020-12-01 15:40:06 -0800827 checkbuildFiles Paths
828 packagingSpecs []PackagingSpec
Colin Crossc85750b2022-04-21 12:50:51 -0700829 packagingSpecsDepSet *DepSet[PackagingSpec]
Colin Cross6301c3c2021-09-28 17:40:21 -0700830 // katiInstalls tracks the install rules that were created by Soong but are being exported
831 // to Make to convert to ninja rules so that Make can add additional dependencies.
832 katiInstalls katiInstalls
Colin Crossd9bbf4b2023-11-17 16:23:48 -0800833 // katiInitRcInstalls and katiVintfInstalls track the install rules created by Soong that are
834 // allowed to have duplicates across modules and variants.
835 katiInitRcInstalls katiInstalls
836 katiVintfInstalls katiInstalls
837 katiSymlinks katiInstalls
838 testData []DataPath
Colin Cross1f8c52b2015-06-16 16:38:17 -0700839
Paul Duffinaf970a22020-11-23 23:32:56 +0000840 // The files to copy to the dist as explicitly specified in the .bp file.
841 distFiles TaggedDistFiles
842
Colin Cross1f8c52b2015-06-16 16:38:17 -0700843 // Used by buildTargetSingleton to create checkbuild and per-directory build targets
844 // Only set on the final variant of each module
Colin Cross0875c522017-11-28 17:34:01 -0800845 installTarget WritablePath
846 checkbuildTarget WritablePath
Colin Cross1f8c52b2015-06-16 16:38:17 -0700847 blueprintDir string
Colin Crossa120ec12016-08-19 16:07:38 -0700848
Colin Cross178a5092016-09-13 13:42:32 -0700849 hooks hooks
Colin Cross36242852017-06-23 15:06:31 -0700850
851 registerProps []interface{}
Colin Crosscec81712017-07-13 14:43:27 -0700852
853 // For tests
Colin Crossae887032017-10-23 17:16:14 -0700854 buildParams []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -0800855 ruleParams map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800856 variables map[string]string
Colin Crossa9d8bee2018-10-02 13:59:46 -0700857
Inseob Kim8471cda2019-11-15 09:59:12 +0900858 initRcPaths Paths
859 vintfFragmentsPaths Paths
Colin Cross4acaea92021-12-10 23:05:02 +0000860
Colin Crossd9bbf4b2023-11-17 16:23:48 -0800861 installedInitRcPaths InstallPaths
862 installedVintfFragmentsPaths InstallPaths
863
Justin Yun74f3f302024-05-07 14:32:14 +0900864 // Merged Aconfig files for all transitive deps.
865 aconfigFilePaths Paths
866
Colin Cross4acaea92021-12-10 23:05:02 +0000867 // set of dependency module:location mappings used to populate the license metadata for
868 // apex containers.
869 licenseInstallMap []string
Colin Crossaa1cab02022-01-28 14:49:24 -0800870
871 // The path to the generated license metadata file for the module.
872 licenseMetadataFile WritablePath
Colin Crossd6fd0132023-11-06 13:54:06 -0800873
874 // moduleInfoJSON can be filled out by GenerateAndroidBuildActions to write a JSON file that will
875 // be included in the final module-info.json produced by Make.
876 moduleInfoJSON *ModuleInfoJSON
mrziwange6c85812024-05-22 14:36:09 -0700877
878 // outputFiles stores the output of a module by tag and is used to set
879 // the OutputFilesProvider in GenerateBuildActions
880 outputFiles OutputFilesInfo
Wei Lia1aa2972024-06-21 13:08:51 -0700881
882 // complianceMetadataInfo is for different module types to dump metadata.
883 // See android.ModuleContext interface.
884 complianceMetadataInfo *ComplianceMetadataInfo
Colin Cross36242852017-06-23 15:06:31 -0700885}
886
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200887func (m *ModuleBase) AddJSONData(d *map[string]interface{}) {
Liz Kammer9525e712022-01-05 13:46:24 -0500888 (*d)["Android"] = map[string]interface{}{
889 // Properties set in Blueprint or in blueprint of a defaults modules
890 "SetProperties": m.propertiesWithValues(),
891 }
892}
893
894type propInfo struct {
Liz Kammer898e0762022-03-22 11:27:26 -0400895 Name string
896 Type string
897 Value string
898 Values []string
Liz Kammer9525e712022-01-05 13:46:24 -0500899}
900
901func (m *ModuleBase) propertiesWithValues() []propInfo {
902 var info []propInfo
903 props := m.GetProperties()
904
905 var propsWithValues func(name string, v reflect.Value)
906 propsWithValues = func(name string, v reflect.Value) {
907 kind := v.Kind()
908 switch kind {
909 case reflect.Ptr, reflect.Interface:
910 if v.IsNil() {
911 return
912 }
913 propsWithValues(name, v.Elem())
914 case reflect.Struct:
915 if v.IsZero() {
916 return
917 }
918 for i := 0; i < v.NumField(); i++ {
919 namePrefix := name
920 sTyp := v.Type().Field(i)
921 if proptools.ShouldSkipProperty(sTyp) {
922 continue
923 }
924 if name != "" && !strings.HasSuffix(namePrefix, ".") {
925 namePrefix += "."
926 }
927 if !proptools.IsEmbedded(sTyp) {
928 namePrefix += sTyp.Name
929 }
930 sVal := v.Field(i)
931 propsWithValues(namePrefix, sVal)
932 }
933 case reflect.Array, reflect.Slice:
934 if v.IsNil() {
935 return
936 }
937 elKind := v.Type().Elem().Kind()
Liz Kammer898e0762022-03-22 11:27:26 -0400938 info = append(info, propInfo{Name: name, Type: elKind.String() + " " + kind.String(), Values: sliceReflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500939 default:
Liz Kammer898e0762022-03-22 11:27:26 -0400940 info = append(info, propInfo{Name: name, Type: kind.String(), Value: reflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500941 }
942 }
943
944 for _, p := range props {
945 propsWithValues("", reflect.ValueOf(p).Elem())
946 }
Liz Kammer898e0762022-03-22 11:27:26 -0400947 sort.Slice(info, func(i, j int) bool {
948 return info[i].Name < info[j].Name
949 })
Liz Kammer9525e712022-01-05 13:46:24 -0500950 return info
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200951}
952
Liz Kammer898e0762022-03-22 11:27:26 -0400953func reflectionValue(value reflect.Value) string {
954 switch value.Kind() {
955 case reflect.Bool:
956 return fmt.Sprintf("%t", value.Bool())
957 case reflect.Int64:
958 return fmt.Sprintf("%d", value.Int())
959 case reflect.String:
960 return fmt.Sprintf("%s", value.String())
961 case reflect.Struct:
962 if value.IsZero() {
963 return "{}"
964 }
965 length := value.NumField()
966 vals := make([]string, length, length)
967 for i := 0; i < length; i++ {
968 sTyp := value.Type().Field(i)
969 if proptools.ShouldSkipProperty(sTyp) {
970 continue
971 }
972 name := sTyp.Name
973 vals[i] = fmt.Sprintf("%s: %s", name, reflectionValue(value.Field(i)))
974 }
975 return fmt.Sprintf("%s{%s}", value.Type(), strings.Join(vals, ", "))
976 case reflect.Array, reflect.Slice:
977 vals := sliceReflectionValue(value)
978 return fmt.Sprintf("[%s]", strings.Join(vals, ", "))
979 }
980 return ""
981}
982
983func sliceReflectionValue(value reflect.Value) []string {
984 length := value.Len()
985 vals := make([]string, length, length)
986 for i := 0; i < length; i++ {
987 vals[i] = reflectionValue(value.Index(i))
988 }
989 return vals
990}
991
Paul Duffin44f1d842020-06-26 20:17:02 +0100992func (m *ModuleBase) ComponentDepsMutator(BottomUpMutatorContext) {}
993
Colin Cross4157e882019-06-06 16:57:04 -0700994func (m *ModuleBase) DepsMutator(BottomUpMutatorContext) {}
Colin Cross5f692ec2019-02-01 16:53:07 -0800995
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800996func (m *ModuleBase) baseDepsMutator(ctx BottomUpMutatorContext) {
997 if m.Team() != "" {
998 ctx.AddDependency(ctx.Module(), teamDepTag, m.Team())
999 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001000
1001 // TODO(jiyong): remove below case. This is to work around build errors happening
1002 // on branches with reduced manifest like aosp_kernel-build-tools.
1003 // In the branch, a build error occurs as follows.
1004 // 1. aosp_kernel-build-tools is a reduced manifest branch. It doesn't have some git
1005 // projects like external/bouncycastle
1006 // 2. `boot_signer` is `required` by modules like `build_image` which is explicitly list as
1007 // the top-level build goal (in the shell file that invokes Soong).
1008 // 3. `boot_signer` depends on `bouncycastle-unbundled` which is in the missing git project.
1009 // 4. aosp_kernel-build-tools invokes soong with `--skip-make`. Therefore, the absence of
1010 // ALLOW_MISSING_DEPENDENCIES didn't cause a problem.
1011 // 5. Now, since Soong understands `required` deps, it tries to build `boot_signer` and the
1012 // absence of external/bouncycastle fails the build.
1013 //
1014 // Unfortunately, there's no way for Soong to correctly determine if it's running in a
1015 // reduced manifest branch. Instead, here, we use the absence of DeviceArch or DeviceName as
1016 // a strong signal, because that's very common across reduced manifest branches.
1017 pv := ctx.Config().productVariables
1018 fullManifest := pv.DeviceArch != nil && pv.DeviceName != nil
1019 if fullManifest {
Jiyong Parkf21dd652024-04-17 05:22:37 +00001020 addRequiredDeps(ctx)
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001021 }
1022}
1023
1024// addRequiredDeps adds required, target_required, and host_required as dependencies.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001025func addRequiredDeps(ctx BottomUpMutatorContext) {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001026 addDep := func(target Target, depName string) {
1027 if !ctx.OtherModuleExists(depName) {
1028 if ctx.Config().AllowMissingDependencies() {
1029 return
1030 }
1031 }
1032
1033 // If Android native module requires another Android native module, ensure that
1034 // they have the same bitness. This mimics the policy in select-bitness-of-required-modules
1035 // in build/make/core/main.mk.
1036 // TODO(jiyong): the Make-side does this only when the required module is a shared
1037 // library or a native test.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001038 bothInAndroid := ctx.Device() && target.Os.Class == Device
Jiyong Parkc4b1d552024-05-13 16:47:30 +09001039 nativeArch := InList(ctx.Arch().ArchType.Multilib, []string{"lib32", "lib64"}) &&
1040 InList(target.Arch.ArchType.Multilib, []string{"lib32", "lib64"})
Jiyong Parkf21dd652024-04-17 05:22:37 +00001041 sameBitness := ctx.Arch().ArchType.Multilib == target.Arch.ArchType.Multilib
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001042 if bothInAndroid && nativeArch && !sameBitness {
1043 return
1044 }
1045
Jiyong Park8db44152024-05-28 12:22:04 +09001046 // ... also don't make a dependency between native bridge arch and non-native bridge
1047 // arches. b/342945184
1048 if ctx.Target().NativeBridge != target.NativeBridge {
1049 return
1050 }
1051
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001052 variation := target.Variations()
1053 if ctx.OtherModuleFarDependencyVariantExists(variation, depName) {
1054 ctx.AddFarVariationDependencies(variation, RequiredDepTag, depName)
1055 }
1056 }
1057
Jiyong Park73e5bab2024-04-05 13:37:21 +09001058 var deviceTargets []Target
1059 deviceTargets = append(deviceTargets, ctx.Config().Targets[Android]...)
1060 deviceTargets = append(deviceTargets, ctx.Config().AndroidCommonTarget)
1061
1062 var hostTargets []Target
1063 hostTargets = append(hostTargets, ctx.Config().Targets[ctx.Config().BuildOS]...)
1064 hostTargets = append(hostTargets, ctx.Config().BuildOSCommonTarget)
1065
Jiyong Parkf21dd652024-04-17 05:22:37 +00001066 if ctx.Device() {
Cole Faust43ddd082024-06-17 12:32:40 -07001067 for _, depName := range ctx.Module().RequiredModuleNames(ctx) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001068 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001069 addDep(target, depName)
1070 }
1071 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001072 for _, depName := range ctx.Module().HostRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001073 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001074 addDep(target, depName)
1075 }
1076 }
1077 }
1078
Jiyong Parkf21dd652024-04-17 05:22:37 +00001079 if ctx.Host() {
Cole Faust43ddd082024-06-17 12:32:40 -07001080 for _, depName := range ctx.Module().RequiredModuleNames(ctx) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001081 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001082 // When a host module requires another host module, don't make a
1083 // dependency if they have different OSes (i.e. hostcross).
Jiyong Parkf21dd652024-04-17 05:22:37 +00001084 if ctx.Target().HostCross != target.HostCross {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001085 continue
1086 }
1087 addDep(target, depName)
1088 }
1089 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001090 for _, depName := range ctx.Module().TargetRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001091 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001092 addDep(target, depName)
1093 }
1094 }
1095 }
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001096}
1097
Usta355a5872021-12-01 15:16:32 -05001098// AddProperties "registers" the provided props
1099// each value in props MUST be a pointer to a struct
Colin Cross4157e882019-06-06 16:57:04 -07001100func (m *ModuleBase) AddProperties(props ...interface{}) {
1101 m.registerProps = append(m.registerProps, props...)
Colin Cross36242852017-06-23 15:06:31 -07001102}
1103
Colin Cross4157e882019-06-06 16:57:04 -07001104func (m *ModuleBase) GetProperties() []interface{} {
1105 return m.registerProps
Colin Cross3f40fa42015-01-30 17:27:36 -08001106}
1107
Colin Cross4157e882019-06-06 16:57:04 -07001108func (m *ModuleBase) BuildParamsForTests() []BuildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001109 // Expand the references to module variables like $flags[0-9]*,
1110 // so we do not need to change many existing unit tests.
1111 // This looks like undoing the shareFlags optimization in cc's
1112 // transformSourceToObj, and should only affects unit tests.
1113 vars := m.VariablesForTests()
1114 buildParams := append([]BuildParams(nil), m.buildParams...)
Sasha Smundake198eaf2022-08-04 13:07:02 -07001115 for i := range buildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001116 newArgs := make(map[string]string)
1117 for k, v := range buildParams[i].Args {
1118 newArgs[k] = v
1119 // Replaces both ${flags1} and $flags1 syntax.
1120 if strings.HasPrefix(v, "${") && strings.HasSuffix(v, "}") {
1121 if value, found := vars[v[2:len(v)-1]]; found {
1122 newArgs[k] = value
1123 }
1124 } else if strings.HasPrefix(v, "$") {
1125 if value, found := vars[v[1:]]; found {
1126 newArgs[k] = value
1127 }
1128 }
1129 }
1130 buildParams[i].Args = newArgs
1131 }
1132 return buildParams
Colin Crosscec81712017-07-13 14:43:27 -07001133}
1134
Colin Cross4157e882019-06-06 16:57:04 -07001135func (m *ModuleBase) RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams {
1136 return m.ruleParams
Colin Cross4c83e5c2019-02-25 14:54:28 -08001137}
1138
Colin Cross4157e882019-06-06 16:57:04 -07001139func (m *ModuleBase) VariablesForTests() map[string]string {
1140 return m.variables
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001141}
1142
Colin Crossce75d2c2016-10-06 16:12:58 -07001143// Name returns the name of the module. It may be overridden by individual module types, for
1144// example prebuilts will prepend prebuilt_ to the name.
Colin Cross4157e882019-06-06 16:57:04 -07001145func (m *ModuleBase) Name() string {
1146 return String(m.nameProperties.Name)
Colin Crossfc754582016-05-17 16:34:16 -07001147}
1148
Colin Cross9a362232019-07-01 15:32:45 -07001149// String returns a string that includes the module name and variants for printing during debugging.
1150func (m *ModuleBase) String() string {
1151 sb := strings.Builder{}
1152 sb.WriteString(m.commonProperties.DebugName)
1153 sb.WriteString("{")
1154 for i := range m.commonProperties.DebugMutators {
1155 if i != 0 {
1156 sb.WriteString(",")
1157 }
1158 sb.WriteString(m.commonProperties.DebugMutators[i])
1159 sb.WriteString(":")
1160 sb.WriteString(m.commonProperties.DebugVariations[i])
1161 }
1162 sb.WriteString("}")
1163 return sb.String()
1164}
1165
Colin Crossce75d2c2016-10-06 16:12:58 -07001166// BaseModuleName returns the name of the module as specified in the blueprints file.
Colin Cross4157e882019-06-06 16:57:04 -07001167func (m *ModuleBase) BaseModuleName() string {
1168 return String(m.nameProperties.Name)
Colin Crossce75d2c2016-10-06 16:12:58 -07001169}
1170
Colin Cross4157e882019-06-06 16:57:04 -07001171func (m *ModuleBase) base() *ModuleBase {
1172 return m
Colin Cross3f40fa42015-01-30 17:27:36 -08001173}
1174
Paul Duffine2453c72019-05-31 14:00:04 +01001175func (m *ModuleBase) qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName {
1176 return qualifiedModuleName{pkg: ctx.ModuleDir(), name: ctx.ModuleName()}
1177}
1178
1179func (m *ModuleBase) visibilityProperties() []visibilityProperty {
Paul Duffin63c6e182019-07-24 14:24:38 +01001180 return m.visibilityPropertyInfo
1181}
1182
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001183func (m *ModuleBase) Dists() []Dist {
Paul Duffined875132020-09-02 13:08:57 +01001184 if len(m.distProperties.Dist.Targets) > 0 {
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001185 // Make a copy of the underlying Dists slice to protect against
1186 // backing array modifications with repeated calls to this method.
Paul Duffined875132020-09-02 13:08:57 +01001187 distsCopy := append([]Dist(nil), m.distProperties.Dists...)
1188 return append(distsCopy, m.distProperties.Dist)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001189 } else {
Paul Duffined875132020-09-02 13:08:57 +01001190 return m.distProperties.Dists
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001191 }
1192}
1193
1194func (m *ModuleBase) GenerateTaggedDistFiles(ctx BaseModuleContext) TaggedDistFiles {
Paul Duffin74f05592020-11-25 16:37:46 +00001195 var distFiles TaggedDistFiles
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001196 for _, dist := range m.Dists() {
Paul Duffin74f05592020-11-25 16:37:46 +00001197 // If no tag is specified then it means to use the default dist paths so use
1198 // the special tag name which represents that.
1199 tag := proptools.StringDefault(dist.Tag, DefaultDistTag)
1200
mrziwangabdb2932024-06-18 12:43:41 -07001201 distFileForTagFromProvider, err := outputFilesForModuleFromProvider(ctx, m.module, tag)
1202 if err != OutputFilesProviderNotSet {
1203 if err != nil && tag != DefaultDistTag {
1204 ctx.PropertyErrorf("dist.tag", "%s", err.Error())
1205 } else {
1206 distFiles = distFiles.addPathsForTag(tag, distFileForTagFromProvider...)
1207 continue
1208 }
1209 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001210 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001211 return distFiles
1212}
1213
Cole Faust02987bd2024-03-21 17:58:43 -07001214func (m *ModuleBase) ArchReady() bool {
1215 return m.commonProperties.ArchReady
1216}
1217
Colin Cross4157e882019-06-06 16:57:04 -07001218func (m *ModuleBase) Target() Target {
1219 return m.commonProperties.CompileTarget
Dan Willemsen490fd492015-11-24 17:53:15 -08001220}
1221
Colin Cross4157e882019-06-06 16:57:04 -07001222func (m *ModuleBase) TargetPrimary() bool {
1223 return m.commonProperties.CompilePrimary
Colin Cross8b74d172016-09-13 09:59:14 -07001224}
1225
Colin Cross4157e882019-06-06 16:57:04 -07001226func (m *ModuleBase) MultiTargets() []Target {
1227 return m.commonProperties.CompileMultiTargets
Colin Crossee0bc3b2018-10-02 22:01:37 -07001228}
1229
Colin Cross4157e882019-06-06 16:57:04 -07001230func (m *ModuleBase) Os() OsType {
1231 return m.Target().Os
Dan Willemsen490fd492015-11-24 17:53:15 -08001232}
1233
Colin Cross4157e882019-06-06 16:57:04 -07001234func (m *ModuleBase) Host() bool {
Jiyong Park1613e552020-09-14 19:43:17 +09001235 return m.Os().Class == Host
Dan Willemsen97750522016-02-09 17:43:51 -08001236}
1237
Yo Chiangbba545e2020-06-09 16:15:37 +08001238func (m *ModuleBase) Device() bool {
1239 return m.Os().Class == Device
1240}
1241
Colin Cross4157e882019-06-06 16:57:04 -07001242func (m *ModuleBase) Arch() Arch {
1243 return m.Target().Arch
Dan Willemsen97750522016-02-09 17:43:51 -08001244}
1245
Colin Cross4157e882019-06-06 16:57:04 -07001246func (m *ModuleBase) ArchSpecific() bool {
1247 return m.commonProperties.ArchSpecific
Dan Willemsen0b24c742016-10-04 15:13:37 -07001248}
1249
Paul Duffin1356d8c2020-02-25 19:26:33 +00001250// True if the current variant is a CommonOS variant, false otherwise.
1251func (m *ModuleBase) IsCommonOSVariant() bool {
1252 return m.commonProperties.CommonOSVariant
1253}
1254
Colin Cross34037c62020-11-17 13:19:17 -08001255// supportsTarget returns true if the given Target is supported by the current module.
1256func (m *ModuleBase) supportsTarget(target Target) bool {
1257 switch target.Os.Class {
1258 case Host:
1259 if target.HostCross {
1260 return m.HostCrossSupported()
1261 } else {
1262 return m.HostSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001263 }
Colin Cross34037c62020-11-17 13:19:17 -08001264 case Device:
1265 return m.DeviceSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001266 default:
Jiyong Park1613e552020-09-14 19:43:17 +09001267 return false
Colin Crossa1ad8d12016-06-01 17:09:44 -07001268 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001269}
1270
Colin Cross34037c62020-11-17 13:19:17 -08001271// DeviceSupported returns true if the current module is supported and enabled for device targets,
1272// i.e. the factory method set the HostOrDeviceSupported value to include device support and
1273// the device support is enabled by default or enabled by the device_supported property.
Colin Cross4157e882019-06-06 16:57:04 -07001274func (m *ModuleBase) DeviceSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001275 hod := m.commonProperties.HostOrDeviceSupported
1276 // deviceEnabled is true if the device_supported property is true or the HostOrDeviceSupported
1277 // value has the deviceDefault bit set.
1278 deviceEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Device_supported, hod&deviceDefault != 0)
1279 return hod&deviceSupported != 0 && deviceEnabled
Colin Cross3f40fa42015-01-30 17:27:36 -08001280}
1281
Colin Cross34037c62020-11-17 13:19:17 -08001282// HostSupported returns true if the current module is supported and enabled for host targets,
1283// i.e. the factory method set the HostOrDeviceSupported value to include host support and
1284// the host support is enabled by default or enabled by the host_supported property.
Paul Duffine44358f2019-11-26 18:04:12 +00001285func (m *ModuleBase) HostSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001286 hod := m.commonProperties.HostOrDeviceSupported
1287 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1288 // value has the hostDefault bit set.
1289 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
1290 return hod&hostSupported != 0 && hostEnabled
1291}
1292
1293// HostCrossSupported returns true if the current module is supported and enabled for host cross
1294// targets, i.e. the factory method set the HostOrDeviceSupported value to include host cross
1295// support and the host cross support is enabled by default or enabled by the
1296// host_supported property.
1297func (m *ModuleBase) HostCrossSupported() bool {
1298 hod := m.commonProperties.HostOrDeviceSupported
1299 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1300 // value has the hostDefault bit set.
1301 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
1302 return hod&hostCrossSupported != 0 && hostEnabled
Paul Duffine44358f2019-11-26 18:04:12 +00001303}
1304
Colin Cross4157e882019-06-06 16:57:04 -07001305func (m *ModuleBase) Platform() bool {
Justin Yund5f6c822019-06-25 16:47:17 +09001306 return !m.DeviceSpecific() && !m.SocSpecific() && !m.ProductSpecific() && !m.SystemExtSpecific()
Jiyong Parkc678ad32018-04-10 13:07:10 +09001307}
1308
Colin Cross4157e882019-06-06 16:57:04 -07001309func (m *ModuleBase) DeviceSpecific() bool {
1310 return Bool(m.commonProperties.Device_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001311}
1312
Colin Cross4157e882019-06-06 16:57:04 -07001313func (m *ModuleBase) SocSpecific() bool {
1314 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001315}
1316
Colin Cross4157e882019-06-06 16:57:04 -07001317func (m *ModuleBase) ProductSpecific() bool {
1318 return Bool(m.commonProperties.Product_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001319}
1320
Justin Yund5f6c822019-06-25 16:47:17 +09001321func (m *ModuleBase) SystemExtSpecific() bool {
1322 return Bool(m.commonProperties.System_ext_specific)
Dario Frenifd05a742018-05-29 13:28:54 +01001323}
1324
Colin Crossc2d24052020-05-13 11:05:02 -07001325// RequiresStableAPIs returns true if the module will be installed to a partition that may
1326// be updated separately from the system image.
1327func (m *ModuleBase) RequiresStableAPIs(ctx BaseModuleContext) bool {
1328 return m.SocSpecific() || m.DeviceSpecific() ||
1329 (m.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface())
1330}
1331
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001332func (m *ModuleBase) PartitionTag(config DeviceConfig) string {
1333 partition := "system"
1334 if m.SocSpecific() {
1335 // A SoC-specific module could be on the vendor partition at
1336 // "vendor" or the system partition at "system/vendor".
1337 if config.VendorPath() == "vendor" {
1338 partition = "vendor"
1339 }
1340 } else if m.DeviceSpecific() {
1341 // A device-specific module could be on the odm partition at
1342 // "odm", the vendor partition at "vendor/odm", or the system
1343 // partition at "system/vendor/odm".
1344 if config.OdmPath() == "odm" {
1345 partition = "odm"
Ramy Medhat944839a2020-03-31 22:14:52 -04001346 } else if strings.HasPrefix(config.OdmPath(), "vendor/") {
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001347 partition = "vendor"
1348 }
1349 } else if m.ProductSpecific() {
1350 // A product-specific module could be on the product partition
1351 // at "product" or the system partition at "system/product".
1352 if config.ProductPath() == "product" {
1353 partition = "product"
1354 }
1355 } else if m.SystemExtSpecific() {
1356 // A system_ext-specific module could be on the system_ext
1357 // partition at "system_ext" or the system partition at
1358 // "system/system_ext".
1359 if config.SystemExtPath() == "system_ext" {
1360 partition = "system_ext"
1361 }
1362 }
1363 return partition
1364}
1365
Cole Fausta963b942024-04-11 17:43:00 -07001366func (m *ModuleBase) Enabled(ctx ConfigAndErrorContext) bool {
Justin Yun32f053b2020-07-31 23:07:17 +09001367 if m.commonProperties.ForcedDisabled {
1368 return false
1369 }
Cole Fausta963b942024-04-11 17:43:00 -07001370 return m.commonProperties.Enabled.GetOrDefault(m.ConfigurableEvaluator(ctx), !m.Os().DefaultDisabled)
Colin Cross3f40fa42015-01-30 17:27:36 -08001371}
1372
Inseob Kimeec88e12020-01-22 11:11:29 +09001373func (m *ModuleBase) Disable() {
Justin Yun32f053b2020-07-31 23:07:17 +09001374 m.commonProperties.ForcedDisabled = true
Inseob Kimeec88e12020-01-22 11:11:29 +09001375}
1376
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001377// HideFromMake marks this variant so that it is not emitted in the generated Android.mk file.
1378func (m *ModuleBase) HideFromMake() {
1379 m.commonProperties.HideFromMake = true
1380}
1381
1382// IsHideFromMake returns true if HideFromMake was previously called.
1383func (m *ModuleBase) IsHideFromMake() bool {
1384 return m.commonProperties.HideFromMake == true
1385}
1386
1387// SkipInstall marks this variant to not create install rules when ctx.Install* are called.
Colin Cross4157e882019-06-06 16:57:04 -07001388func (m *ModuleBase) SkipInstall() {
1389 m.commonProperties.SkipInstall = true
Colin Crossce75d2c2016-10-06 16:12:58 -07001390}
1391
Martin Stjernholm9e7f45e2020-12-23 03:50:30 +00001392// IsSkipInstall returns true if this variant is marked to not create install
1393// rules when ctx.Install* are called.
1394func (m *ModuleBase) IsSkipInstall() bool {
1395 return m.commonProperties.SkipInstall
1396}
1397
Iván Budnik295da162023-03-10 16:11:26 +00001398// Similar to HideFromMake, but if the AndroidMk entry would set
1399// LOCAL_UNINSTALLABLE_MODULE then this variant may still output that entry
1400// rather than leaving it out altogether. That happens in cases where it would
1401// have other side effects, in particular when it adds a NOTICE file target,
1402// which other install targets might depend on.
1403func (m *ModuleBase) MakeUninstallable() {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001404 m.commonProperties.UninstallableApexPlatformVariant = true
Iván Budnik295da162023-03-10 16:11:26 +00001405 m.HideFromMake()
1406}
1407
Liz Kammer5ca3a622020-08-05 15:40:41 -07001408func (m *ModuleBase) ReplacedByPrebuilt() {
1409 m.commonProperties.ReplacedByPrebuilt = true
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001410 m.HideFromMake()
Liz Kammer5ca3a622020-08-05 15:40:41 -07001411}
1412
1413func (m *ModuleBase) IsReplacedByPrebuilt() bool {
1414 return m.commonProperties.ReplacedByPrebuilt
1415}
1416
Colin Cross4157e882019-06-06 16:57:04 -07001417func (m *ModuleBase) ExportedToMake() bool {
1418 return m.commonProperties.NamespaceExportedToMake
Jiyong Park374510b2018-03-19 18:23:01 +09001419}
1420
Justin Yun1871f902023-04-07 20:13:19 +09001421func (m *ModuleBase) EffectiveLicenseKinds() []string {
1422 return m.commonProperties.Effective_license_kinds
1423}
1424
Justin Yun885a7de2021-06-29 20:34:53 +09001425func (m *ModuleBase) EffectiveLicenseFiles() Paths {
Bob Badour4101c712022-02-09 11:54:35 -08001426 result := make(Paths, 0, len(m.commonProperties.Effective_license_text))
1427 for _, p := range m.commonProperties.Effective_license_text {
1428 result = append(result, p.Path)
1429 }
1430 return result
Justin Yun885a7de2021-06-29 20:34:53 +09001431}
1432
Colin Crosse9fe2942020-11-10 18:12:15 -08001433// computeInstallDeps finds the installed paths of all dependencies that have a dependency
Colin Crossbd3a16b2023-04-25 11:30:51 -07001434// tag that is annotated as needing installation via the isInstallDepNeeded method.
Colin Crossc85750b2022-04-21 12:50:51 -07001435func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]*DepSet[InstallPath], []*DepSet[PackagingSpec]) {
1436 var installDeps []*DepSet[InstallPath]
1437 var packagingSpecs []*DepSet[PackagingSpec]
Colin Cross5d583952020-11-24 16:21:24 -08001438 ctx.VisitDirectDeps(func(dep Module) {
Jiyong Park1d4907e2024-05-15 02:09:42 +09001439 if isInstallDepNeeded(dep, ctx.OtherModuleDependencyTag(dep)) {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001440 // Installation is still handled by Make, so anything hidden from Make is not
1441 // installable.
1442 if !dep.IsHideFromMake() && !dep.IsSkipInstall() {
Jiyong Park1d4907e2024-05-15 02:09:42 +09001443 installDeps = append(installDeps, dep.base().installFilesDepSet)
Colin Crossbd3a16b2023-04-25 11:30:51 -07001444 }
1445 // Add packaging deps even when the dependency is not installed so that uninstallable
1446 // modules can still be packaged. Often the package will be installed instead.
Jiyong Park1d4907e2024-05-15 02:09:42 +09001447 packagingSpecs = append(packagingSpecs, dep.base().packagingSpecsDepSet)
Colin Cross897266e2020-02-13 13:22:08 -08001448 }
1449 })
Colin Cross3f40fa42015-01-30 17:27:36 -08001450
Colin Crossffe6b9d2020-12-01 15:40:06 -08001451 return installDeps, packagingSpecs
Colin Cross3f40fa42015-01-30 17:27:36 -08001452}
1453
Colin Crossbd3a16b2023-04-25 11:30:51 -07001454// isInstallDepNeeded returns true if installing the output files of the current module
1455// should also install the output files of the given dependency and dependency tag.
1456func isInstallDepNeeded(dep Module, tag blueprint.DependencyTag) bool {
1457 // Don't add a dependency from the platform to a library provided by an apex.
1458 if dep.base().commonProperties.UninstallableApexPlatformVariant {
1459 return false
1460 }
1461 // Only install modules if the dependency tag is an InstallDepNeeded tag.
1462 return IsInstallDepNeededTag(tag)
1463}
1464
Jiyong Park4dc2a1a2020-09-28 17:46:22 +09001465func (m *ModuleBase) FilesToInstall() InstallPaths {
Colin Cross4157e882019-06-06 16:57:04 -07001466 return m.installFiles
Colin Cross3f40fa42015-01-30 17:27:36 -08001467}
1468
Jiyong Park073ea552020-11-09 14:08:34 +09001469func (m *ModuleBase) PackagingSpecs() []PackagingSpec {
1470 return m.packagingSpecs
1471}
1472
Colin Crossffe6b9d2020-12-01 15:40:06 -08001473func (m *ModuleBase) TransitivePackagingSpecs() []PackagingSpec {
1474 return m.packagingSpecsDepSet.ToList()
1475}
1476
Colin Cross4157e882019-06-06 16:57:04 -07001477func (m *ModuleBase) NoAddressSanitizer() bool {
1478 return m.noAddressSanitizer
Colin Cross3f40fa42015-01-30 17:27:36 -08001479}
1480
Colin Cross4157e882019-06-06 16:57:04 -07001481func (m *ModuleBase) InstallInData() bool {
Dan Willemsen782a2d12015-12-21 14:55:28 -08001482 return false
1483}
1484
Jaewoong Jung0949f312019-09-11 10:25:18 -07001485func (m *ModuleBase) InstallInTestcases() bool {
1486 return false
1487}
1488
Colin Cross4157e882019-06-06 16:57:04 -07001489func (m *ModuleBase) InstallInSanitizerDir() bool {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001490 return false
1491}
1492
Yifan Hong1b3348d2020-01-21 15:53:22 -08001493func (m *ModuleBase) InstallInRamdisk() bool {
1494 return Bool(m.commonProperties.Ramdisk)
1495}
1496
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001497func (m *ModuleBase) InstallInVendorRamdisk() bool {
1498 return Bool(m.commonProperties.Vendor_ramdisk)
1499}
1500
Inseob Kim08758f02021-04-08 21:13:22 +09001501func (m *ModuleBase) InstallInDebugRamdisk() bool {
1502 return Bool(m.commonProperties.Debug_ramdisk)
1503}
1504
Colin Cross4157e882019-06-06 16:57:04 -07001505func (m *ModuleBase) InstallInRecovery() bool {
1506 return Bool(m.commonProperties.Recovery)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001507}
1508
Colin Crossea30d852023-11-29 16:00:16 -08001509func (m *ModuleBase) InstallInOdm() bool {
1510 return false
1511}
1512
1513func (m *ModuleBase) InstallInProduct() bool {
1514 return false
1515}
1516
Kiyoung Kimae11c232021-07-19 11:38:04 +09001517func (m *ModuleBase) InstallInVendor() bool {
Kiyoung Kimf160f7f2022-11-29 10:58:08 +09001518 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Soc_specific) || Bool(m.commonProperties.Proprietary)
Kiyoung Kimae11c232021-07-19 11:38:04 +09001519}
1520
Colin Cross90ba5f42019-10-02 11:10:58 -07001521func (m *ModuleBase) InstallInRoot() bool {
1522 return false
1523}
1524
Jiyong Park87788b52020-09-01 12:37:45 +09001525func (m *ModuleBase) InstallForceOS() (*OsType, *ArchType) {
1526 return nil, nil
Colin Cross6e359402020-02-10 15:29:54 -08001527}
1528
Colin Cross4157e882019-06-06 16:57:04 -07001529func (m *ModuleBase) Owner() string {
1530 return String(m.commonProperties.Owner)
Sundong Ahn4fd04bb2018-08-31 18:01:37 +09001531}
1532
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001533func (m *ModuleBase) Team() string {
1534 return String(m.commonProperties.Team)
1535}
1536
Colin Cross7228ecd2019-11-18 16:00:16 -08001537func (m *ModuleBase) setImageVariation(variant string) {
1538 m.commonProperties.ImageVariation = variant
1539}
1540
1541func (m *ModuleBase) ImageVariation() blueprint.Variation {
1542 return blueprint.Variation{
1543 Mutator: "image",
1544 Variation: m.base().commonProperties.ImageVariation,
1545 }
1546}
1547
Paul Duffin9b76c0b2020-03-12 10:24:35 +00001548func (m *ModuleBase) getVariationByMutatorName(mutator string) string {
1549 for i, v := range m.commonProperties.DebugMutators {
1550 if v == mutator {
1551 return m.commonProperties.DebugVariations[i]
1552 }
1553 }
1554
1555 return ""
1556}
1557
Yifan Hong1b3348d2020-01-21 15:53:22 -08001558func (m *ModuleBase) InRamdisk() bool {
1559 return m.base().commonProperties.ImageVariation == RamdiskVariation
1560}
1561
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001562func (m *ModuleBase) InVendorRamdisk() bool {
1563 return m.base().commonProperties.ImageVariation == VendorRamdiskVariation
1564}
1565
Inseob Kim08758f02021-04-08 21:13:22 +09001566func (m *ModuleBase) InDebugRamdisk() bool {
1567 return m.base().commonProperties.ImageVariation == DebugRamdiskVariation
1568}
1569
Colin Cross7228ecd2019-11-18 16:00:16 -08001570func (m *ModuleBase) InRecovery() bool {
1571 return m.base().commonProperties.ImageVariation == RecoveryVariation
1572}
1573
Cole Faust43ddd082024-06-17 12:32:40 -07001574func (m *ModuleBase) RequiredModuleNames(ctx ConfigAndErrorContext) []string {
1575 return m.base().commonProperties.Required.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
Jiyong Park6a8cf5f2019-12-30 16:31:09 +09001576}
1577
1578func (m *ModuleBase) HostRequiredModuleNames() []string {
1579 return m.base().commonProperties.Host_required
1580}
1581
1582func (m *ModuleBase) TargetRequiredModuleNames() []string {
1583 return m.base().commonProperties.Target_required
1584}
1585
Inseob Kim8471cda2019-11-15 09:59:12 +09001586func (m *ModuleBase) InitRc() Paths {
1587 return append(Paths{}, m.initRcPaths...)
1588}
1589
1590func (m *ModuleBase) VintfFragments() Paths {
1591 return append(Paths{}, m.vintfFragmentsPaths...)
1592}
1593
Yu Liu4ae55d12022-01-05 17:17:23 -08001594func (m *ModuleBase) CompileMultilib() *string {
1595 return m.base().commonProperties.Compile_multilib
1596}
1597
Colin Cross4acaea92021-12-10 23:05:02 +00001598// SetLicenseInstallMap stores the set of dependency module:location mappings for files in an
1599// apex container for use when generation the license metadata file.
1600func (m *ModuleBase) SetLicenseInstallMap(installMap []string) {
1601 m.licenseInstallMap = append(m.licenseInstallMap, installMap...)
1602}
1603
Colin Cross4157e882019-06-06 16:57:04 -07001604func (m *ModuleBase) generateModuleTarget(ctx ModuleContext) {
Colin Cross897266e2020-02-13 13:22:08 -08001605 var allInstalledFiles InstallPaths
1606 var allCheckbuildFiles Paths
Colin Cross0875c522017-11-28 17:34:01 -08001607 ctx.VisitAllModuleVariants(func(module Module) {
1608 a := module.base()
Colin Crossc9404352015-03-26 16:10:12 -07001609 allInstalledFiles = append(allInstalledFiles, a.installFiles...)
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001610 // A module's -checkbuild phony targets should
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001611 // not be created if the module is not exported to make.
1612 // Those could depend on the build target and fail to compile
1613 // for the current build target.
Cole Fausta963b942024-04-11 17:43:00 -07001614 if !ctx.Config().KatiEnabled() || !shouldSkipAndroidMkProcessing(ctx, a) {
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001615 allCheckbuildFiles = append(allCheckbuildFiles, a.checkbuildFiles...)
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001616 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001617 })
1618
Colin Cross0875c522017-11-28 17:34:01 -08001619 var deps Paths
Colin Cross9454bfa2015-03-17 13:24:18 -07001620
Colin Cross133ebef2020-08-14 17:38:45 -07001621 namespacePrefix := ctx.Namespace().id
Jeff Gaston088e29e2017-11-29 16:47:17 -08001622 if namespacePrefix != "" {
1623 namespacePrefix = namespacePrefix + "-"
1624 }
1625
Colin Cross3f40fa42015-01-30 17:27:36 -08001626 if len(allInstalledFiles) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001627 name := namespacePrefix + ctx.ModuleName() + "-install"
1628 ctx.Phony(name, allInstalledFiles.Paths()...)
1629 m.installTarget = PathForPhony(ctx, name)
1630 deps = append(deps, m.installTarget)
Colin Cross9454bfa2015-03-17 13:24:18 -07001631 }
1632
1633 if len(allCheckbuildFiles) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001634 name := namespacePrefix + ctx.ModuleName() + "-checkbuild"
1635 ctx.Phony(name, allCheckbuildFiles...)
1636 m.checkbuildTarget = PathForPhony(ctx, name)
1637 deps = append(deps, m.checkbuildTarget)
Colin Cross9454bfa2015-03-17 13:24:18 -07001638 }
1639
1640 if len(deps) > 0 {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001641 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05001642 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001643 suffix = "-soong"
1644 }
1645
Colin Crossc3d87d32020-06-04 13:25:17 -07001646 ctx.Phony(namespacePrefix+ctx.ModuleName()+suffix, deps...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07001647
Colin Cross4157e882019-06-06 16:57:04 -07001648 m.blueprintDir = ctx.ModuleDir()
Colin Cross3f40fa42015-01-30 17:27:36 -08001649 }
1650}
1651
Colin Crossc34d2322020-01-03 15:23:27 -08001652func determineModuleKind(m *ModuleBase, ctx blueprint.EarlyModuleContext) moduleKind {
Colin Cross4157e882019-06-06 16:57:04 -07001653 var socSpecific = Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
1654 var deviceSpecific = Bool(m.commonProperties.Device_specific)
1655 var productSpecific = Bool(m.commonProperties.Product_specific)
Justin Yund5f6c822019-06-25 16:47:17 +09001656 var systemExtSpecific = Bool(m.commonProperties.System_ext_specific)
Jiyong Park2db76922017-11-08 16:03:48 +09001657
Dario Frenifd05a742018-05-29 13:28:54 +01001658 msg := "conflicting value set here"
1659 if socSpecific && deviceSpecific {
1660 ctx.PropertyErrorf("device_specific", "a module cannot be specific to SoC and device at the same time.")
Colin Cross4157e882019-06-06 16:57:04 -07001661 if Bool(m.commonProperties.Vendor) {
Jiyong Park2db76922017-11-08 16:03:48 +09001662 ctx.PropertyErrorf("vendor", msg)
1663 }
Colin Cross4157e882019-06-06 16:57:04 -07001664 if Bool(m.commonProperties.Proprietary) {
Jiyong Park2db76922017-11-08 16:03:48 +09001665 ctx.PropertyErrorf("proprietary", msg)
1666 }
Colin Cross4157e882019-06-06 16:57:04 -07001667 if Bool(m.commonProperties.Soc_specific) {
Jiyong Park2db76922017-11-08 16:03:48 +09001668 ctx.PropertyErrorf("soc_specific", msg)
1669 }
1670 }
1671
Justin Yund5f6c822019-06-25 16:47:17 +09001672 if productSpecific && systemExtSpecific {
1673 ctx.PropertyErrorf("product_specific", "a module cannot be specific to product and system_ext at the same time.")
1674 ctx.PropertyErrorf("system_ext_specific", msg)
Dario Frenifd05a742018-05-29 13:28:54 +01001675 }
1676
Justin Yund5f6c822019-06-25 16:47:17 +09001677 if (socSpecific || deviceSpecific) && (productSpecific || systemExtSpecific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001678 if productSpecific {
1679 ctx.PropertyErrorf("product_specific", "a module cannot be specific to SoC or device and product at the same time.")
1680 } else {
Justin Yund5f6c822019-06-25 16:47:17 +09001681 ctx.PropertyErrorf("system_ext_specific", "a module cannot be specific to SoC or device and system_ext at the same time.")
Dario Frenifd05a742018-05-29 13:28:54 +01001682 }
1683 if deviceSpecific {
1684 ctx.PropertyErrorf("device_specific", msg)
1685 } else {
Colin Cross4157e882019-06-06 16:57:04 -07001686 if Bool(m.commonProperties.Vendor) {
Dario Frenifd05a742018-05-29 13:28:54 +01001687 ctx.PropertyErrorf("vendor", msg)
1688 }
Colin Cross4157e882019-06-06 16:57:04 -07001689 if Bool(m.commonProperties.Proprietary) {
Dario Frenifd05a742018-05-29 13:28:54 +01001690 ctx.PropertyErrorf("proprietary", msg)
1691 }
Colin Cross4157e882019-06-06 16:57:04 -07001692 if Bool(m.commonProperties.Soc_specific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001693 ctx.PropertyErrorf("soc_specific", msg)
1694 }
1695 }
1696 }
1697
Jiyong Park2db76922017-11-08 16:03:48 +09001698 if productSpecific {
1699 return productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +09001700 } else if systemExtSpecific {
1701 return systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +09001702 } else if deviceSpecific {
1703 return deviceSpecificModule
1704 } else if socSpecific {
1705 return socSpecificModule
1706 } else {
1707 return platformModule
1708 }
1709}
1710
Colin Crossc34d2322020-01-03 15:23:27 -08001711func (m *ModuleBase) earlyModuleContextFactory(ctx blueprint.EarlyModuleContext) earlyModuleContext {
Colin Cross1184b642019-12-30 18:43:07 -08001712 return earlyModuleContext{
Colin Crossc34d2322020-01-03 15:23:27 -08001713 EarlyModuleContext: ctx,
1714 kind: determineModuleKind(m, ctx),
1715 config: ctx.Config().(Config),
Colin Cross3f40fa42015-01-30 17:27:36 -08001716 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001717}
1718
Colin Cross1184b642019-12-30 18:43:07 -08001719func (m *ModuleBase) baseModuleContextFactory(ctx blueprint.BaseModuleContext) baseModuleContext {
1720 return baseModuleContext{
1721 bp: ctx,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001722 archModuleContext: m.archModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001723 earlyModuleContext: m.earlyModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001724 }
1725}
1726
Colin Crosse1a85552024-06-14 12:17:37 -07001727type archModuleContextFactoryContext interface {
1728 Config() interface{}
1729}
1730
1731func (m *ModuleBase) archModuleContextFactory(ctx archModuleContextFactoryContext) archModuleContext {
Colin Cross1d3d9f12024-01-18 14:30:22 -08001732 config := ctx.Config().(Config)
1733 target := m.Target()
1734 primaryArch := false
1735 if len(config.Targets[target.Os]) <= 1 {
1736 primaryArch = true
1737 } else {
1738 primaryArch = target.Arch.ArchType == config.Targets[target.Os][0].Arch.ArchType
1739 }
1740
1741 return archModuleContext{
Cole Faust0aa21cc2024-03-20 12:28:03 -07001742 ready: m.commonProperties.ArchReady,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001743 os: m.commonProperties.CompileOS,
1744 target: m.commonProperties.CompileTarget,
1745 targetPrimary: m.commonProperties.CompilePrimary,
1746 multiTargets: m.commonProperties.CompileMultiTargets,
1747 primaryArch: primaryArch,
1748 }
1749
1750}
1751
Colin Cross4157e882019-06-06 16:57:04 -07001752func (m *ModuleBase) GenerateBuildActions(blueprintCtx blueprint.ModuleContext) {
Colin Cross25de6c32019-06-06 14:29:25 -07001753 ctx := &moduleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001754 module: m.module,
Colin Crossdc35e212019-06-06 16:13:11 -07001755 bp: blueprintCtx,
Colin Cross0ea8ba82019-06-06 14:33:29 -07001756 baseModuleContext: m.baseModuleContextFactory(blueprintCtx),
Colin Cross0ea8ba82019-06-06 14:33:29 -07001757 variables: make(map[string]string),
Colin Cross3f40fa42015-01-30 17:27:36 -08001758 }
1759
Colin Crossaa1cab02022-01-28 14:49:24 -08001760 m.licenseMetadataFile = PathForModuleOut(ctx, "meta_lic")
1761
Colin Crossffe6b9d2020-12-01 15:40:06 -08001762 dependencyInstallFiles, dependencyPackagingSpecs := m.computeInstallDeps(ctx)
Colin Cross5d583952020-11-24 16:21:24 -08001763 // set m.installFilesDepSet to only the transitive dependencies to be used as the dependencies
1764 // of installed files of this module. It will be replaced by a depset including the installed
1765 // files of this module at the end for use by modules that depend on this one.
Colin Crossc85750b2022-04-21 12:50:51 -07001766 m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, nil, dependencyInstallFiles)
Colin Cross5d583952020-11-24 16:21:24 -08001767
Colin Cross6c4f21f2019-06-06 15:41:36 -07001768 // Temporarily continue to call blueprintCtx.GetMissingDependencies() to maintain the previous behavior of never
1769 // reporting missing dependency errors in Blueprint when AllowMissingDependencies == true.
1770 // TODO: This will be removed once defaults modules handle missing dependency errors
1771 blueprintCtx.GetMissingDependencies()
1772
Colin Crossdc35e212019-06-06 16:13:11 -07001773 // For the final GenerateAndroidBuildActions pass, require that all visited dependencies Soong modules and
Paul Duffin1356d8c2020-02-25 19:26:33 +00001774 // are enabled. Unless the module is a CommonOS variant which may have dependencies on disabled variants
1775 // (because the dependencies are added before the modules are disabled). The
1776 // GetOsSpecificVariantsOfCommonOSVariant(...) method will ensure that the disabled variants are
1777 // ignored.
1778 ctx.baseModuleContext.strictVisitDeps = !m.IsCommonOSVariant()
Colin Crossdc35e212019-06-06 16:13:11 -07001779
Colin Cross4c83e5c2019-02-25 14:54:28 -08001780 if ctx.config.captureBuild {
1781 ctx.ruleParams = make(map[blueprint.Rule]blueprint.RuleParams)
1782 }
1783
Colin Cross67a5c132017-05-09 13:45:28 -07001784 desc := "//" + ctx.ModuleDir() + ":" + ctx.ModuleName() + " "
1785 var suffix []string
Colin Cross0875c522017-11-28 17:34:01 -08001786 if ctx.Os().Class != Device && ctx.Os().Class != Generic {
1787 suffix = append(suffix, ctx.Os().String())
Colin Cross67a5c132017-05-09 13:45:28 -07001788 }
Colin Cross0875c522017-11-28 17:34:01 -08001789 if !ctx.PrimaryArch() {
1790 suffix = append(suffix, ctx.Arch().ArchType.String())
Colin Cross67a5c132017-05-09 13:45:28 -07001791 }
Colin Crossff694a82023-12-13 15:54:49 -08001792 if apexInfo, _ := ModuleProvider(ctx, ApexInfoProvider); !apexInfo.IsForPlatform() {
Colin Cross56a83212020-09-15 18:30:11 -07001793 suffix = append(suffix, apexInfo.ApexVariationName)
Dan Willemsenb13a9482020-02-14 11:25:54 -08001794 }
Colin Cross67a5c132017-05-09 13:45:28 -07001795
1796 ctx.Variable(pctx, "moduleDesc", desc)
1797
1798 s := ""
1799 if len(suffix) > 0 {
1800 s = " [" + strings.Join(suffix, " ") + "]"
1801 }
1802 ctx.Variable(pctx, "moduleDescSuffix", s)
1803
Dan Willemsen569edc52018-11-19 09:33:29 -08001804 // Some common property checks for properties that will be used later in androidmk.go
Paul Duffin89968e32020-11-23 18:17:03 +00001805 checkDistProperties(ctx, "dist", &m.distProperties.Dist)
Sasha Smundake198eaf2022-08-04 13:07:02 -07001806 for i := range m.distProperties.Dists {
Paul Duffin89968e32020-11-23 18:17:03 +00001807 checkDistProperties(ctx, fmt.Sprintf("dists[%d]", i), &m.distProperties.Dists[i])
Dan Willemsen569edc52018-11-19 09:33:29 -08001808 }
1809
Cole Fausta963b942024-04-11 17:43:00 -07001810 if m.Enabled(ctx) {
Jooyung Hand48f3c32019-08-23 11:18:57 +09001811 // ensure all direct android.Module deps are enabled
1812 ctx.VisitDirectDepsBlueprint(func(bm blueprint.Module) {
Martin Stjernholm0e4cceb2021-05-13 02:38:35 +01001813 if m, ok := bm.(Module); ok {
LaMont Jones34314b72024-01-18 18:27:35 +00001814 ctx.validateAndroidModule(bm, ctx.OtherModuleDependencyTag(m), ctx.baseModuleContext.strictVisitDeps, false)
Jooyung Hand48f3c32019-08-23 11:18:57 +09001815 }
1816 })
1817
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001818 if m.Device() {
1819 // Handle any init.rc and vintf fragment files requested by the module. All files installed by this
1820 // module will automatically have a dependency on the installed init.rc or vintf fragment file.
1821 // The same init.rc or vintf fragment file may be requested by multiple modules or variants,
1822 // so instead of installing them now just compute the install path and store it for later.
1823 // The full list of all init.rc and vintf fragment install rules will be deduplicated later
1824 // so only a single rule is created for each init.rc or vintf fragment file.
1825
1826 if !m.InVendorRamdisk() {
1827 m.initRcPaths = PathsForModuleSrc(ctx, m.commonProperties.Init_rc)
1828 rcDir := PathForModuleInstall(ctx, "etc", "init")
1829 for _, src := range m.initRcPaths {
1830 installedInitRc := rcDir.Join(ctx, src.Base())
1831 m.katiInitRcInstalls = append(m.katiInitRcInstalls, katiInstall{
1832 from: src,
1833 to: installedInitRc,
1834 })
1835 ctx.PackageFile(rcDir, src.Base(), src)
1836 m.installedInitRcPaths = append(m.installedInitRcPaths, installedInitRc)
1837 }
1838 }
1839
1840 m.vintfFragmentsPaths = PathsForModuleSrc(ctx, m.commonProperties.Vintf_fragments)
1841 vintfDir := PathForModuleInstall(ctx, "etc", "vintf", "manifest")
1842 for _, src := range m.vintfFragmentsPaths {
1843 installedVintfFragment := vintfDir.Join(ctx, src.Base())
1844 m.katiVintfInstalls = append(m.katiVintfInstalls, katiInstall{
1845 from: src,
1846 to: installedVintfFragment,
1847 })
1848 ctx.PackageFile(vintfDir, src.Base(), src)
1849 m.installedVintfFragmentsPaths = append(m.installedVintfFragmentsPaths, installedVintfFragment)
1850 }
1851 }
1852
Bob Badour37af0462021-01-07 03:34:31 +00001853 licensesPropertyFlattener(ctx)
1854 if ctx.Failed() {
1855 return
1856 }
1857
Joe Onorato349ae8d2024-02-05 22:46:00 +00001858 if jarJarPrefixHandler != nil {
1859 jarJarPrefixHandler(ctx)
1860 if ctx.Failed() {
1861 return
1862 }
1863 }
1864
Justin Yun40182b62024-05-07 10:22:19 +09001865 // Call aconfigUpdateAndroidBuildActions to collect merged aconfig files before being used
1866 // in m.module.GenerateAndroidBuildActions
1867 aconfigUpdateAndroidBuildActions(ctx)
Jaewoong Jung5b425e22019-06-17 17:40:56 -07001868 if ctx.Failed() {
1869 return
1870 }
1871
Yu Liufa297642024-06-11 00:13:02 +00001872 incrementalAnalysis := false
1873 incrementalEnabled := false
1874 var cacheKey *blueprint.BuildActionCacheKey = nil
1875 var incrementalModule *blueprint.Incremental = nil
1876 if ctx.bp.GetIncrementalEnabled() {
1877 if im, ok := m.module.(blueprint.Incremental); ok {
1878 incrementalModule = &im
1879 incrementalEnabled = im.IncrementalSupported()
1880 incrementalAnalysis = ctx.bp.GetIncrementalAnalysis() && incrementalEnabled
1881 }
1882 }
1883 if incrementalEnabled {
1884 hash, err := proptools.CalculateHash(m.GetProperties())
1885 if err != nil {
1886 ctx.ModuleErrorf("failed to calculate properties hash: %s", err)
1887 return
1888 }
1889 cacheInput := new(blueprint.BuildActionCacheInput)
1890 cacheInput.PropertiesHash = hash
1891 ctx.VisitDirectDeps(func(module Module) {
1892 cacheInput.ProvidersHash =
1893 append(cacheInput.ProvidersHash, ctx.bp.OtherModuleProviderInitialValueHashes(module))
1894 })
1895 hash, err = proptools.CalculateHash(&cacheInput)
1896 if err != nil {
1897 ctx.ModuleErrorf("failed to calculate cache input hash: %s", err)
1898 return
1899 }
1900 cacheKey = &blueprint.BuildActionCacheKey{
1901 Id: ctx.bp.ModuleId(),
1902 InputHash: hash,
1903 }
1904 }
1905
1906 restored := false
1907 if incrementalAnalysis && cacheKey != nil {
1908 restored = ctx.bp.RestoreBuildActions(cacheKey, incrementalModule)
1909 }
1910
1911 if !restored {
1912 m.module.GenerateAndroidBuildActions(ctx)
1913 if ctx.Failed() {
1914 return
1915 }
1916 }
1917
1918 if incrementalEnabled && cacheKey != nil {
1919 ctx.bp.CacheBuildActions(cacheKey, incrementalModule)
LaMont Jonesb5099382024-01-10 23:42:36 +00001920 }
1921
Paul Duffinaf970a22020-11-23 23:32:56 +00001922 // Create the set of tagged dist files after calling GenerateAndroidBuildActions
1923 // as GenerateTaggedDistFiles() calls OutputFiles(tag) and so relies on the
1924 // output paths being set which must be done before or during
1925 // GenerateAndroidBuildActions.
1926 m.distFiles = m.GenerateTaggedDistFiles(ctx)
1927 if ctx.Failed() {
1928 return
1929 }
1930
Jaewoong Jung5b425e22019-06-17 17:40:56 -07001931 m.installFiles = append(m.installFiles, ctx.installFiles...)
1932 m.checkbuildFiles = append(m.checkbuildFiles, ctx.checkbuildFiles...)
Jiyong Park073ea552020-11-09 14:08:34 +09001933 m.packagingSpecs = append(m.packagingSpecs, ctx.packagingSpecs...)
Colin Cross6301c3c2021-09-28 17:40:21 -07001934 m.katiInstalls = append(m.katiInstalls, ctx.katiInstalls...)
1935 m.katiSymlinks = append(m.katiSymlinks, ctx.katiSymlinks...)
Colin Cross5c1d5fb2023-11-15 12:39:40 -08001936 m.testData = append(m.testData, ctx.testData...)
Colin Crossdc35e212019-06-06 16:13:11 -07001937 } else if ctx.Config().AllowMissingDependencies() {
1938 // If the module is not enabled it will not create any build rules, nothing will call
1939 // ctx.GetMissingDependencies(), and blueprint will consider the missing dependencies to be unhandled
1940 // and report them as an error even when AllowMissingDependencies = true. Call
1941 // ctx.GetMissingDependencies() here to tell blueprint not to handle them.
1942 ctx.GetMissingDependencies()
Colin Cross3f40fa42015-01-30 17:27:36 -08001943 }
1944
Colin Cross4157e882019-06-06 16:57:04 -07001945 if m == ctx.FinalModule().(Module).base() {
1946 m.generateModuleTarget(ctx)
Colin Cross9b1d13d2016-09-19 15:18:11 -07001947 if ctx.Failed() {
1948 return
1949 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001950 }
Colin Crosscec81712017-07-13 14:43:27 -07001951
Colin Crossc85750b2022-04-21 12:50:51 -07001952 m.installFilesDepSet = NewDepSet[InstallPath](TOPOLOGICAL, m.installFiles, dependencyInstallFiles)
1953 m.packagingSpecsDepSet = NewDepSet[PackagingSpec](TOPOLOGICAL, m.packagingSpecs, dependencyPackagingSpecs)
Colin Cross5d583952020-11-24 16:21:24 -08001954
Colin Crossaa1cab02022-01-28 14:49:24 -08001955 buildLicenseMetadata(ctx, m.licenseMetadataFile)
Colin Cross4acaea92021-12-10 23:05:02 +00001956
Colin Crossd6fd0132023-11-06 13:54:06 -08001957 if m.moduleInfoJSON != nil {
1958 var installed InstallPaths
1959 installed = append(installed, m.katiInstalls.InstallPaths()...)
1960 installed = append(installed, m.katiSymlinks.InstallPaths()...)
1961 installed = append(installed, m.katiInitRcInstalls.InstallPaths()...)
1962 installed = append(installed, m.katiVintfInstalls.InstallPaths()...)
1963 installedStrings := installed.Strings()
1964
1965 var targetRequired, hostRequired []string
1966 if ctx.Host() {
1967 targetRequired = m.commonProperties.Target_required
1968 } else {
1969 hostRequired = m.commonProperties.Host_required
1970 }
1971
1972 var data []string
1973 for _, d := range m.testData {
1974 data = append(data, d.ToRelativeInstallPath())
1975 }
1976
1977 if m.moduleInfoJSON.Uninstallable {
1978 installedStrings = nil
1979 if len(m.moduleInfoJSON.CompatibilitySuites) == 1 && m.moduleInfoJSON.CompatibilitySuites[0] == "null-suite" {
1980 m.moduleInfoJSON.CompatibilitySuites = nil
1981 m.moduleInfoJSON.TestConfig = nil
1982 m.moduleInfoJSON.AutoTestConfig = nil
1983 data = nil
1984 }
1985 }
1986
1987 m.moduleInfoJSON.core = CoreModuleInfoJSON{
1988 RegisterName: m.moduleInfoRegisterName(ctx, m.moduleInfoJSON.SubName),
1989 Path: []string{ctx.ModuleDir()},
1990 Installed: installedStrings,
1991 ModuleName: m.BaseModuleName() + m.moduleInfoJSON.SubName,
1992 SupportedVariants: []string{m.moduleInfoVariant(ctx)},
1993 TargetDependencies: targetRequired,
1994 HostDependencies: hostRequired,
1995 Data: data,
Cole Faust43ddd082024-06-17 12:32:40 -07001996 Required: m.RequiredModuleNames(ctx),
Colin Crossd6fd0132023-11-06 13:54:06 -08001997 }
1998 SetProvider(ctx, ModuleInfoJSONProvider, m.moduleInfoJSON)
1999 }
2000
Colin Cross4157e882019-06-06 16:57:04 -07002001 m.buildParams = ctx.buildParams
2002 m.ruleParams = ctx.ruleParams
2003 m.variables = ctx.variables
mrziwange6c85812024-05-22 14:36:09 -07002004
2005 if m.outputFiles.DefaultOutputFiles != nil || m.outputFiles.TaggedOutputFiles != nil {
2006 SetProvider(ctx, OutputFilesProvider, m.outputFiles)
2007 }
Wei Lia1aa2972024-06-21 13:08:51 -07002008
2009 buildComplianceMetadataProvider(ctx, m)
Colin Cross3f40fa42015-01-30 17:27:36 -08002010}
2011
Joe Onorato349ae8d2024-02-05 22:46:00 +00002012func SetJarJarPrefixHandler(handler func(ModuleContext)) {
2013 if jarJarPrefixHandler != nil {
2014 panic("jarJarPrefixHandler already set")
2015 }
2016 jarJarPrefixHandler = handler
2017}
2018
Colin Crossd6fd0132023-11-06 13:54:06 -08002019func (m *ModuleBase) moduleInfoRegisterName(ctx ModuleContext, subName string) string {
2020 name := m.BaseModuleName()
2021
2022 prefix := ""
2023 if ctx.Host() {
2024 if ctx.Os() != ctx.Config().BuildOS {
2025 prefix = "host_cross_"
2026 }
2027 }
2028 suffix := ""
2029 arches := slices.Clone(ctx.Config().Targets[ctx.Os()])
2030 arches = slices.DeleteFunc(arches, func(target Target) bool {
2031 return target.NativeBridge != ctx.Target().NativeBridge
2032 })
2033 if len(arches) > 0 && ctx.Arch().ArchType != arches[0].Arch.ArchType {
2034 if ctx.Arch().ArchType.Multilib == "lib32" {
2035 suffix = "_32"
2036 } else {
2037 suffix = "_64"
2038 }
2039 }
2040 return prefix + name + subName + suffix
2041}
2042
2043func (m *ModuleBase) moduleInfoVariant(ctx ModuleContext) string {
2044 variant := "DEVICE"
2045 if ctx.Host() {
2046 if ctx.Os() != ctx.Config().BuildOS {
2047 variant = "HOST_CROSS"
2048 } else {
2049 variant = "HOST"
2050 }
2051 }
2052 return variant
2053}
2054
Paul Duffin89968e32020-11-23 18:17:03 +00002055// Check the supplied dist structure to make sure that it is valid.
2056//
2057// property - the base property, e.g. dist or dists[1], which is combined with the
2058// name of the nested property to produce the full property, e.g. dist.dest or
2059// dists[1].dir.
2060func checkDistProperties(ctx *moduleContext, property string, dist *Dist) {
2061 if dist.Dest != nil {
2062 _, err := validateSafePath(*dist.Dest)
2063 if err != nil {
2064 ctx.PropertyErrorf(property+".dest", "%s", err.Error())
2065 }
2066 }
2067 if dist.Dir != nil {
2068 _, err := validateSafePath(*dist.Dir)
2069 if err != nil {
2070 ctx.PropertyErrorf(property+".dir", "%s", err.Error())
2071 }
2072 }
2073 if dist.Suffix != nil {
2074 if strings.Contains(*dist.Suffix, "/") {
2075 ctx.PropertyErrorf(property+".suffix", "Suffix may not contain a '/' character.")
2076 }
2077 }
2078
2079}
2080
Colin Cross6301c3c2021-09-28 17:40:21 -07002081// katiInstall stores a request from Soong to Make to create an install rule.
2082type katiInstall struct {
2083 from Path
2084 to InstallPath
2085 implicitDeps Paths
2086 orderOnlyDeps Paths
2087 executable bool
Colin Cross50ed1f92021-11-12 17:41:02 -08002088 extraFiles *extraFilesZip
Colin Cross6301c3c2021-09-28 17:40:21 -07002089
2090 absFrom string
2091}
2092
Colin Cross50ed1f92021-11-12 17:41:02 -08002093type extraFilesZip struct {
2094 zip Path
2095 dir InstallPath
2096}
2097
Colin Cross6301c3c2021-09-28 17:40:21 -07002098type katiInstalls []katiInstall
2099
2100// BuiltInstalled returns the katiInstalls in the form used by $(call copy-many-files) in Make, a
2101// space separated list of from:to tuples.
2102func (installs katiInstalls) BuiltInstalled() string {
2103 sb := strings.Builder{}
2104 for i, install := range installs {
2105 if i != 0 {
2106 sb.WriteRune(' ')
2107 }
2108 sb.WriteString(install.from.String())
2109 sb.WriteRune(':')
2110 sb.WriteString(install.to.String())
2111 }
2112 return sb.String()
2113}
2114
2115// InstallPaths returns the install path of each entry.
2116func (installs katiInstalls) InstallPaths() InstallPaths {
2117 paths := make(InstallPaths, 0, len(installs))
2118 for _, install := range installs {
2119 paths = append(paths, install.to)
2120 }
2121 return paths
2122}
2123
Jiyong Park5baac542018-08-28 09:55:37 +09002124// Makes this module a platform module, i.e. not specific to soc, device,
Justin Yund5f6c822019-06-25 16:47:17 +09002125// product, or system_ext.
Colin Cross4157e882019-06-06 16:57:04 -07002126func (m *ModuleBase) MakeAsPlatform() {
2127 m.commonProperties.Vendor = boolPtr(false)
2128 m.commonProperties.Proprietary = boolPtr(false)
2129 m.commonProperties.Soc_specific = boolPtr(false)
2130 m.commonProperties.Product_specific = boolPtr(false)
Justin Yund5f6c822019-06-25 16:47:17 +09002131 m.commonProperties.System_ext_specific = boolPtr(false)
Jiyong Park5baac542018-08-28 09:55:37 +09002132}
2133
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002134func (m *ModuleBase) MakeAsSystemExt() {
Jooyung Han91df2082019-11-20 01:49:42 +09002135 m.commonProperties.Vendor = boolPtr(false)
2136 m.commonProperties.Proprietary = boolPtr(false)
2137 m.commonProperties.Soc_specific = boolPtr(false)
2138 m.commonProperties.Product_specific = boolPtr(false)
2139 m.commonProperties.System_ext_specific = boolPtr(true)
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002140}
2141
Jooyung Han344d5432019-08-23 11:17:39 +09002142// IsNativeBridgeSupported returns true if "native_bridge_supported" is explicitly set as "true"
2143func (m *ModuleBase) IsNativeBridgeSupported() bool {
2144 return proptools.Bool(m.commonProperties.Native_bridge_supported)
2145}
2146
Cole Faust02987bd2024-03-21 17:58:43 -07002147type ConfigAndErrorContext interface {
2148 Config() Config
2149 OtherModulePropertyErrorf(module Module, property string, fmt string, args ...interface{})
2150}
2151
2152type configurationEvalutor struct {
2153 ctx ConfigAndErrorContext
2154 m Module
2155}
2156
2157func (m *ModuleBase) ConfigurableEvaluator(ctx ConfigAndErrorContext) proptools.ConfigurableEvaluator {
2158 return configurationEvalutor{
2159 ctx: ctx,
2160 m: m.module,
2161 }
2162}
2163
2164func (e configurationEvalutor) PropertyErrorf(property string, fmt string, args ...interface{}) {
Cole Fausta963b942024-04-11 17:43:00 -07002165 e.ctx.OtherModulePropertyErrorf(e.m, property, fmt, args...)
Cole Faust02987bd2024-03-21 17:58:43 -07002166}
2167
Cole Faustfdbf5d42024-04-10 15:01:23 -07002168func (e configurationEvalutor) EvaluateConfiguration(condition proptools.ConfigurableCondition, property string) proptools.ConfigurableValue {
Cole Faust02987bd2024-03-21 17:58:43 -07002169 ctx := e.ctx
2170 m := e.m
Cole Faust8afc5142024-04-26 16:30:19 -07002171 switch condition.FunctionName() {
Cole Fauste19f7412024-05-09 15:14:04 -07002172 case "release_flag":
Cole Faust8afc5142024-04-26 16:30:19 -07002173 if condition.NumArgs() != 1 {
Cole Fauste19f7412024-05-09 15:14:04 -07002174 ctx.OtherModulePropertyErrorf(m, property, "release_flag requires 1 argument, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002175 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002176 }
Cole Faust751a4a52024-05-21 16:51:59 -07002177 if ty, ok := ctx.Config().productVariables.BuildFlagTypes[condition.Arg(0)]; ok {
2178 v := ctx.Config().productVariables.BuildFlags[condition.Arg(0)]
2179 switch ty {
2180 case "unspecified", "obsolete":
2181 return proptools.ConfigurableValueUndefined()
2182 case "string":
2183 return proptools.ConfigurableValueString(v)
2184 case "bool":
2185 return proptools.ConfigurableValueBool(v == "true")
2186 default:
2187 panic("unhandled release flag type: " + ty)
2188 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002189 }
2190 return proptools.ConfigurableValueUndefined()
2191 case "product_variable":
Jiyong Parke3250752024-05-17 14:56:10 +09002192 if condition.NumArgs() != 1 {
2193 ctx.OtherModulePropertyErrorf(m, property, "product_variable requires 1 argument, found %d", condition.NumArgs())
2194 return proptools.ConfigurableValueUndefined()
2195 }
2196 variable := condition.Arg(0)
2197 switch variable {
2198 case "debuggable":
2199 return proptools.ConfigurableValueBool(ctx.Config().Debuggable())
2200 default:
2201 // TODO(b/323382414): Might add these on a case-by-case basis
2202 ctx.OtherModulePropertyErrorf(m, property, fmt.Sprintf("TODO(b/323382414): Product variable %q is not yet supported in selects", variable))
2203 return proptools.ConfigurableValueUndefined()
2204 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002205 case "soong_config_variable":
Cole Faust8afc5142024-04-26 16:30:19 -07002206 if condition.NumArgs() != 2 {
2207 ctx.OtherModulePropertyErrorf(m, property, "soong_config_variable requires 2 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002208 return proptools.ConfigurableValueUndefined()
2209 }
Cole Faust8afc5142024-04-26 16:30:19 -07002210 namespace := condition.Arg(0)
2211 variable := condition.Arg(1)
Cole Faust02987bd2024-03-21 17:58:43 -07002212 if n, ok := ctx.Config().productVariables.VendorVars[namespace]; ok {
2213 if v, ok := n[variable]; ok {
Cole Faust46f6e2f2024-06-20 12:57:43 -07002214 ty := ""
2215 if namespaces, ok := ctx.Config().productVariables.VendorVarTypes[namespace]; ok {
2216 ty = namespaces[variable]
2217 }
2218 switch ty {
2219 case "":
2220 // strings are the default, we don't bother writing them to the soong variables json file
2221 return proptools.ConfigurableValueString(v)
2222 case "bool":
2223 return proptools.ConfigurableValueBool(v == "true")
2224 default:
2225 panic("unhandled soong config variable type: " + ty)
2226 }
2227
Cole Faust02987bd2024-03-21 17:58:43 -07002228 }
2229 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002230 return proptools.ConfigurableValueUndefined()
Cole Faustfc57d402024-04-11 12:09:44 -07002231 case "arch":
Cole Faust8afc5142024-04-26 16:30:19 -07002232 if condition.NumArgs() != 0 {
2233 ctx.OtherModulePropertyErrorf(m, property, "arch requires no arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002234 return proptools.ConfigurableValueUndefined()
2235 }
Cole Faustfc57d402024-04-11 12:09:44 -07002236 if !m.base().ArchReady() {
2237 ctx.OtherModulePropertyErrorf(m, property, "A select on arch was attempted before the arch mutator ran")
2238 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002239 }
Cole Faustfc57d402024-04-11 12:09:44 -07002240 return proptools.ConfigurableValueString(m.base().Arch().ArchType.Name)
2241 case "os":
Cole Faust8afc5142024-04-26 16:30:19 -07002242 if condition.NumArgs() != 0 {
2243 ctx.OtherModulePropertyErrorf(m, property, "os requires no arguments, found %d", condition.NumArgs())
Cole Faustfc57d402024-04-11 12:09:44 -07002244 return proptools.ConfigurableValueUndefined()
2245 }
2246 // the arch mutator runs after the os mutator, we can just use this to enforce that os is ready.
2247 if !m.base().ArchReady() {
2248 ctx.OtherModulePropertyErrorf(m, property, "A select on os was attempted before the arch mutator ran (arch runs after os, we use it to lazily detect that os is ready)")
2249 return proptools.ConfigurableValueUndefined()
2250 }
2251 return proptools.ConfigurableValueString(m.base().Os().Name)
Cole Faustfdbf5d42024-04-10 15:01:23 -07002252 case "boolean_var_for_testing":
2253 // We currently don't have any other boolean variables (we should add support for typing
2254 // the soong config variables), so add this fake one for testing the boolean select
2255 // functionality.
Cole Faust8afc5142024-04-26 16:30:19 -07002256 if condition.NumArgs() != 0 {
2257 ctx.OtherModulePropertyErrorf(m, property, "boolean_var_for_testing requires 0 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002258 return proptools.ConfigurableValueUndefined()
2259 }
2260
2261 if n, ok := ctx.Config().productVariables.VendorVars["boolean_var"]; ok {
2262 if v, ok := n["for_testing"]; ok {
2263 switch v {
2264 case "true":
2265 return proptools.ConfigurableValueBool(true)
2266 case "false":
2267 return proptools.ConfigurableValueBool(false)
2268 default:
2269 ctx.OtherModulePropertyErrorf(m, property, "testing:my_boolean_var can only be true or false, found %q", v)
2270 }
2271 }
2272 }
2273 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002274 default:
Cole Faustfdbf5d42024-04-10 15:01:23 -07002275 ctx.OtherModulePropertyErrorf(m, property, "Unknown select condition %s", condition.FunctionName)
2276 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002277 }
2278}
2279
Colin Crossb63d7b32023-12-07 16:54:51 -08002280// ModuleNameWithPossibleOverride returns the name of the OverrideModule that overrides the current
2281// variant of this OverridableModule, or ctx.ModuleName() if this module is not an OverridableModule
2282// or if this variant is not overridden.
2283func ModuleNameWithPossibleOverride(ctx BaseModuleContext) string {
2284 if overridable, ok := ctx.Module().(OverridableModule); ok {
2285 if o := overridable.GetOverriddenBy(); o != "" {
2286 return o
2287 }
2288 }
2289 return ctx.ModuleName()
2290}
2291
Paul Duffine6ba0722021-07-12 20:12:12 +01002292// SrcIsModule decodes module references in the format ":unqualified-name" or "//namespace:name"
2293// into the module name, or empty string if the input was not a module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002294func SrcIsModule(s string) (module string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002295 if len(s) > 1 {
2296 if s[0] == ':' {
2297 module = s[1:]
2298 if !isUnqualifiedModuleName(module) {
2299 // The module name should be unqualified but is not so do not treat it as a module.
2300 module = ""
2301 }
2302 } else if s[0] == '/' && s[1] == '/' {
2303 module = s
2304 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002305 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002306 return module
Colin Cross068e0fe2016-12-13 15:23:47 -08002307}
2308
Yi-Yo Chiangba9ea322021-07-15 17:18:21 +08002309// SrcIsModuleWithTag decodes module references in the format ":unqualified-name{.tag}" or
2310// "//namespace:name{.tag}" into the module name and tag, ":unqualified-name" or "//namespace:name"
2311// into the module name and an empty string for the tag, or empty strings if the input was not a
2312// module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002313func SrcIsModuleWithTag(s string) (module, tag string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002314 if len(s) > 1 {
2315 if s[0] == ':' {
2316 module = s[1:]
2317 } else if s[0] == '/' && s[1] == '/' {
2318 module = s
2319 }
2320
2321 if module != "" {
2322 if tagStart := strings.IndexByte(module, '{'); tagStart > 0 {
2323 if module[len(module)-1] == '}' {
2324 tag = module[tagStart+1 : len(module)-1]
2325 module = module[:tagStart]
2326 }
2327 }
2328
2329 if s[0] == ':' && !isUnqualifiedModuleName(module) {
2330 // The module name should be unqualified but is not so do not treat it as a module.
2331 module = ""
2332 tag = ""
Colin Cross41955e82019-05-29 14:40:35 -07002333 }
2334 }
Colin Cross41955e82019-05-29 14:40:35 -07002335 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002336
2337 return module, tag
2338}
2339
2340// isUnqualifiedModuleName makes sure that the supplied module is an unqualified module name, i.e.
2341// does not contain any /.
2342func isUnqualifiedModuleName(module string) bool {
2343 return strings.IndexByte(module, '/') == -1
Colin Cross068e0fe2016-12-13 15:23:47 -08002344}
2345
Paul Duffin40131a32021-07-09 17:10:35 +01002346// sourceOrOutputDependencyTag is the dependency tag added automatically by pathDepsMutator for any
2347// module reference in a property annotated with `android:"path"` or passed to ExtractSourceDeps
2348// or ExtractSourcesDeps.
2349//
2350// If uniquely identifies the dependency that was added as it contains both the module name used to
2351// add the dependency as well as the tag. That makes it very simple to find the matching dependency
2352// in GetModuleFromPathDep as all it needs to do is find the dependency whose tag matches the tag
2353// used to add it. It does not need to check that the module name as returned by one of
2354// Module.Name(), BaseModuleContext.OtherModuleName() or ModuleBase.BaseModuleName() matches the
2355// name supplied in the tag. That means it does not need to handle differences in module names
2356// caused by prebuilt_ prefix, or fully qualified module names.
Colin Cross41955e82019-05-29 14:40:35 -07002357type sourceOrOutputDependencyTag struct {
2358 blueprint.BaseDependencyTag
Yu Liu67a28422024-03-05 00:36:31 +00002359 AlwaysPropagateAconfigValidationDependencyTag
Paul Duffin40131a32021-07-09 17:10:35 +01002360
2361 // The name of the module.
2362 moduleName string
2363
mrziwangd38e63d2024-07-15 13:43:37 -07002364 // The tag that will be used to get the specific output file(s).
Colin Cross41955e82019-05-29 14:40:35 -07002365 tag string
2366}
2367
Paul Duffin40131a32021-07-09 17:10:35 +01002368func sourceOrOutputDepTag(moduleName, tag string) blueprint.DependencyTag {
2369 return sourceOrOutputDependencyTag{moduleName: moduleName, tag: tag}
Colin Cross41955e82019-05-29 14:40:35 -07002370}
2371
Paul Duffind5cf92e2021-07-09 17:38:55 +01002372// IsSourceDepTagWithOutputTag returns true if the supplied blueprint.DependencyTag is one that was
2373// used to add dependencies by either ExtractSourceDeps, ExtractSourcesDeps or automatically for
2374// properties tagged with `android:"path"` AND it was added using a module reference of
2375// :moduleName{outputTag}.
2376func IsSourceDepTagWithOutputTag(depTag blueprint.DependencyTag, outputTag string) bool {
2377 t, ok := depTag.(sourceOrOutputDependencyTag)
2378 return ok && t.tag == outputTag
2379}
2380
Colin Cross366938f2017-12-11 16:29:02 -08002381// Adds necessary dependencies to satisfy filegroup or generated sources modules listed in srcFiles
2382// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002383//
2384// Deprecated: tag the property with `android:"path"` instead.
Colin Cross068e0fe2016-12-13 15:23:47 -08002385func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) {
Nan Zhang2439eb72017-04-10 11:27:50 -07002386 set := make(map[string]bool)
2387
Colin Cross068e0fe2016-12-13 15:23:47 -08002388 for _, s := range srcFiles {
Colin Cross41955e82019-05-29 14:40:35 -07002389 if m, t := SrcIsModuleWithTag(s); m != "" {
2390 if _, found := set[s]; found {
2391 ctx.ModuleErrorf("found source dependency duplicate: %q!", s)
Nan Zhang2439eb72017-04-10 11:27:50 -07002392 } else {
Colin Cross41955e82019-05-29 14:40:35 -07002393 set[s] = true
Paul Duffin40131a32021-07-09 17:10:35 +01002394 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Nan Zhang2439eb72017-04-10 11:27:50 -07002395 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002396 }
2397 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002398}
2399
Colin Cross366938f2017-12-11 16:29:02 -08002400// Adds necessary dependencies to satisfy filegroup or generated sources modules specified in s
2401// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002402//
2403// Deprecated: tag the property with `android:"path"` instead.
Colin Cross366938f2017-12-11 16:29:02 -08002404func ExtractSourceDeps(ctx BottomUpMutatorContext, s *string) {
2405 if s != nil {
Colin Cross41955e82019-05-29 14:40:35 -07002406 if m, t := SrcIsModuleWithTag(*s); m != "" {
Paul Duffin40131a32021-07-09 17:10:35 +01002407 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Colin Cross366938f2017-12-11 16:29:02 -08002408 }
2409 }
2410}
2411
Colin Cross41955e82019-05-29 14:40:35 -07002412// A module that implements SourceFileProducer can be referenced from any property that is tagged with `android:"path"`
2413// using the ":module" syntax and provides a list of paths to be used as if they were listed in the property.
Colin Cross068e0fe2016-12-13 15:23:47 -08002414type SourceFileProducer interface {
2415 Srcs() Paths
2416}
2417
mrziwangd38e63d2024-07-15 13:43:37 -07002418// OutputFilesForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002419// module produced zero paths, it reports errors to the ctx and returns nil.
2420func OutputFilesForModule(ctx PathContext, module blueprint.Module, tag string) Paths {
2421 paths, err := outputFilesForModule(ctx, module, tag)
2422 if err != nil {
2423 reportPathError(ctx, err)
2424 return nil
2425 }
2426 return paths
2427}
2428
mrziwangd38e63d2024-07-15 13:43:37 -07002429// OutputFileForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002430// module produced zero or multiple paths, it reports errors to the ctx and returns nil.
2431func OutputFileForModule(ctx PathContext, module blueprint.Module, tag string) Path {
2432 paths, err := outputFilesForModule(ctx, module, tag)
2433 if err != nil {
2434 reportPathError(ctx, err)
2435 return nil
2436 }
Colin Cross14ec66c2022-10-03 21:02:27 -07002437 if len(paths) == 0 {
2438 type addMissingDependenciesIntf interface {
2439 AddMissingDependencies([]string)
2440 OtherModuleName(blueprint.Module) string
2441 }
2442 if mctx, ok := ctx.(addMissingDependenciesIntf); ok && ctx.Config().AllowMissingDependencies() {
2443 mctx.AddMissingDependencies([]string{mctx.OtherModuleName(module)})
2444 } else {
2445 ReportPathErrorf(ctx, "failed to get output files from module %q", pathContextName(ctx, module))
2446 }
2447 // Return a fake output file to avoid nil dereferences of Path objects later.
2448 // This should never get used for an actual build as the error or missing
2449 // dependency has already been reported.
2450 p, err := pathForSource(ctx, filepath.Join("missing_output_file", pathContextName(ctx, module)))
2451 if err != nil {
2452 reportPathError(ctx, err)
2453 return nil
2454 }
2455 return p
2456 }
Colin Cross5e708052019-08-06 13:59:50 -07002457 if len(paths) > 1 {
Ulya Trafimovich5ab276a2020-08-25 12:45:15 +01002458 ReportPathErrorf(ctx, "got multiple output files from module %q, expected exactly one",
Colin Cross5e708052019-08-06 13:59:50 -07002459 pathContextName(ctx, module))
Colin Cross5e708052019-08-06 13:59:50 -07002460 }
2461 return paths[0]
2462}
2463
2464func outputFilesForModule(ctx PathContext, module blueprint.Module, tag string) (Paths, error) {
mrziwange6c85812024-05-22 14:36:09 -07002465 outputFilesFromProvider, err := outputFilesForModuleFromProvider(ctx, module, tag)
mrziwangabdb2932024-06-18 12:43:41 -07002466 if outputFilesFromProvider != nil || err != OutputFilesProviderNotSet {
mrziwange6c85812024-05-22 14:36:09 -07002467 return outputFilesFromProvider, err
2468 }
mrziwang1ea01e32024-07-12 12:26:34 -07002469 if sourceFileProducer, ok := module.(SourceFileProducer); ok {
Colin Cross74b1e2b2020-11-22 20:23:02 -08002470 if tag != "" {
mrziwang1ea01e32024-07-12 12:26:34 -07002471 return nil, fmt.Errorf("module %q is a SourceFileProducer, which does not support tag %q", pathContextName(ctx, module), tag)
Colin Cross74b1e2b2020-11-22 20:23:02 -08002472 }
2473 paths := sourceFileProducer.Srcs()
Colin Cross74b1e2b2020-11-22 20:23:02 -08002474 return paths, nil
Colin Cross5e708052019-08-06 13:59:50 -07002475 } else {
mrziwang68b25942024-07-11 09:58:30 -07002476 return nil, fmt.Errorf("module %q is not a SourceFileProducer or having valid output file for tag %q", pathContextName(ctx, module), tag)
Colin Cross5e708052019-08-06 13:59:50 -07002477 }
2478}
2479
mrziwange6c85812024-05-22 14:36:09 -07002480// This method uses OutputFilesProvider for output files
2481// *inter-module-communication*.
2482// If mctx module is the same as the param module the output files are obtained
2483// from outputFiles property of module base, to avoid both setting and
mrziwang42953592024-06-20 09:53:33 -07002484// reading OutputFilesProvider before GenerateBuildActions is finished.
mrziwange6c85812024-05-22 14:36:09 -07002485// If a module doesn't have the OutputFilesProvider, nil is returned.
2486func outputFilesForModuleFromProvider(ctx PathContext, module blueprint.Module, tag string) (Paths, error) {
mrziwangabdb2932024-06-18 12:43:41 -07002487 var outputFiles OutputFilesInfo
2488 fromProperty := false
mrziwang0cbd3b02024-06-20 16:39:25 -07002489
mrziwang1ea01e32024-07-12 12:26:34 -07002490 type OutputFilesProviderModuleContext interface {
2491 OtherModuleProviderContext
2492 Module() Module
2493 }
2494
2495 if mctx, isMctx := ctx.(OutputFilesProviderModuleContext); isMctx {
mrziwang0cbd3b02024-06-20 16:39:25 -07002496 if mctx.Module() != module {
mrziwangabdb2932024-06-18 12:43:41 -07002497 outputFiles, _ = OtherModuleProvider(mctx, module, OutputFilesProvider)
mrziwang0cbd3b02024-06-20 16:39:25 -07002498 } else {
mrziwangabdb2932024-06-18 12:43:41 -07002499 outputFiles = mctx.Module().base().outputFiles
2500 fromProperty = true
mrziwange6c85812024-05-22 14:36:09 -07002501 }
mrziwang0cbd3b02024-06-20 16:39:25 -07002502 } else if cta, isCta := ctx.(*singletonContextAdaptor); isCta {
2503 providerData, _ := cta.moduleProvider(module, OutputFilesProvider)
mrziwangabdb2932024-06-18 12:43:41 -07002504 outputFiles, _ = providerData.(OutputFilesInfo)
mrziwang0cbd3b02024-06-20 16:39:25 -07002505 }
2506 // TODO: Add a check for skipped context
2507
mrziwangabdb2932024-06-18 12:43:41 -07002508 if outputFiles.isEmpty() {
mrziwangabdb2932024-06-18 12:43:41 -07002509 return nil, OutputFilesProviderNotSet
2510 }
2511
2512 if tag == "" {
2513 return outputFiles.DefaultOutputFiles, nil
2514 } else if taggedOutputFiles, hasTag := outputFiles.TaggedOutputFiles[tag]; hasTag {
2515 return taggedOutputFiles, nil
2516 } else {
2517 if fromProperty {
2518 return nil, fmt.Errorf("unsupported tag %q for module getting its own output files", tag)
mrziwange6c85812024-05-22 14:36:09 -07002519 } else {
mrziwang0cbd3b02024-06-20 16:39:25 -07002520 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
mrziwange6c85812024-05-22 14:36:09 -07002521 }
2522 }
mrziwange6c85812024-05-22 14:36:09 -07002523}
2524
mrziwang0cbd3b02024-06-20 16:39:25 -07002525func (o OutputFilesInfo) isEmpty() bool {
2526 return o.DefaultOutputFiles == nil && o.TaggedOutputFiles == nil
2527}
2528
mrziwange6c85812024-05-22 14:36:09 -07002529type OutputFilesInfo struct {
2530 // default output files when tag is an empty string ""
2531 DefaultOutputFiles Paths
2532
2533 // the corresponding output files for given tags
2534 TaggedOutputFiles map[string]Paths
2535}
2536
2537var OutputFilesProvider = blueprint.NewProvider[OutputFilesInfo]()
2538
mrziwangabdb2932024-06-18 12:43:41 -07002539// This is used to mark the case where OutputFilesProvider is not set on some modules.
2540var OutputFilesProviderNotSet = fmt.Errorf("No output files from provider")
2541
Colin Cross41589502020-12-01 14:00:21 -08002542// Modules can implement HostToolProvider and return a valid OptionalPath from HostToolPath() to
2543// specify that they can be used as a tool by a genrule module.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002544type HostToolProvider interface {
Colin Crossba9e4032020-11-24 16:32:22 -08002545 Module
Colin Cross41589502020-12-01 14:00:21 -08002546 // HostToolPath returns the path to the host tool for the module if it is one, or an invalid
2547 // OptionalPath.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002548 HostToolPath() OptionalPath
2549}
2550
Colin Cross463a90e2015-06-17 14:20:06 -07002551func init() {
LaMont Jones0c10e4d2023-05-16 00:58:37 +00002552 RegisterParallelSingletonType("buildtarget", BuildTargetSingleton)
Colin Cross463a90e2015-06-17 14:20:06 -07002553}
2554
Colin Cross0875c522017-11-28 17:34:01 -08002555func BuildTargetSingleton() Singleton {
Colin Cross1f8c52b2015-06-16 16:38:17 -07002556 return &buildTargetSingleton{}
2557}
2558
Colin Cross87d8b562017-04-25 10:01:55 -07002559func parentDir(dir string) string {
2560 dir, _ = filepath.Split(dir)
2561 return filepath.Clean(dir)
2562}
2563
Colin Cross1f8c52b2015-06-16 16:38:17 -07002564type buildTargetSingleton struct{}
2565
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002566func AddAncestors(ctx SingletonContext, dirMap map[string]Paths, mmName func(string) string) ([]string, []string) {
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002567 // Ensure ancestor directories are in dirMap
2568 // Make directories build their direct subdirectories
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002569 // Returns a slice of all directories and a slice of top-level directories.
Cole Faust18994c72023-02-28 16:02:16 -08002570 dirs := SortedKeys(dirMap)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002571 for _, dir := range dirs {
2572 dir := parentDir(dir)
2573 for dir != "." && dir != "/" {
2574 if _, exists := dirMap[dir]; exists {
2575 break
2576 }
2577 dirMap[dir] = nil
2578 dir = parentDir(dir)
2579 }
2580 }
Cole Faust18994c72023-02-28 16:02:16 -08002581 dirs = SortedKeys(dirMap)
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002582 var topDirs []string
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002583 for _, dir := range dirs {
2584 p := parentDir(dir)
2585 if p != "." && p != "/" {
2586 dirMap[p] = append(dirMap[p], PathForPhony(ctx, mmName(dir)))
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002587 } else if dir != "." && dir != "/" && dir != "" {
2588 topDirs = append(topDirs, dir)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002589 }
2590 }
Cole Faust18994c72023-02-28 16:02:16 -08002591 return SortedKeys(dirMap), topDirs
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002592}
2593
Colin Cross0875c522017-11-28 17:34:01 -08002594func (c *buildTargetSingleton) GenerateBuildActions(ctx SingletonContext) {
2595 var checkbuildDeps Paths
Colin Cross1f8c52b2015-06-16 16:38:17 -07002596
Colin Crossc3d87d32020-06-04 13:25:17 -07002597 mmTarget := func(dir string) string {
2598 return "MODULES-IN-" + strings.Replace(filepath.Clean(dir), "/", "-", -1)
Colin Cross87d8b562017-04-25 10:01:55 -07002599 }
2600
Colin Cross0875c522017-11-28 17:34:01 -08002601 modulesInDir := make(map[string]Paths)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002602
Colin Cross0875c522017-11-28 17:34:01 -08002603 ctx.VisitAllModules(func(module Module) {
2604 blueprintDir := module.base().blueprintDir
2605 installTarget := module.base().installTarget
2606 checkbuildTarget := module.base().checkbuildTarget
Colin Cross1f8c52b2015-06-16 16:38:17 -07002607
Colin Cross0875c522017-11-28 17:34:01 -08002608 if checkbuildTarget != nil {
2609 checkbuildDeps = append(checkbuildDeps, checkbuildTarget)
2610 modulesInDir[blueprintDir] = append(modulesInDir[blueprintDir], checkbuildTarget)
2611 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07002612
Colin Cross0875c522017-11-28 17:34:01 -08002613 if installTarget != nil {
2614 modulesInDir[blueprintDir] = append(modulesInDir[blueprintDir], installTarget)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002615 }
2616 })
2617
Dan Willemsen5ba07e82015-12-11 13:51:06 -08002618 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05002619 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08002620 suffix = "-soong"
2621 }
2622
Colin Cross1f8c52b2015-06-16 16:38:17 -07002623 // Create a top-level checkbuild target that depends on all modules
Colin Crossc3d87d32020-06-04 13:25:17 -07002624 ctx.Phony("checkbuild"+suffix, checkbuildDeps...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002625
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002626 // Make will generate the MODULES-IN-* targets
Jingwen Chencda22c92020-11-23 00:22:30 -05002627 if ctx.Config().KatiEnabled() {
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002628 return
2629 }
2630
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002631 dirs, _ := AddAncestors(ctx, modulesInDir, mmTarget)
Colin Cross87d8b562017-04-25 10:01:55 -07002632
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002633 // Create a MODULES-IN-<directory> target that depends on all modules in a directory, and
2634 // depends on the MODULES-IN-* targets of all of its subdirectories that contain Android.bp
2635 // files.
Colin Cross1f8c52b2015-06-16 16:38:17 -07002636 for _, dir := range dirs {
Colin Crossc3d87d32020-06-04 13:25:17 -07002637 ctx.Phony(mmTarget(dir), modulesInDir[dir]...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002638 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07002639
2640 // Create (host|host-cross|target)-<OS> phony rules to build a reduced checkbuild.
Jiyong Park1613e552020-09-14 19:43:17 +09002641 type osAndCross struct {
2642 os OsType
2643 hostCross bool
2644 }
2645 osDeps := map[osAndCross]Paths{}
Colin Cross0875c522017-11-28 17:34:01 -08002646 ctx.VisitAllModules(func(module Module) {
Cole Fausta963b942024-04-11 17:43:00 -07002647 if module.Enabled(ctx) {
Jiyong Park1613e552020-09-14 19:43:17 +09002648 key := osAndCross{os: module.Target().Os, hostCross: module.Target().HostCross}
2649 osDeps[key] = append(osDeps[key], module.base().checkbuildFiles...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002650 }
2651 })
2652
Colin Cross0875c522017-11-28 17:34:01 -08002653 osClass := make(map[string]Paths)
Jiyong Park1613e552020-09-14 19:43:17 +09002654 for key, deps := range osDeps {
Dan Willemsen61d88b82017-09-20 17:29:08 -07002655 var className string
2656
Jiyong Park1613e552020-09-14 19:43:17 +09002657 switch key.os.Class {
Dan Willemsen61d88b82017-09-20 17:29:08 -07002658 case Host:
Jiyong Park1613e552020-09-14 19:43:17 +09002659 if key.hostCross {
2660 className = "host-cross"
2661 } else {
2662 className = "host"
2663 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07002664 case Device:
2665 className = "target"
2666 default:
2667 continue
2668 }
2669
Jiyong Park1613e552020-09-14 19:43:17 +09002670 name := className + "-" + key.os.Name
Colin Crossc3d87d32020-06-04 13:25:17 -07002671 osClass[className] = append(osClass[className], PathForPhony(ctx, name))
Dan Willemsen61d88b82017-09-20 17:29:08 -07002672
Colin Crossc3d87d32020-06-04 13:25:17 -07002673 ctx.Phony(name, deps...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002674 }
2675
2676 // Wrap those into host|host-cross|target phony rules
Cole Faust18994c72023-02-28 16:02:16 -08002677 for _, class := range SortedKeys(osClass) {
Colin Crossc3d87d32020-06-04 13:25:17 -07002678 ctx.Phony(class, osClass[class]...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002679 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07002680}
Colin Crossd779da42015-12-17 18:00:23 -08002681
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002682// Collect information for opening IDE project files in java/jdeps.go.
2683type IDEInfo interface {
2684 IDEInfo(ideInfo *IdeInfo)
2685 BaseModuleName() string
2686}
2687
2688// Extract the base module name from the Import name.
2689// Often the Import name has a prefix "prebuilt_".
2690// Remove the prefix explicitly if needed
2691// until we find a better solution to get the Import name.
2692type IDECustomizedModuleName interface {
2693 IDECustomizedModuleName() string
2694}
2695
2696type IdeInfo struct {
2697 Deps []string `json:"dependencies,omitempty"`
2698 Srcs []string `json:"srcs,omitempty"`
2699 Aidl_include_dirs []string `json:"aidl_include_dirs,omitempty"`
2700 Jarjar_rules []string `json:"jarjar_rules,omitempty"`
2701 Jars []string `json:"jars,omitempty"`
2702 Classes []string `json:"class,omitempty"`
2703 Installed_paths []string `json:"installed,omitempty"`
patricktu18c82ff2019-05-10 15:48:50 +08002704 SrcJars []string `json:"srcjars,omitempty"`
bralee1fbf4402020-05-21 10:11:59 +08002705 Paths []string `json:"path,omitempty"`
Yikef6282022022-04-13 20:41:01 +08002706 Static_libs []string `json:"static_libs,omitempty"`
2707 Libs []string `json:"libs,omitempty"`
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002708}
Paul Duffinf88d8e02020-05-07 20:21:34 +01002709
2710func CheckBlueprintSyntax(ctx BaseModuleContext, filename string, contents string) []error {
2711 bpctx := ctx.blueprintBaseModuleContext()
2712 return blueprint.CheckBlueprintSyntax(bpctx.ModuleFactories(), filename, contents)
2713}