blob: e4967d81c569f8167081fc4a17bbfa887fc08216 [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"
Yu Liu3cadf7d2024-10-24 18:47:06 +000027 "github.com/google/blueprint/depset"
28 "github.com/google/blueprint/gobtools"
Colin Crossfe4bc362018-09-12 10:02:13 -070029 "github.com/google/blueprint/proptools"
Colin Cross3f40fa42015-01-30 17:27:36 -080030)
31
32var (
33 DeviceSharedLibrary = "shared_library"
34 DeviceStaticLibrary = "static_library"
Joe Onorato349ae8d2024-02-05 22:46:00 +000035 jarJarPrefixHandler func(ctx ModuleContext)
Colin Cross3f40fa42015-01-30 17:27:36 -080036)
37
Colin Cross635c3b02016-05-18 15:37:25 -070038type Module interface {
Colin Cross3f40fa42015-01-30 17:27:36 -080039 blueprint.Module
40
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070041 // GenerateAndroidBuildActions is analogous to Blueprints' GenerateBuildActions,
42 // but GenerateAndroidBuildActions also has access to Android-specific information.
43 // For more information, see Module.GenerateBuildActions within Blueprint's module_ctx.go
Colin Cross635c3b02016-05-18 15:37:25 -070044 GenerateAndroidBuildActions(ModuleContext)
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -070045
Paul Duffin44f1d842020-06-26 20:17:02 +010046 // Add dependencies to the components of a module, i.e. modules that are created
47 // by the module and which are considered to be part of the creating module.
48 //
49 // This is called before prebuilts are renamed so as to allow a dependency to be
50 // added directly to a prebuilt child module instead of depending on a source module
51 // and relying on prebuilt processing to switch to the prebuilt module if preferred.
52 //
53 // A dependency on a prebuilt must include the "prebuilt_" prefix.
54 ComponentDepsMutator(ctx BottomUpMutatorContext)
55
Colin Cross1e676be2016-10-12 14:38:15 -070056 DepsMutator(BottomUpMutatorContext)
Colin Cross3f40fa42015-01-30 17:27:36 -080057
Colin Cross635c3b02016-05-18 15:37:25 -070058 base() *ModuleBase
Inseob Kimeec88e12020-01-22 11:11:29 +090059 Disable()
Cole Fauste8a87832024-09-11 11:35:46 -070060 Enabled(ctx ConfigurableEvaluatorContext) bool
Colin Crossa1ad8d12016-06-01 17:09:44 -070061 Target() Target
Paul Duffinc04fb9e2021-03-01 12:25:10 +000062 MultiTargets() []Target
Paul Duffinb42fa672021-09-09 16:37:49 +010063
64 // ImageVariation returns the image variation of this module.
65 //
66 // The returned structure has its Mutator field set to "image" and its Variation field set to the
67 // image variation, e.g. recovery, ramdisk, etc.. The Variation field is "" for host modules and
68 // device modules that have no image variation.
69 ImageVariation() blueprint.Variation
70
Anton Hansson1ee62c02020-06-30 11:51:53 +010071 Owner() string
Dan Willemsen782a2d12015-12-21 14:55:28 -080072 InstallInData() bool
Jaewoong Jung0949f312019-09-11 10:25:18 -070073 InstallInTestcases() bool
Vishwath Mohan1dd88392017-03-29 22:00:18 -070074 InstallInSanitizerDir() bool
Yifan Hong1b3348d2020-01-21 15:53:22 -080075 InstallInRamdisk() bool
Yifan Hong60e0cfb2020-10-21 15:17:56 -070076 InstallInVendorRamdisk() bool
Inseob Kim08758f02021-04-08 21:13:22 +090077 InstallInDebugRamdisk() bool
Jiyong Parkf9332f12018-02-01 00:54:12 +090078 InstallInRecovery() bool
Colin Cross90ba5f42019-10-02 11:10:58 -070079 InstallInRoot() bool
Colin Crossea30d852023-11-29 16:00:16 -080080 InstallInOdm() bool
81 InstallInProduct() bool
Kiyoung Kimae11c232021-07-19 11:38:04 +090082 InstallInVendor() bool
Spandan Das950deca2024-10-01 18:35:23 +000083 InstallInSystemExt() bool
Spandan Das27ff7672024-11-06 19:23:57 +000084 InstallInSystemDlkm() bool
85 InstallInVendorDlkm() bool
86 InstallInOdmDlkm() bool
Jiyong Park87788b52020-09-01 12:37:45 +090087 InstallForceOS() (*OsType, *ArchType)
Jiyong Parkce243632023-02-17 18:22:25 +090088 PartitionTag(DeviceConfig) string
Colin Crossa9c8c9f2020-12-16 10:20:23 -080089 HideFromMake()
90 IsHideFromMake() bool
Spandan Das034af2c2024-10-30 21:45:09 +000091 SkipInstall()
Martin Stjernholm9e7f45e2020-12-23 03:50:30 +000092 IsSkipInstall() bool
Iván Budnik295da162023-03-10 16:11:26 +000093 MakeUninstallable()
Liz Kammer5ca3a622020-08-05 15:40:41 -070094 ReplacedByPrebuilt()
95 IsReplacedByPrebuilt() bool
Jiyong Park374510b2018-03-19 18:23:01 +090096 ExportedToMake() bool
Justin Yun1871f902023-04-07 20:13:19 +090097 EffectiveLicenseKinds() []string
Justin Yun885a7de2021-06-29 20:34:53 +090098 EffectiveLicenseFiles() Paths
Colin Cross36242852017-06-23 15:06:31 -070099
100 AddProperties(props ...interface{})
101 GetProperties() []interface{}
Colin Crosscec81712017-07-13 14:43:27 -0700102
Colin Crossae887032017-10-23 17:16:14 -0700103 BuildParamsForTests() []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -0800104 RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800105 VariablesForTests() map[string]string
Paul Duffine2453c72019-05-31 14:00:04 +0100106
Colin Cross9a362232019-07-01 15:32:45 -0700107 // String returns a string that includes the module name and variants for printing during debugging.
108 String() string
109
Paul Duffine2453c72019-05-31 14:00:04 +0100110 // Get the qualified module id for this module.
111 qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName
112
113 // Get information about the properties that can contain visibility rules.
114 visibilityProperties() []visibilityProperty
Paul Duffin63c6e182019-07-24 14:24:38 +0100115
Cole Fauste8a87832024-09-11 11:35:46 -0700116 RequiredModuleNames(ctx ConfigurableEvaluatorContext) []string
Jiyong Park6a8cf5f2019-12-30 16:31:09 +0900117 HostRequiredModuleNames() []string
118 TargetRequiredModuleNames() []string
Cole Fauste8a87832024-09-11 11:35:46 -0700119 VintfFragmentModuleNames(ctx ConfigurableEvaluatorContext) []string
Kiyoung Kim23be5bb2024-11-27 00:50:30 +0000120 VintfFragments(ctx ConfigurableEvaluatorContext) []string
Colin Cross897266e2020-02-13 13:22:08 -0800121
Cole Fauste8a87832024-09-11 11:35:46 -0700122 ConfigurableEvaluator(ctx ConfigurableEvaluatorContext) proptools.ConfigurableEvaluator
Jihoon Kang0d545b82024-10-11 00:21:57 +0000123
124 // The usage of this method is experimental and should not be used outside of fsgen package.
125 // This will be removed once product packaging migration to Soong is complete.
126 DecodeMultilib(ctx ConfigContext) (string, string)
Spandan Dase1860e42024-10-24 22:29:50 +0000127
128 // WARNING: This should not be used outside build/soong/fsgen
129 // Overrides returns the list of modules which should not be installed if this module is installed.
130 Overrides() []string
Paul Duffine2453c72019-05-31 14:00:04 +0100131}
132
133// Qualified id for a module
134type qualifiedModuleName struct {
135 // The package (i.e. directory) in which the module is defined, without trailing /
136 pkg string
137
138 // The name of the module, empty string if package.
139 name string
140}
141
142func (q qualifiedModuleName) String() string {
143 if q.name == "" {
144 return "//" + q.pkg
145 }
146 return "//" + q.pkg + ":" + q.name
147}
148
Paul Duffine484f472019-06-20 16:38:08 +0100149func (q qualifiedModuleName) isRootPackage() bool {
150 return q.pkg == "" && q.name == ""
151}
152
Paul Duffine2453c72019-05-31 14:00:04 +0100153// Get the id for the package containing this module.
154func (q qualifiedModuleName) getContainingPackageId() qualifiedModuleName {
155 pkg := q.pkg
156 if q.name == "" {
Paul Duffine484f472019-06-20 16:38:08 +0100157 if pkg == "" {
158 panic(fmt.Errorf("Cannot get containing package id of root package"))
159 }
160
161 index := strings.LastIndex(pkg, "/")
162 if index == -1 {
163 pkg = ""
164 } else {
165 pkg = pkg[:index]
166 }
Paul Duffine2453c72019-05-31 14:00:04 +0100167 }
168 return newPackageId(pkg)
169}
170
171func newPackageId(pkg string) qualifiedModuleName {
172 // A qualified id for a package module has no name.
173 return qualifiedModuleName{pkg: pkg, name: ""}
Colin Cross3f40fa42015-01-30 17:27:36 -0800174}
175
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000176type Dist struct {
177 // Copy the output of this module to the $DIST_DIR when `dist` is specified on the
178 // command line and any of these targets are also on the command line, or otherwise
179 // built
180 Targets []string `android:"arch_variant"`
181
182 // The name of the output artifact. This defaults to the basename of the output of
183 // the module.
184 Dest *string `android:"arch_variant"`
185
186 // The directory within the dist directory to store the artifact. Defaults to the
187 // top level directory ("").
188 Dir *string `android:"arch_variant"`
189
190 // A suffix to add to the artifact file name (before any extension).
191 Suffix *string `android:"arch_variant"`
192
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000193 // If true, then the artifact file will be appended with _<product name>. For
194 // example, if the product is coral and the module is an android_app module
195 // of name foo, then the artifact would be foo_coral.apk. If false, there is
196 // no change to the artifact file name.
197 Append_artifact_with_product *bool `android:"arch_variant"`
198
Paul Duffin74f05592020-11-25 16:37:46 +0000199 // A string tag to select the OutputFiles associated with the tag.
200 //
201 // If no tag is specified then it will select the default dist paths provided
202 // by the module type. If a tag of "" is specified then it will return the
203 // default output files provided by the modules, i.e. the result of calling
204 // OutputFiles("").
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000205 Tag *string `android:"arch_variant"`
206}
207
Bob Badour4101c712022-02-09 11:54:35 -0800208// NamedPath associates a path with a name. e.g. a license text path with a package name
209type NamedPath struct {
210 Path Path
211 Name string
212}
213
214// String returns an escaped string representing the `NamedPath`.
215func (p NamedPath) String() string {
216 if len(p.Name) > 0 {
217 return p.Path.String() + ":" + url.QueryEscape(p.Name)
218 }
219 return p.Path.String()
220}
221
222// NamedPaths describes a list of paths each associated with a name.
223type NamedPaths []NamedPath
224
225// Strings returns a list of escaped strings representing each `NamedPath` in the list.
226func (l NamedPaths) Strings() []string {
227 result := make([]string, 0, len(l))
228 for _, p := range l {
229 result = append(result, p.String())
230 }
231 return result
232}
233
234// SortedUniqueNamedPaths modifies `l` in place to return the sorted unique subset.
235func SortedUniqueNamedPaths(l NamedPaths) NamedPaths {
236 if len(l) == 0 {
237 return l
238 }
239 sort.Slice(l, func(i, j int) bool {
240 return l[i].String() < l[j].String()
241 })
242 k := 0
243 for i := 1; i < len(l); i++ {
244 if l[i].String() == l[k].String() {
245 continue
246 }
247 k++
248 if k < i {
249 l[k] = l[i]
250 }
251 }
252 return l[:k+1]
253}
254
Colin Crossfc754582016-05-17 16:34:16 -0700255type nameProperties struct {
256 // The name of the module. Must be unique across all modules.
Nan Zhang0007d812017-11-07 10:57:05 -0800257 Name *string
Colin Crossfc754582016-05-17 16:34:16 -0700258}
259
Colin Cross08d6f8f2020-11-19 02:33:19 +0000260type commonProperties struct {
Dan Willemsen0effe062015-11-30 16:06:01 -0800261 // emit build rules for this module
Paul Duffin54d9bb72020-02-12 10:20:56 +0000262 //
263 // Disabling a module should only be done for those modules that cannot be built
264 // in the current environment. Modules that can build in the current environment
265 // but are not usually required (e.g. superceded by a prebuilt) should not be
266 // disabled as that will prevent them from being built by the checkbuild target
267 // and so prevent early detection of changes that have broken those modules.
Cole Fausta963b942024-04-11 17:43:00 -0700268 Enabled proptools.Configurable[bool] `android:"arch_variant,replace_instead_of_append"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800269
Paul Duffin2e61fa62019-03-28 14:10:57 +0000270 // Controls the visibility of this module to other modules. Allowable values are one or more of
271 // these formats:
272 //
273 // ["//visibility:public"]: Anyone can use this module.
274 // ["//visibility:private"]: Only rules in the module's package (not its subpackages) can use
275 // this module.
Paul Duffin51084ff2020-05-05 19:19:22 +0100276 // ["//visibility:override"]: Discards any rules inherited from defaults or a creating module.
277 // Can only be used at the beginning of a list of visibility rules.
Paul Duffin2e61fa62019-03-28 14:10:57 +0000278 // ["//some/package:__pkg__", "//other/package:__pkg__"]: Only modules in some/package and
279 // other/package (defined in some/package/*.bp and other/package/*.bp) have access to
280 // this module. Note that sub-packages do not have access to the rule; for example,
281 // //some/package/foo:bar or //other/package/testing:bla wouldn't have access. __pkg__
282 // is a special module and must be used verbatim. It represents all of the modules in the
283 // package.
284 // ["//project:__subpackages__", "//other:__subpackages__"]: Only modules in packages project
285 // or other or in one of their sub-packages have access to this module. For example,
286 // //project:rule, //project/library:lib or //other/testing/internal:munge are allowed
287 // to depend on this rule (but not //independent:evil)
288 // ["//project"]: This is shorthand for ["//project:__pkg__"]
289 // [":__subpackages__"]: This is shorthand for ["//project:__subpackages__"] where
290 // //project is the module's package. e.g. using [":__subpackages__"] in
291 // packages/apps/Settings/Android.bp is equivalent to
292 // //packages/apps/Settings:__subpackages__.
293 // ["//visibility:legacy_public"]: The default visibility, behaves as //visibility:public
294 // for now. It is an error if it is used in a module.
Paul Duffine2453c72019-05-31 14:00:04 +0100295 //
296 // If a module does not specify the `visibility` property then it uses the
297 // `default_visibility` property of the `package` module in the module's package.
298 //
299 // If the `default_visibility` property is not set for the module's package then
Paul Duffine484f472019-06-20 16:38:08 +0100300 // it will use the `default_visibility` of its closest ancestor package for which
301 // a `default_visibility` property is specified.
302 //
303 // If no `default_visibility` property can be found then the module uses the
304 // global default of `//visibility:legacy_public`.
Paul Duffine2453c72019-05-31 14:00:04 +0100305 //
Paul Duffin95d53b52019-07-24 13:45:05 +0100306 // The `visibility` property has no effect on a defaults module although it does
307 // apply to any non-defaults module that uses it. To set the visibility of a
308 // defaults module, use the `defaults_visibility` property on the defaults module;
309 // not to be confused with the `default_visibility` property on the package module.
310 //
Elliott Hughes10363162024-01-09 22:02:03 +0000311 // See https://android.googlesource.com/platform/build/soong/+/main/README.md#visibility for
Paul Duffin2e61fa62019-03-28 14:10:57 +0000312 // more details.
313 Visibility []string
314
Bob Badour37af0462021-01-07 03:34:31 +0000315 // Describes the licenses applicable to this module. Must reference license modules.
316 Licenses []string
317
318 // Flattened from direct license dependencies. Equal to Licenses unless particular module adds more.
319 Effective_licenses []string `blueprint:"mutated"`
320 // Override of module name when reporting licenses
321 Effective_package_name *string `blueprint:"mutated"`
322 // Notice files
Bob Badour4101c712022-02-09 11:54:35 -0800323 Effective_license_text NamedPaths `blueprint:"mutated"`
Bob Badour37af0462021-01-07 03:34:31 +0000324 // License names
325 Effective_license_kinds []string `blueprint:"mutated"`
326 // License conditions
327 Effective_license_conditions []string `blueprint:"mutated"`
328
Colin Cross7d5136f2015-05-11 13:39:40 -0700329 // control whether this module compiles for 32-bit, 64-bit, or both. Possible values
Colin Cross3f40fa42015-01-30 17:27:36 -0800330 // are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
331 // 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 +0000332 // platform).
Colin Cross7d716ba2017-11-01 10:38:29 -0700333 Compile_multilib *string `android:"arch_variant"`
Colin Cross69617d32016-09-06 10:39:07 -0700334
335 Target struct {
336 Host struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700337 Compile_multilib *string
Colin Cross69617d32016-09-06 10:39:07 -0700338 }
339 Android struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700340 Compile_multilib *string
Spandan Dasef569082024-11-18 19:22:39 +0000341 Enabled *bool
Colin Cross69617d32016-09-06 10:39:07 -0700342 }
343 }
344
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000345 // If set to true then the archMutator will create variants for each arch specific target
346 // (e.g. 32/64) that the module is required to produce. If set to false then it will only
347 // create a variant for the architecture and will list the additional arch specific targets
348 // that the variant needs to produce in the CompileMultiTargets property.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700349 UseTargetVariants bool `blueprint:"mutated"`
350 Default_multilib string `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800351
Dan Willemsen782a2d12015-12-21 14:55:28 -0800352 // whether this is a proprietary vendor module, and should be installed into /vendor
Colin Cross7d716ba2017-11-01 10:38:29 -0700353 Proprietary *bool
Dan Willemsen782a2d12015-12-21 14:55:28 -0800354
Colin Cross55708f32017-03-20 13:23:34 -0700355 // vendor who owns this module
Dan Willemsenefac4a82017-07-18 19:42:09 -0700356 Owner *string
Colin Cross55708f32017-03-20 13:23:34 -0700357
Jiyong Park2db76922017-11-08 16:03:48 +0900358 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
359 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
360 // Use `soc_specific` instead for better meaning.
Colin Cross7d716ba2017-11-01 10:38:29 -0700361 Vendor *bool
Dan Willemsenaa118f92017-04-06 12:49:58 -0700362
Jiyong Park2db76922017-11-08 16:03:48 +0900363 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
364 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
365 Soc_specific *bool
366
367 // whether this module is specific to a device, not only for SoC, but also for off-chip
368 // peripherals. When set to true, it is installed into /odm (or /vendor/odm if odm partition
369 // does not exist, or /system/vendor/odm if both odm and vendor partitions do not exist).
370 // This implies `soc_specific:true`.
371 Device_specific *bool
372
373 // whether this module is specific to a software configuration of a product (e.g. country,
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +0900374 // network operator, etc). When set to true, it is installed into /product (or
375 // /system/product if product partition does not exist).
Jiyong Park2db76922017-11-08 16:03:48 +0900376 Product_specific *bool
377
Justin Yund5f6c822019-06-25 16:47:17 +0900378 // whether this module extends system. When set to true, it is installed into /system_ext
379 // (or /system/system_ext if system_ext partition does not exist).
380 System_ext_specific *bool
381
Jiyong Parkf9332f12018-02-01 00:54:12 +0900382 // Whether this module is installed to recovery partition
383 Recovery *bool
384
Yifan Hong1b3348d2020-01-21 15:53:22 -0800385 // Whether this module is installed to ramdisk
386 Ramdisk *bool
387
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700388 // Whether this module is installed to vendor ramdisk
389 Vendor_ramdisk *bool
390
Inseob Kim08758f02021-04-08 21:13:22 +0900391 // Whether this module is installed to debug ramdisk
392 Debug_ramdisk *bool
393
Spandan Das27ff7672024-11-06 19:23:57 +0000394 // Install to partition system_dlkm when set to true.
395 System_dlkm_specific *bool
396
397 // Install to partition vendor_dlkm when set to true.
398 Vendor_dlkm_specific *bool
399
400 // Install to partition odm_dlkm when set to true.
401 Odm_dlkm_specific *bool
402
Jaewoong Jung8e93aba2021-03-02 16:58:08 -0800403 // Whether this module is built for non-native architectures (also known as native bridge binary)
dimitry1f33e402019-03-26 12:39:31 +0100404 Native_bridge_supported *bool `android:"arch_variant"`
405
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700406 // init.rc files to be installed if this module is installed
Inseob Kim713b87d2024-09-13 11:29:54 +0900407 Init_rc proptools.Configurable[[]string] `android:"arch_variant,path"`
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700408
Steven Moreland57a23d22018-04-04 15:42:19 -0700409 // VINTF manifest fragments to be installed if this module is installed
Inseob Kimf2237022024-07-23 13:36:31 +0900410 Vintf_fragments proptools.Configurable[[]string] `android:"path"`
Steven Moreland57a23d22018-04-04 15:42:19 -0700411
Chris Wolfe998306e2016-08-15 14:47:23 -0400412 // names of other modules to install if this module is installed
Cole Faust43ddd082024-06-17 12:32:40 -0700413 Required proptools.Configurable[[]string] `android:"arch_variant"`
Chris Wolfe998306e2016-08-15 14:47:23 -0400414
Sasha Smundakb6d23052019-04-01 18:37:36 -0700415 // names of other modules to install on host if this module is installed
416 Host_required []string `android:"arch_variant"`
417
418 // names of other modules to install on target if this module is installed
419 Target_required []string `android:"arch_variant"`
420
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000421 // The OsType of artifacts that this module variant is responsible for creating.
422 //
423 // Set by osMutator
424 CompileOS OsType `blueprint:"mutated"`
425
Cole Faust0aa21cc2024-03-20 12:28:03 -0700426 // Set to true after the arch mutator has run on this module and set CompileTarget,
427 // CompileMultiTargets, and CompilePrimary
428 ArchReady bool `blueprint:"mutated"`
429
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000430 // The Target of artifacts that this module variant is responsible for creating.
431 //
432 // Set by archMutator
433 CompileTarget Target `blueprint:"mutated"`
434
435 // The additional arch specific targets (e.g. 32/64 bit) that this module variant is
436 // responsible for creating.
437 //
438 // By default this is nil as, where necessary, separate variants are created for the
439 // different multilib types supported and that information is encapsulated in the
440 // CompileTarget so the module variant simply needs to create artifacts for that.
441 //
442 // However, if UseTargetVariants is set to false (e.g. by
443 // InitAndroidMultiTargetsArchModule) then no separate variants are created for the
444 // multilib targets. Instead a single variant is created for the architecture and
445 // this contains the multilib specific targets that this variant should create.
446 //
447 // Set by archMutator
Colin Crossee0bc3b2018-10-02 22:01:37 -0700448 CompileMultiTargets []Target `blueprint:"mutated"`
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000449
450 // True if the module variant's CompileTarget is the primary target
451 //
452 // Set by archMutator
453 CompilePrimary bool `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800454
455 // Set by InitAndroidModule
456 HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
Dan Willemsen0b24c742016-10-04 15:13:37 -0700457 ArchSpecific bool `blueprint:"mutated"`
Colin Crossce75d2c2016-10-06 16:12:58 -0700458
Paul Duffin1356d8c2020-02-25 19:26:33 +0000459 // If set to true then a CommonOS variant will be created which will have dependencies
460 // on all its OsType specific variants. Used by sdk/module_exports to create a snapshot
461 // that covers all os and architecture variants.
462 //
463 // The OsType specific variants can be retrieved by calling
464 // GetOsSpecificVariantsOfCommonOSVariant
465 //
466 // Set at module initialization time by calling InitCommonOSAndroidMultiTargetsArchModule
467 CreateCommonOSVariant bool `blueprint:"mutated"`
468
Jiyong Park3f627e62024-05-01 16:14:38 +0900469 // When set to true, this module is not installed to the full install path (ex: under
470 // out/target/product/<name>/<partition>). It can be installed only to the packaging
471 // modules like android_filesystem.
472 No_full_install *bool
473
Colin Crossa9c8c9f2020-12-16 10:20:23 -0800474 // When HideFromMake is set to true, no entry for this variant will be emitted in the
475 // generated Android.mk file.
476 HideFromMake bool `blueprint:"mutated"`
477
478 // When SkipInstall is set to true, calls to ctx.InstallFile, ctx.InstallExecutable,
479 // ctx.InstallSymlink and ctx.InstallAbsoluteSymlink act like calls to ctx.PackageFile
480 // and don't create a rule to install the file.
Colin Crossce75d2c2016-10-06 16:12:58 -0700481 SkipInstall bool `blueprint:"mutated"`
Jeff Gaston088e29e2017-11-29 16:47:17 -0800482
Colin Crossbd3a16b2023-04-25 11:30:51 -0700483 // UninstallableApexPlatformVariant is set by MakeUninstallable called by the apex
484 // mutator. MakeUninstallable also sets HideFromMake. UninstallableApexPlatformVariant
485 // is used to avoid adding install or packaging dependencies into libraries provided
486 // by apexes.
487 UninstallableApexPlatformVariant bool `blueprint:"mutated"`
488
Liz Kammer5ca3a622020-08-05 15:40:41 -0700489 // Whether the module has been replaced by a prebuilt
490 ReplacedByPrebuilt bool `blueprint:"mutated"`
491
Justin Yun32f053b2020-07-31 23:07:17 +0900492 // Disabled by mutators. If set to true, it overrides Enabled property.
493 ForcedDisabled bool `blueprint:"mutated"`
494
Jeff Gaston088e29e2017-11-29 16:47:17 -0800495 NamespaceExportedToMake bool `blueprint:"mutated"`
Colin Cross6c4f21f2019-06-06 15:41:36 -0700496
Liz Kammerc13f7852023-05-17 13:01:48 -0400497 MissingDeps []string `blueprint:"mutated"`
498 CheckedMissingDeps bool `blueprint:"mutated"`
Colin Cross9a362232019-07-01 15:32:45 -0700499
500 // Name and variant strings stored by mutators to enable Module.String()
501 DebugName string `blueprint:"mutated"`
502 DebugMutators []string `blueprint:"mutated"`
503 DebugVariations []string `blueprint:"mutated"`
Colin Cross7228ecd2019-11-18 16:00:16 -0800504
Colin Crossa6845402020-11-16 15:08:19 -0800505 // ImageVariation is set by ImageMutator to specify which image this variation is for,
506 // for example "" for core or "recovery" for recovery. It will often be set to one of the
507 // constants in image.go, but can also be set to a custom value by individual module types.
Colin Cross7228ecd2019-11-18 16:00:16 -0800508 ImageVariation string `blueprint:"mutated"`
Liz Kammer2ada09a2021-08-11 00:17:36 -0400509
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800510 // The team (defined by the owner/vendor) who owns the property.
511 Team *string `android:"path"`
Kiyoung Kimfaf6af32024-08-12 11:15:19 +0900512
513 // vintf_fragment Modules required from this module.
514 Vintf_fragment_modules proptools.Configurable[[]string] `android:"path"`
Jiyong Parka574d532024-08-28 18:06:43 +0900515
516 // List of module names that are prevented from being installed when this module gets
517 // installed.
518 Overrides []string
Colin Cross3f40fa42015-01-30 17:27:36 -0800519}
520
Paul Duffined875132020-09-02 13:08:57 +0100521type distProperties struct {
522 // configuration to distribute output files from this module to the distribution
523 // directory (default: $OUT/dist, configurable with $DIST_DIR)
524 Dist Dist `android:"arch_variant"`
525
526 // a list of configurations to distribute output files from this module to the
527 // distribution directory (default: $OUT/dist, configurable with $DIST_DIR)
528 Dists []Dist `android:"arch_variant"`
529}
530
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800531type TeamDepTagType struct {
532 blueprint.BaseDependencyTag
533}
534
535var teamDepTag = TeamDepTagType{}
536
Jiyong Park8bcf3c62024-03-18 18:37:10 +0900537// Dependency tag for required, host_required, and target_required modules.
538var RequiredDepTag = struct {
539 blueprint.BaseDependencyTag
540 InstallAlwaysNeededDependencyTag
541 // Requiring disabled module has been supported (as a side effect of this being implemented
542 // in Make). We may want to make it an error, but for now, let's keep the existing behavior.
543 AlwaysAllowDisabledModuleDependencyTag
544}{}
545
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800546// CommonTestOptions represents the common `test_options` properties in
547// Android.bp.
548type CommonTestOptions struct {
549 // If the test is a hostside (no device required) unittest that shall be run
550 // during presubmit check.
551 Unit_test *bool
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800552
553 // Tags provide additional metadata to customize test execution by downstream
554 // test runners. The tags have no special meaning to Soong.
555 Tags []string
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800556}
557
558// SetAndroidMkEntries sets AndroidMkEntries according to the value of base
559// `test_options`.
560func (t *CommonTestOptions) SetAndroidMkEntries(entries *AndroidMkEntries) {
561 entries.SetBoolIfTrue("LOCAL_IS_UNIT_TEST", Bool(t.Unit_test))
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800562 if len(t.Tags) > 0 {
563 entries.AddStrings("LOCAL_TEST_OPTIONS_TAGS", t.Tags...)
564 }
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800565}
566
Yu Liue70976d2024-10-15 20:45:35 +0000567func (t *CommonTestOptions) SetAndroidMkInfoEntries(entries *AndroidMkInfo) {
568 entries.SetBoolIfTrue("LOCAL_IS_UNIT_TEST", Bool(t.Unit_test))
569 if len(t.Tags) > 0 {
570 entries.AddStrings("LOCAL_TEST_OPTIONS_TAGS", t.Tags...)
571 }
572}
573
Paul Duffin74f05592020-11-25 16:37:46 +0000574// The key to use in TaggedDistFiles when a Dist structure does not specify a
575// tag property. This intentionally does not use "" as the default because that
576// would mean that an empty tag would have a different meaning when used in a dist
577// structure that when used to reference a specific set of output paths using the
578// :module{tag} syntax, which passes tag to the OutputFiles(tag) method.
579const DefaultDistTag = "<default-dist-tag>"
580
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000581// A map of OutputFile tag keys to Paths, for disting purposes.
582type TaggedDistFiles map[string]Paths
583
Paul Duffin74f05592020-11-25 16:37:46 +0000584// addPathsForTag adds a mapping from the tag to the paths. If the map is nil
585// then it will create a map, update it and then return it. If a mapping already
586// exists for the tag then the paths are appended to the end of the current list
587// of paths, ignoring any duplicates.
588func (t TaggedDistFiles) addPathsForTag(tag string, paths ...Path) TaggedDistFiles {
589 if t == nil {
590 t = make(TaggedDistFiles)
591 }
592
593 for _, distFile := range paths {
594 if distFile != nil && !t[tag].containsPath(distFile) {
595 t[tag] = append(t[tag], distFile)
596 }
597 }
598
599 return t
600}
601
602// merge merges the entries from the other TaggedDistFiles object into this one.
603// If the TaggedDistFiles is nil then it will create a new instance, merge the
604// other into it, and then return it.
605func (t TaggedDistFiles) merge(other TaggedDistFiles) TaggedDistFiles {
606 for tag, paths := range other {
607 t = t.addPathsForTag(tag, paths...)
608 }
609
610 return t
611}
612
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000613func MakeDefaultDistFiles(paths ...Path) TaggedDistFiles {
Sasha Smundake198eaf2022-08-04 13:07:02 -0700614 for _, p := range paths {
615 if p == nil {
Jingwen Chen7b27ca72020-07-24 09:13:49 +0000616 panic("The path to a dist file cannot be nil.")
617 }
618 }
619
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000620 // The default OutputFile tag is the empty "" string.
Paul Duffin74f05592020-11-25 16:37:46 +0000621 return TaggedDistFiles{DefaultDistTag: paths}
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000622}
623
Colin Cross3f40fa42015-01-30 17:27:36 -0800624type hostAndDeviceProperties struct {
Colin Cross4e81d702018-11-09 10:36:55 -0800625 // If set to true, build a variant of the module for the host. Defaults to false.
626 Host_supported *bool
627
628 // If set to true, build a variant of the module for the device. Defaults to true.
Colin Crossa4190c12016-07-12 13:11:25 -0700629 Device_supported *bool
Colin Cross3f40fa42015-01-30 17:27:36 -0800630}
631
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000632type hostCrossProperties struct {
633 // If set to true, build a variant of the module for the host cross. Defaults to true.
634 Host_cross_supported *bool
635}
636
Colin Crossc472d572015-03-17 15:06:21 -0700637type Multilib string
638
639const (
Cole Faustb9c67e22024-10-08 16:39:56 -0700640 MultilibBoth Multilib = "both"
641 MultilibFirst Multilib = "first"
642 MultilibCommon Multilib = "common"
Colin Crossc472d572015-03-17 15:06:21 -0700643)
644
Colin Crossa1ad8d12016-06-01 17:09:44 -0700645type HostOrDeviceSupported int
646
647const (
Colin Cross34037c62020-11-17 13:19:17 -0800648 hostSupported = 1 << iota
649 hostCrossSupported
650 deviceSupported
651 hostDefault
652 deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700653
654 // Host and HostCross are built by default. Device is not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800655 HostSupported = hostSupported | hostCrossSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700656
657 // Host is built by default. HostCross and Device are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800658 HostSupportedNoCross = hostSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700659
660 // Device is built by default. Host and HostCross are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800661 DeviceSupported = deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700662
Liz Kammer8631cc72021-08-23 21:12:07 +0000663 // By default, _only_ device variant is built. Device variant can be disabled with `device_supported: false`
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700664 // Host and HostCross are disabled by default and can be enabled with `host_supported: true`
Colin Cross34037c62020-11-17 13:19:17 -0800665 HostAndDeviceSupported = hostSupported | hostCrossSupported | deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700666
667 // Host, HostCross, and Device are built by default.
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700668 // Building Device can be disabled with `device_supported: false`
669 // Building Host and HostCross can be disabled with `host_supported: false`
Colin Cross34037c62020-11-17 13:19:17 -0800670 HostAndDeviceDefault = hostSupported | hostCrossSupported | hostDefault |
671 deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700672
673 // Nothing is supported. This is not exposed to the user, but used to mark a
674 // host only module as unsupported when the module type is not supported on
675 // the host OS. E.g. benchmarks are supported on Linux but not Darwin.
Colin Cross34037c62020-11-17 13:19:17 -0800676 NeitherHostNorDeviceSupported = 0
Colin Crossa1ad8d12016-06-01 17:09:44 -0700677)
678
Jiyong Park2db76922017-11-08 16:03:48 +0900679type moduleKind int
680
681const (
682 platformModule moduleKind = iota
683 deviceSpecificModule
684 socSpecificModule
685 productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +0900686 systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +0900687)
688
689func (k moduleKind) String() string {
690 switch k {
691 case platformModule:
692 return "platform"
693 case deviceSpecificModule:
694 return "device-specific"
695 case socSpecificModule:
696 return "soc-specific"
697 case productSpecificModule:
698 return "product-specific"
Justin Yund5f6c822019-06-25 16:47:17 +0900699 case systemExtSpecificModule:
700 return "systemext-specific"
Jiyong Park2db76922017-11-08 16:03:48 +0900701 default:
702 panic(fmt.Errorf("unknown module kind %d", k))
703 }
704}
705
Colin Cross9d34f352019-11-22 16:03:51 -0800706func initAndroidModuleBase(m Module) {
707 m.base().module = m
708}
709
Colin Crossa6845402020-11-16 15:08:19 -0800710// InitAndroidModule initializes the Module as an Android module that is not architecture-specific.
711// It adds the common properties, for example "name" and "enabled".
Colin Cross36242852017-06-23 15:06:31 -0700712func InitAndroidModule(m Module) {
Colin Cross9d34f352019-11-22 16:03:51 -0800713 initAndroidModuleBase(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800714 base := m.base()
Colin Cross5049f022015-03-18 13:28:46 -0700715
Colin Cross36242852017-06-23 15:06:31 -0700716 m.AddProperties(
Colin Crossfc754582016-05-17 16:34:16 -0700717 &base.nameProperties,
Paul Duffined875132020-09-02 13:08:57 +0100718 &base.commonProperties,
719 &base.distProperties)
Colin Cross18c46802019-09-24 22:19:02 -0700720
Colin Crosseabaedd2020-02-06 17:01:55 -0800721 initProductVariableModule(m)
Colin Cross18c46802019-09-24 22:19:02 -0700722
Paul Duffin63c6e182019-07-24 14:24:38 +0100723 // The default_visibility property needs to be checked and parsed by the visibility module during
Paul Duffin5ec73ec2020-05-01 17:52:01 +0100724 // its checking and parsing phases so make it the primary visibility property.
725 setPrimaryVisibilityProperty(m, "visibility", &base.commonProperties.Visibility)
Bob Badour37af0462021-01-07 03:34:31 +0000726
727 // The default_applicable_licenses property needs to be checked and parsed by the licenses module during
728 // its checking and parsing phases so make it the primary licenses property.
729 setPrimaryLicensesProperty(m, "licenses", &base.commonProperties.Licenses)
Colin Cross5049f022015-03-18 13:28:46 -0700730}
731
Colin Crossa6845402020-11-16 15:08:19 -0800732// InitAndroidArchModule initializes the Module as an Android module that is architecture-specific.
733// It adds the common properties, for example "name" and "enabled", as well as runtime generated
734// property structs for architecture-specific versions of generic properties tagged with
735// `android:"arch_variant"`.
736//
Colin Crossd079e0b2022-08-16 10:27:33 -0700737// InitAndroidModule should not be called if InitAndroidArchModule was called.
Colin Cross36242852017-06-23 15:06:31 -0700738func InitAndroidArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
739 InitAndroidModule(m)
Colin Cross5049f022015-03-18 13:28:46 -0700740
741 base := m.base()
Colin Cross3f40fa42015-01-30 17:27:36 -0800742 base.commonProperties.HostOrDeviceSupported = hod
Colin Cross69617d32016-09-06 10:39:07 -0700743 base.commonProperties.Default_multilib = string(defaultMultilib)
Dan Willemsen0b24c742016-10-04 15:13:37 -0700744 base.commonProperties.ArchSpecific = true
Colin Crossee0bc3b2018-10-02 22:01:37 -0700745 base.commonProperties.UseTargetVariants = true
Colin Cross3f40fa42015-01-30 17:27:36 -0800746
Colin Cross34037c62020-11-17 13:19:17 -0800747 if hod&hostSupported != 0 && hod&deviceSupported != 0 {
Colin Cross36242852017-06-23 15:06:31 -0700748 m.AddProperties(&base.hostAndDeviceProperties)
Colin Cross3f40fa42015-01-30 17:27:36 -0800749 }
750
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000751 if hod&hostCrossSupported != 0 {
752 m.AddProperties(&base.hostCrossProperties)
753 }
754
Colin Crossa6845402020-11-16 15:08:19 -0800755 initArchModule(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800756}
757
Colin Crossa6845402020-11-16 15:08:19 -0800758// InitAndroidMultiTargetsArchModule initializes the Module as an Android module that is
759// architecture-specific, but will only have a single variant per OS that handles all the
760// architectures simultaneously. The list of Targets that it must handle will be available from
761// ModuleContext.MultiTargets. It adds the common properties, for example "name" and "enabled", as
762// well as runtime generated property structs for architecture-specific versions of generic
763// properties tagged with `android:"arch_variant"`.
764//
765// InitAndroidModule or InitAndroidArchModule should not be called if
766// InitAndroidMultiTargetsArchModule was called.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700767func InitAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
768 InitAndroidArchModule(m, hod, defaultMultilib)
769 m.base().commonProperties.UseTargetVariants = false
770}
771
Colin Crossa6845402020-11-16 15:08:19 -0800772// InitCommonOSAndroidMultiTargetsArchModule initializes the Module as an Android module that is
773// architecture-specific, but will only have a single variant per OS that handles all the
774// architectures simultaneously, and will also have an additional CommonOS variant that has
775// dependencies on all the OS-specific variants. The list of Targets that it must handle will be
776// available from ModuleContext.MultiTargets. It adds the common properties, for example "name" and
777// "enabled", as well as runtime generated property structs for architecture-specific versions of
778// generic properties tagged with `android:"arch_variant"`.
779//
780// InitAndroidModule, InitAndroidArchModule or InitAndroidMultiTargetsArchModule should not be
781// called if InitCommonOSAndroidMultiTargetsArchModule was called.
Paul Duffin1356d8c2020-02-25 19:26:33 +0000782func InitCommonOSAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
783 InitAndroidArchModule(m, hod, defaultMultilib)
784 m.base().commonProperties.UseTargetVariants = false
785 m.base().commonProperties.CreateCommonOSVariant = true
786}
787
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800788// A ModuleBase object contains the properties that are common to all Android
Colin Cross3f40fa42015-01-30 17:27:36 -0800789// modules. It should be included as an anonymous field in every module
790// struct definition. InitAndroidModule should then be called from the module's
791// factory function, and the return values from InitAndroidModule should be
792// returned from the factory function.
793//
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800794// The ModuleBase type is responsible for implementing the GenerateBuildActions
795// method to support the blueprint.Module interface. This method will then call
796// the module's GenerateAndroidBuildActions method once for each build variant
Colin Cross25de6c32019-06-06 14:29:25 -0700797// that is to be built. GenerateAndroidBuildActions is passed a ModuleContext
798// rather than the usual blueprint.ModuleContext.
799// ModuleContext exposes extra functionality specific to the Android build
Colin Cross3f40fa42015-01-30 17:27:36 -0800800// system including details about the particular build variant that is to be
801// generated.
802//
803// For example:
804//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800805// import (
806// "android/soong/android"
807// )
Colin Cross3f40fa42015-01-30 17:27:36 -0800808//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800809// type myModule struct {
810// android.ModuleBase
811// properties struct {
812// MyProperty string
813// }
814// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800815//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800816// func NewMyModule() android.Module {
817// m := &myModule{}
818// m.AddProperties(&m.properties)
819// android.InitAndroidModule(m)
820// return m
821// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800822//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800823// func (m *myModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
824// // Get the CPU architecture for the current build variant.
825// variantArch := ctx.Arch()
Colin Cross3f40fa42015-01-30 17:27:36 -0800826//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800827// // ...
828// }
Colin Cross635c3b02016-05-18 15:37:25 -0700829type ModuleBase struct {
Colin Cross3f40fa42015-01-30 17:27:36 -0800830 // Putting the curiously recurring thing pointing to the thing that contains
831 // the thing pattern to good use.
Colin Cross36242852017-06-23 15:06:31 -0700832 // TODO: remove this
Colin Cross635c3b02016-05-18 15:37:25 -0700833 module Module
Colin Cross3f40fa42015-01-30 17:27:36 -0800834
Colin Crossfc754582016-05-17 16:34:16 -0700835 nameProperties nameProperties
Colin Cross3f40fa42015-01-30 17:27:36 -0800836 commonProperties commonProperties
Paul Duffined875132020-09-02 13:08:57 +0100837 distProperties distProperties
Colin Cross18c46802019-09-24 22:19:02 -0700838 variableProperties interface{}
Colin Cross3f40fa42015-01-30 17:27:36 -0800839 hostAndDeviceProperties hostAndDeviceProperties
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000840 hostCrossProperties hostCrossProperties
Jingwen Chen5d864492021-02-24 07:20:12 -0500841
Usta851a3272022-01-05 23:42:33 -0500842 // Arch specific versions of structs in GetProperties() prior to
843 // initialization in InitAndroidArchModule, lets call it `generalProperties`.
844 // The outer index has the same order as generalProperties and the inner index
845 // chooses the props specific to the architecture. The interface{} value is an
846 // archPropRoot that is filled with arch specific values by the arch mutator.
Jingwen Chen5d864492021-02-24 07:20:12 -0500847 archProperties [][]interface{}
848
Paul Duffin63c6e182019-07-24 14:24:38 +0100849 // Information about all the properties on the module that contains visibility rules that need
850 // checking.
851 visibilityPropertyInfo []visibilityProperty
852
853 // The primary visibility property, may be nil, that controls access to the module.
854 primaryVisibilityProperty visibilityProperty
855
Bob Badour37af0462021-01-07 03:34:31 +0000856 // The primary licenses property, may be nil, records license metadata for the module.
857 primaryLicensesProperty applicableLicensesProperty
858
Yu Liueb6d7052024-08-27 22:35:54 +0000859 noAddressSanitizer bool
Colin Cross1f8c52b2015-06-16 16:38:17 -0700860
Colin Cross178a5092016-09-13 13:42:32 -0700861 hooks hooks
Colin Cross36242852017-06-23 15:06:31 -0700862
863 registerProps []interface{}
Colin Crosscec81712017-07-13 14:43:27 -0700864
865 // For tests
Colin Crossae887032017-10-23 17:16:14 -0700866 buildParams []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -0800867 ruleParams map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800868 variables map[string]string
Colin Cross36242852017-06-23 15:06:31 -0700869}
870
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200871func (m *ModuleBase) AddJSONData(d *map[string]interface{}) {
Liz Kammer9525e712022-01-05 13:46:24 -0500872 (*d)["Android"] = map[string]interface{}{
873 // Properties set in Blueprint or in blueprint of a defaults modules
874 "SetProperties": m.propertiesWithValues(),
875 }
876}
877
878type propInfo struct {
Liz Kammer898e0762022-03-22 11:27:26 -0400879 Name string
880 Type string
881 Value string
882 Values []string
Liz Kammer9525e712022-01-05 13:46:24 -0500883}
884
885func (m *ModuleBase) propertiesWithValues() []propInfo {
886 var info []propInfo
887 props := m.GetProperties()
888
889 var propsWithValues func(name string, v reflect.Value)
890 propsWithValues = func(name string, v reflect.Value) {
891 kind := v.Kind()
892 switch kind {
893 case reflect.Ptr, reflect.Interface:
894 if v.IsNil() {
895 return
896 }
897 propsWithValues(name, v.Elem())
898 case reflect.Struct:
899 if v.IsZero() {
900 return
901 }
902 for i := 0; i < v.NumField(); i++ {
903 namePrefix := name
904 sTyp := v.Type().Field(i)
905 if proptools.ShouldSkipProperty(sTyp) {
906 continue
907 }
908 if name != "" && !strings.HasSuffix(namePrefix, ".") {
909 namePrefix += "."
910 }
911 if !proptools.IsEmbedded(sTyp) {
912 namePrefix += sTyp.Name
913 }
914 sVal := v.Field(i)
915 propsWithValues(namePrefix, sVal)
916 }
917 case reflect.Array, reflect.Slice:
918 if v.IsNil() {
919 return
920 }
921 elKind := v.Type().Elem().Kind()
Liz Kammer898e0762022-03-22 11:27:26 -0400922 info = append(info, propInfo{Name: name, Type: elKind.String() + " " + kind.String(), Values: sliceReflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500923 default:
Liz Kammer898e0762022-03-22 11:27:26 -0400924 info = append(info, propInfo{Name: name, Type: kind.String(), Value: reflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500925 }
926 }
927
928 for _, p := range props {
929 propsWithValues("", reflect.ValueOf(p).Elem())
930 }
Liz Kammer898e0762022-03-22 11:27:26 -0400931 sort.Slice(info, func(i, j int) bool {
932 return info[i].Name < info[j].Name
933 })
Liz Kammer9525e712022-01-05 13:46:24 -0500934 return info
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200935}
936
Liz Kammer898e0762022-03-22 11:27:26 -0400937func reflectionValue(value reflect.Value) string {
938 switch value.Kind() {
939 case reflect.Bool:
940 return fmt.Sprintf("%t", value.Bool())
941 case reflect.Int64:
942 return fmt.Sprintf("%d", value.Int())
943 case reflect.String:
944 return fmt.Sprintf("%s", value.String())
945 case reflect.Struct:
946 if value.IsZero() {
947 return "{}"
948 }
949 length := value.NumField()
950 vals := make([]string, length, length)
951 for i := 0; i < length; i++ {
952 sTyp := value.Type().Field(i)
953 if proptools.ShouldSkipProperty(sTyp) {
954 continue
955 }
956 name := sTyp.Name
957 vals[i] = fmt.Sprintf("%s: %s", name, reflectionValue(value.Field(i)))
958 }
959 return fmt.Sprintf("%s{%s}", value.Type(), strings.Join(vals, ", "))
960 case reflect.Array, reflect.Slice:
961 vals := sliceReflectionValue(value)
962 return fmt.Sprintf("[%s]", strings.Join(vals, ", "))
963 }
964 return ""
965}
966
967func sliceReflectionValue(value reflect.Value) []string {
968 length := value.Len()
969 vals := make([]string, length, length)
970 for i := 0; i < length; i++ {
971 vals[i] = reflectionValue(value.Index(i))
972 }
973 return vals
974}
975
Paul Duffin44f1d842020-06-26 20:17:02 +0100976func (m *ModuleBase) ComponentDepsMutator(BottomUpMutatorContext) {}
977
Colin Cross4157e882019-06-06 16:57:04 -0700978func (m *ModuleBase) DepsMutator(BottomUpMutatorContext) {}
Colin Cross5f692ec2019-02-01 16:53:07 -0800979
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800980func (m *ModuleBase) baseDepsMutator(ctx BottomUpMutatorContext) {
981 if m.Team() != "" {
982 ctx.AddDependency(ctx.Module(), teamDepTag, m.Team())
983 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +0900984
985 // TODO(jiyong): remove below case. This is to work around build errors happening
986 // on branches with reduced manifest like aosp_kernel-build-tools.
987 // In the branch, a build error occurs as follows.
988 // 1. aosp_kernel-build-tools is a reduced manifest branch. It doesn't have some git
989 // projects like external/bouncycastle
990 // 2. `boot_signer` is `required` by modules like `build_image` which is explicitly list as
991 // the top-level build goal (in the shell file that invokes Soong).
992 // 3. `boot_signer` depends on `bouncycastle-unbundled` which is in the missing git project.
993 // 4. aosp_kernel-build-tools invokes soong with `--skip-make`. Therefore, the absence of
994 // ALLOW_MISSING_DEPENDENCIES didn't cause a problem.
995 // 5. Now, since Soong understands `required` deps, it tries to build `boot_signer` and the
996 // absence of external/bouncycastle fails the build.
997 //
998 // Unfortunately, there's no way for Soong to correctly determine if it's running in a
999 // reduced manifest branch. Instead, here, we use the absence of DeviceArch or DeviceName as
1000 // a strong signal, because that's very common across reduced manifest branches.
1001 pv := ctx.Config().productVariables
1002 fullManifest := pv.DeviceArch != nil && pv.DeviceName != nil
1003 if fullManifest {
Jiyong Parkf21dd652024-04-17 05:22:37 +00001004 addRequiredDeps(ctx)
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001005 addVintfFragmentDeps(ctx)
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001006 }
1007}
1008
1009// addRequiredDeps adds required, target_required, and host_required as dependencies.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001010func addRequiredDeps(ctx BottomUpMutatorContext) {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001011 addDep := func(target Target, depName string) {
1012 if !ctx.OtherModuleExists(depName) {
1013 if ctx.Config().AllowMissingDependencies() {
1014 return
1015 }
1016 }
1017
1018 // If Android native module requires another Android native module, ensure that
1019 // they have the same bitness. This mimics the policy in select-bitness-of-required-modules
1020 // in build/make/core/main.mk.
1021 // TODO(jiyong): the Make-side does this only when the required module is a shared
1022 // library or a native test.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001023 bothInAndroid := ctx.Device() && target.Os.Class == Device
Jiyong Parkc4b1d552024-05-13 16:47:30 +09001024 nativeArch := InList(ctx.Arch().ArchType.Multilib, []string{"lib32", "lib64"}) &&
1025 InList(target.Arch.ArchType.Multilib, []string{"lib32", "lib64"})
Jiyong Parkf21dd652024-04-17 05:22:37 +00001026 sameBitness := ctx.Arch().ArchType.Multilib == target.Arch.ArchType.Multilib
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001027 if bothInAndroid && nativeArch && !sameBitness {
1028 return
1029 }
1030
Jiyong Park8db44152024-05-28 12:22:04 +09001031 // ... also don't make a dependency between native bridge arch and non-native bridge
1032 // arches. b/342945184
1033 if ctx.Target().NativeBridge != target.NativeBridge {
1034 return
1035 }
1036
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001037 variation := target.Variations()
1038 if ctx.OtherModuleFarDependencyVariantExists(variation, depName) {
1039 ctx.AddFarVariationDependencies(variation, RequiredDepTag, depName)
1040 }
1041 }
1042
Jiyong Park73e5bab2024-04-05 13:37:21 +09001043 var deviceTargets []Target
1044 deviceTargets = append(deviceTargets, ctx.Config().Targets[Android]...)
1045 deviceTargets = append(deviceTargets, ctx.Config().AndroidCommonTarget)
1046
1047 var hostTargets []Target
1048 hostTargets = append(hostTargets, ctx.Config().Targets[ctx.Config().BuildOS]...)
1049 hostTargets = append(hostTargets, ctx.Config().BuildOSCommonTarget)
1050
Jiyong Parkf21dd652024-04-17 05:22:37 +00001051 if ctx.Device() {
Cole Faust43ddd082024-06-17 12:32:40 -07001052 for _, depName := range ctx.Module().RequiredModuleNames(ctx) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001053 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001054 addDep(target, depName)
1055 }
1056 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001057 for _, depName := range ctx.Module().HostRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001058 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001059 addDep(target, depName)
1060 }
1061 }
1062 }
1063
Jiyong Parkf21dd652024-04-17 05:22:37 +00001064 if ctx.Host() {
Cole Faust43ddd082024-06-17 12:32:40 -07001065 for _, depName := range ctx.Module().RequiredModuleNames(ctx) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001066 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001067 // When a host module requires another host module, don't make a
1068 // dependency if they have different OSes (i.e. hostcross).
Jiyong Parkf21dd652024-04-17 05:22:37 +00001069 if ctx.Target().HostCross != target.HostCross {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001070 continue
1071 }
1072 addDep(target, depName)
1073 }
1074 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001075 for _, depName := range ctx.Module().TargetRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001076 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001077 addDep(target, depName)
1078 }
1079 }
1080 }
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001081}
1082
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001083var vintfDepTag = struct {
1084 blueprint.BaseDependencyTag
1085 InstallAlwaysNeededDependencyTag
1086}{}
1087
1088func addVintfFragmentDeps(ctx BottomUpMutatorContext) {
Kiyoung Kim55234812024-09-11 17:00:24 +09001089 // Vintf manifests in the recovery partition will be ignored.
1090 if !ctx.Device() || ctx.Module().InstallInRecovery() {
1091 return
1092 }
1093
1094 deviceConfig := ctx.DeviceConfig()
1095
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001096 mod := ctx.Module()
Kiyoung Kim55234812024-09-11 17:00:24 +09001097 vintfModules := ctx.AddDependency(mod, vintfDepTag, mod.VintfFragmentModuleNames(ctx)...)
1098
1099 modPartition := mod.PartitionTag(deviceConfig)
1100 for _, vintf := range vintfModules {
Cole Faust69788792024-10-10 11:00:36 -07001101 if vintf == nil {
1102 // TODO(b/372091092): Remove this. Having it gives us missing dependency errors instead
1103 // of nil pointer dereference errors, but we should resolve the missing dependencies.
1104 continue
1105 }
Kiyoung Kim55234812024-09-11 17:00:24 +09001106 if vintfModule, ok := vintf.(*vintfFragmentModule); ok {
1107 vintfPartition := vintfModule.PartitionTag(deviceConfig)
1108 if modPartition != vintfPartition {
1109 ctx.ModuleErrorf("Module %q(%q) and Vintf_fragment %q(%q) are installed to different partitions.",
1110 mod.Name(), modPartition,
1111 vintfModule.Name(), vintfPartition)
1112 }
1113 } else {
1114 ctx.ModuleErrorf("Only vintf_fragment type module should be listed in vintf_fragment_modules : %q", vintf.Name())
1115 }
1116 }
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001117}
1118
Usta355a5872021-12-01 15:16:32 -05001119// AddProperties "registers" the provided props
1120// each value in props MUST be a pointer to a struct
Colin Cross4157e882019-06-06 16:57:04 -07001121func (m *ModuleBase) AddProperties(props ...interface{}) {
1122 m.registerProps = append(m.registerProps, props...)
Colin Cross36242852017-06-23 15:06:31 -07001123}
1124
Colin Cross4157e882019-06-06 16:57:04 -07001125func (m *ModuleBase) GetProperties() []interface{} {
1126 return m.registerProps
Colin Cross3f40fa42015-01-30 17:27:36 -08001127}
1128
Colin Cross4157e882019-06-06 16:57:04 -07001129func (m *ModuleBase) BuildParamsForTests() []BuildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001130 // Expand the references to module variables like $flags[0-9]*,
1131 // so we do not need to change many existing unit tests.
1132 // This looks like undoing the shareFlags optimization in cc's
1133 // transformSourceToObj, and should only affects unit tests.
1134 vars := m.VariablesForTests()
1135 buildParams := append([]BuildParams(nil), m.buildParams...)
Sasha Smundake198eaf2022-08-04 13:07:02 -07001136 for i := range buildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001137 newArgs := make(map[string]string)
1138 for k, v := range buildParams[i].Args {
1139 newArgs[k] = v
1140 // Replaces both ${flags1} and $flags1 syntax.
1141 if strings.HasPrefix(v, "${") && strings.HasSuffix(v, "}") {
1142 if value, found := vars[v[2:len(v)-1]]; found {
1143 newArgs[k] = value
1144 }
1145 } else if strings.HasPrefix(v, "$") {
1146 if value, found := vars[v[1:]]; found {
1147 newArgs[k] = value
1148 }
1149 }
1150 }
1151 buildParams[i].Args = newArgs
1152 }
1153 return buildParams
Colin Crosscec81712017-07-13 14:43:27 -07001154}
1155
Colin Cross4157e882019-06-06 16:57:04 -07001156func (m *ModuleBase) RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams {
1157 return m.ruleParams
Colin Cross4c83e5c2019-02-25 14:54:28 -08001158}
1159
Colin Cross4157e882019-06-06 16:57:04 -07001160func (m *ModuleBase) VariablesForTests() map[string]string {
1161 return m.variables
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001162}
1163
Colin Crossce75d2c2016-10-06 16:12:58 -07001164// Name returns the name of the module. It may be overridden by individual module types, for
1165// example prebuilts will prepend prebuilt_ to the name.
Colin Cross4157e882019-06-06 16:57:04 -07001166func (m *ModuleBase) Name() string {
1167 return String(m.nameProperties.Name)
Colin Crossfc754582016-05-17 16:34:16 -07001168}
1169
Colin Cross9a362232019-07-01 15:32:45 -07001170// String returns a string that includes the module name and variants for printing during debugging.
1171func (m *ModuleBase) String() string {
1172 sb := strings.Builder{}
1173 sb.WriteString(m.commonProperties.DebugName)
1174 sb.WriteString("{")
1175 for i := range m.commonProperties.DebugMutators {
1176 if i != 0 {
1177 sb.WriteString(",")
1178 }
1179 sb.WriteString(m.commonProperties.DebugMutators[i])
1180 sb.WriteString(":")
1181 sb.WriteString(m.commonProperties.DebugVariations[i])
1182 }
1183 sb.WriteString("}")
1184 return sb.String()
1185}
1186
Colin Crossce75d2c2016-10-06 16:12:58 -07001187// BaseModuleName returns the name of the module as specified in the blueprints file.
Colin Cross4157e882019-06-06 16:57:04 -07001188func (m *ModuleBase) BaseModuleName() string {
1189 return String(m.nameProperties.Name)
Colin Crossce75d2c2016-10-06 16:12:58 -07001190}
1191
Colin Cross4157e882019-06-06 16:57:04 -07001192func (m *ModuleBase) base() *ModuleBase {
1193 return m
Colin Cross3f40fa42015-01-30 17:27:36 -08001194}
1195
Paul Duffine2453c72019-05-31 14:00:04 +01001196func (m *ModuleBase) qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName {
1197 return qualifiedModuleName{pkg: ctx.ModuleDir(), name: ctx.ModuleName()}
1198}
1199
1200func (m *ModuleBase) visibilityProperties() []visibilityProperty {
Paul Duffin63c6e182019-07-24 14:24:38 +01001201 return m.visibilityPropertyInfo
1202}
1203
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001204func (m *ModuleBase) Dists() []Dist {
Paul Duffined875132020-09-02 13:08:57 +01001205 if len(m.distProperties.Dist.Targets) > 0 {
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001206 // Make a copy of the underlying Dists slice to protect against
1207 // backing array modifications with repeated calls to this method.
Paul Duffined875132020-09-02 13:08:57 +01001208 distsCopy := append([]Dist(nil), m.distProperties.Dists...)
1209 return append(distsCopy, m.distProperties.Dist)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001210 } else {
Paul Duffined875132020-09-02 13:08:57 +01001211 return m.distProperties.Dists
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001212 }
1213}
1214
1215func (m *ModuleBase) GenerateTaggedDistFiles(ctx BaseModuleContext) TaggedDistFiles {
Paul Duffin74f05592020-11-25 16:37:46 +00001216 var distFiles TaggedDistFiles
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001217 for _, dist := range m.Dists() {
Paul Duffin74f05592020-11-25 16:37:46 +00001218 // If no tag is specified then it means to use the default dist paths so use
1219 // the special tag name which represents that.
1220 tag := proptools.StringDefault(dist.Tag, DefaultDistTag)
1221
mrziwangabdb2932024-06-18 12:43:41 -07001222 distFileForTagFromProvider, err := outputFilesForModuleFromProvider(ctx, m.module, tag)
1223 if err != OutputFilesProviderNotSet {
1224 if err != nil && tag != DefaultDistTag {
1225 ctx.PropertyErrorf("dist.tag", "%s", err.Error())
1226 } else {
1227 distFiles = distFiles.addPathsForTag(tag, distFileForTagFromProvider...)
1228 continue
1229 }
1230 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001231 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001232 return distFiles
1233}
1234
Cole Faust02987bd2024-03-21 17:58:43 -07001235func (m *ModuleBase) ArchReady() bool {
1236 return m.commonProperties.ArchReady
1237}
1238
Colin Cross4157e882019-06-06 16:57:04 -07001239func (m *ModuleBase) Target() Target {
1240 return m.commonProperties.CompileTarget
Dan Willemsen490fd492015-11-24 17:53:15 -08001241}
1242
Colin Cross4157e882019-06-06 16:57:04 -07001243func (m *ModuleBase) TargetPrimary() bool {
1244 return m.commonProperties.CompilePrimary
Colin Cross8b74d172016-09-13 09:59:14 -07001245}
1246
Colin Cross4157e882019-06-06 16:57:04 -07001247func (m *ModuleBase) MultiTargets() []Target {
1248 return m.commonProperties.CompileMultiTargets
Colin Crossee0bc3b2018-10-02 22:01:37 -07001249}
1250
Colin Cross4157e882019-06-06 16:57:04 -07001251func (m *ModuleBase) Os() OsType {
1252 return m.Target().Os
Dan Willemsen490fd492015-11-24 17:53:15 -08001253}
1254
Colin Cross4157e882019-06-06 16:57:04 -07001255func (m *ModuleBase) Host() bool {
Jiyong Park1613e552020-09-14 19:43:17 +09001256 return m.Os().Class == Host
Dan Willemsen97750522016-02-09 17:43:51 -08001257}
1258
Yo Chiangbba545e2020-06-09 16:15:37 +08001259func (m *ModuleBase) Device() bool {
1260 return m.Os().Class == Device
1261}
1262
Colin Cross4157e882019-06-06 16:57:04 -07001263func (m *ModuleBase) Arch() Arch {
1264 return m.Target().Arch
Dan Willemsen97750522016-02-09 17:43:51 -08001265}
1266
Colin Cross4157e882019-06-06 16:57:04 -07001267func (m *ModuleBase) ArchSpecific() bool {
1268 return m.commonProperties.ArchSpecific
Dan Willemsen0b24c742016-10-04 15:13:37 -07001269}
1270
Paul Duffin1356d8c2020-02-25 19:26:33 +00001271// True if the current variant is a CommonOS variant, false otherwise.
1272func (m *ModuleBase) IsCommonOSVariant() bool {
Colin Cross8bbc3d52024-09-11 15:33:54 -07001273 return m.commonProperties.CompileOS == CommonOS
Paul Duffin1356d8c2020-02-25 19:26:33 +00001274}
1275
Colin Cross34037c62020-11-17 13:19:17 -08001276// supportsTarget returns true if the given Target is supported by the current module.
1277func (m *ModuleBase) supportsTarget(target Target) bool {
1278 switch target.Os.Class {
1279 case Host:
1280 if target.HostCross {
1281 return m.HostCrossSupported()
1282 } else {
1283 return m.HostSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001284 }
Colin Cross34037c62020-11-17 13:19:17 -08001285 case Device:
1286 return m.DeviceSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001287 default:
Jiyong Park1613e552020-09-14 19:43:17 +09001288 return false
Colin Crossa1ad8d12016-06-01 17:09:44 -07001289 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001290}
1291
Colin Cross34037c62020-11-17 13:19:17 -08001292// DeviceSupported returns true if the current module is supported and enabled for device targets,
1293// i.e. the factory method set the HostOrDeviceSupported value to include device support and
1294// the device support is enabled by default or enabled by the device_supported property.
Colin Cross4157e882019-06-06 16:57:04 -07001295func (m *ModuleBase) DeviceSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001296 hod := m.commonProperties.HostOrDeviceSupported
1297 // deviceEnabled is true if the device_supported property is true or the HostOrDeviceSupported
1298 // value has the deviceDefault bit set.
1299 deviceEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Device_supported, hod&deviceDefault != 0)
1300 return hod&deviceSupported != 0 && deviceEnabled
Colin Cross3f40fa42015-01-30 17:27:36 -08001301}
1302
Colin Cross34037c62020-11-17 13:19:17 -08001303// HostSupported returns true if the current module is supported and enabled for host targets,
1304// i.e. the factory method set the HostOrDeviceSupported value to include host support and
1305// the host support is enabled by default or enabled by the host_supported property.
Paul Duffine44358f2019-11-26 18:04:12 +00001306func (m *ModuleBase) HostSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001307 hod := m.commonProperties.HostOrDeviceSupported
1308 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1309 // value has the hostDefault bit set.
1310 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
1311 return hod&hostSupported != 0 && hostEnabled
1312}
1313
1314// HostCrossSupported returns true if the current module is supported and enabled for host cross
1315// targets, i.e. the factory method set the HostOrDeviceSupported value to include host cross
1316// support and the host cross support is enabled by default or enabled by the
1317// host_supported property.
1318func (m *ModuleBase) HostCrossSupported() bool {
1319 hod := m.commonProperties.HostOrDeviceSupported
1320 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1321 // value has the hostDefault bit set.
1322 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
Ivan Lozanoc7eafa72024-07-16 17:55:33 +00001323
1324 // Default true for the Host_cross_supported property
1325 hostCrossEnabled := proptools.BoolDefault(m.hostCrossProperties.Host_cross_supported, true)
1326
1327 return hod&hostCrossSupported != 0 && hostEnabled && hostCrossEnabled
Paul Duffine44358f2019-11-26 18:04:12 +00001328}
1329
Colin Cross4157e882019-06-06 16:57:04 -07001330func (m *ModuleBase) Platform() bool {
Justin Yund5f6c822019-06-25 16:47:17 +09001331 return !m.DeviceSpecific() && !m.SocSpecific() && !m.ProductSpecific() && !m.SystemExtSpecific()
Jiyong Parkc678ad32018-04-10 13:07:10 +09001332}
1333
Colin Cross4157e882019-06-06 16:57:04 -07001334func (m *ModuleBase) DeviceSpecific() bool {
1335 return Bool(m.commonProperties.Device_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001336}
1337
Colin Cross4157e882019-06-06 16:57:04 -07001338func (m *ModuleBase) SocSpecific() bool {
1339 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001340}
1341
Colin Cross4157e882019-06-06 16:57:04 -07001342func (m *ModuleBase) ProductSpecific() bool {
1343 return Bool(m.commonProperties.Product_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001344}
1345
Justin Yund5f6c822019-06-25 16:47:17 +09001346func (m *ModuleBase) SystemExtSpecific() bool {
1347 return Bool(m.commonProperties.System_ext_specific)
Dario Frenifd05a742018-05-29 13:28:54 +01001348}
1349
Colin Crossc2d24052020-05-13 11:05:02 -07001350// RequiresStableAPIs returns true if the module will be installed to a partition that may
1351// be updated separately from the system image.
1352func (m *ModuleBase) RequiresStableAPIs(ctx BaseModuleContext) bool {
1353 return m.SocSpecific() || m.DeviceSpecific() ||
1354 (m.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface())
1355}
1356
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001357func (m *ModuleBase) PartitionTag(config DeviceConfig) string {
1358 partition := "system"
1359 if m.SocSpecific() {
1360 // A SoC-specific module could be on the vendor partition at
1361 // "vendor" or the system partition at "system/vendor".
1362 if config.VendorPath() == "vendor" {
1363 partition = "vendor"
1364 }
1365 } else if m.DeviceSpecific() {
1366 // A device-specific module could be on the odm partition at
1367 // "odm", the vendor partition at "vendor/odm", or the system
1368 // partition at "system/vendor/odm".
1369 if config.OdmPath() == "odm" {
1370 partition = "odm"
Ramy Medhat944839a2020-03-31 22:14:52 -04001371 } else if strings.HasPrefix(config.OdmPath(), "vendor/") {
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001372 partition = "vendor"
1373 }
1374 } else if m.ProductSpecific() {
1375 // A product-specific module could be on the product partition
1376 // at "product" or the system partition at "system/product".
1377 if config.ProductPath() == "product" {
1378 partition = "product"
1379 }
1380 } else if m.SystemExtSpecific() {
1381 // A system_ext-specific module could be on the system_ext
1382 // partition at "system_ext" or the system partition at
1383 // "system/system_ext".
1384 if config.SystemExtPath() == "system_ext" {
1385 partition = "system_ext"
1386 }
Cole Faust76a6e952024-11-07 16:56:45 -08001387 } else if m.InstallInRamdisk() {
1388 partition = "ramdisk"
Jihoon Kang30bf8f62024-11-26 21:50:55 +00001389 } else if m.InstallInVendorRamdisk() {
1390 partition = "vendor_ramdisk"
Jihoon Kang3216c982024-12-02 19:42:20 +00001391 } else if m.InstallInRecovery() {
1392 partition = "recovery"
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001393 }
1394 return partition
1395}
1396
Cole Fauste8a87832024-09-11 11:35:46 -07001397func (m *ModuleBase) Enabled(ctx ConfigurableEvaluatorContext) bool {
Justin Yun32f053b2020-07-31 23:07:17 +09001398 if m.commonProperties.ForcedDisabled {
1399 return false
1400 }
Cole Fausta963b942024-04-11 17:43:00 -07001401 return m.commonProperties.Enabled.GetOrDefault(m.ConfigurableEvaluator(ctx), !m.Os().DefaultDisabled)
Colin Cross3f40fa42015-01-30 17:27:36 -08001402}
1403
Cole Faust8eeae4b2024-09-12 11:51:04 -07001404// Returns a copy of the enabled property, useful for passing it on to sub-modules
1405func (m *ModuleBase) EnabledProperty() proptools.Configurable[bool] {
1406 if m.commonProperties.ForcedDisabled {
1407 return proptools.NewSimpleConfigurable(false)
1408 }
1409 return m.commonProperties.Enabled.Clone()
1410}
1411
Inseob Kimeec88e12020-01-22 11:11:29 +09001412func (m *ModuleBase) Disable() {
Justin Yun32f053b2020-07-31 23:07:17 +09001413 m.commonProperties.ForcedDisabled = true
Inseob Kimeec88e12020-01-22 11:11:29 +09001414}
1415
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001416// HideFromMake marks this variant so that it is not emitted in the generated Android.mk file.
1417func (m *ModuleBase) HideFromMake() {
1418 m.commonProperties.HideFromMake = true
1419}
1420
1421// IsHideFromMake returns true if HideFromMake was previously called.
1422func (m *ModuleBase) IsHideFromMake() bool {
1423 return m.commonProperties.HideFromMake == true
1424}
1425
1426// SkipInstall marks this variant to not create install rules when ctx.Install* are called.
Colin Cross4157e882019-06-06 16:57:04 -07001427func (m *ModuleBase) SkipInstall() {
1428 m.commonProperties.SkipInstall = true
Colin Crossce75d2c2016-10-06 16:12:58 -07001429}
1430
Martin Stjernholm9e7f45e2020-12-23 03:50:30 +00001431// IsSkipInstall returns true if this variant is marked to not create install
1432// rules when ctx.Install* are called.
1433func (m *ModuleBase) IsSkipInstall() bool {
1434 return m.commonProperties.SkipInstall
1435}
1436
Iván Budnik295da162023-03-10 16:11:26 +00001437// Similar to HideFromMake, but if the AndroidMk entry would set
1438// LOCAL_UNINSTALLABLE_MODULE then this variant may still output that entry
1439// rather than leaving it out altogether. That happens in cases where it would
1440// have other side effects, in particular when it adds a NOTICE file target,
1441// which other install targets might depend on.
1442func (m *ModuleBase) MakeUninstallable() {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001443 m.commonProperties.UninstallableApexPlatformVariant = true
Iván Budnik295da162023-03-10 16:11:26 +00001444 m.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00001445 m.SkipInstall()
Iván Budnik295da162023-03-10 16:11:26 +00001446}
1447
Liz Kammer5ca3a622020-08-05 15:40:41 -07001448func (m *ModuleBase) ReplacedByPrebuilt() {
1449 m.commonProperties.ReplacedByPrebuilt = true
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001450 m.HideFromMake()
Liz Kammer5ca3a622020-08-05 15:40:41 -07001451}
1452
1453func (m *ModuleBase) IsReplacedByPrebuilt() bool {
1454 return m.commonProperties.ReplacedByPrebuilt
1455}
1456
Colin Cross4157e882019-06-06 16:57:04 -07001457func (m *ModuleBase) ExportedToMake() bool {
1458 return m.commonProperties.NamespaceExportedToMake
Jiyong Park374510b2018-03-19 18:23:01 +09001459}
1460
Justin Yun1871f902023-04-07 20:13:19 +09001461func (m *ModuleBase) EffectiveLicenseKinds() []string {
1462 return m.commonProperties.Effective_license_kinds
1463}
1464
Justin Yun885a7de2021-06-29 20:34:53 +09001465func (m *ModuleBase) EffectiveLicenseFiles() Paths {
Bob Badour4101c712022-02-09 11:54:35 -08001466 result := make(Paths, 0, len(m.commonProperties.Effective_license_text))
1467 for _, p := range m.commonProperties.Effective_license_text {
1468 result = append(result, p.Path)
1469 }
1470 return result
Justin Yun885a7de2021-06-29 20:34:53 +09001471}
1472
Colin Crosse9fe2942020-11-10 18:12:15 -08001473// computeInstallDeps finds the installed paths of all dependencies that have a dependency
Colin Crossbd3a16b2023-04-25 11:30:51 -07001474// tag that is annotated as needing installation via the isInstallDepNeeded method.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001475func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]depset.DepSet[InstallPath], []depset.DepSet[PackagingSpec]) {
1476 var installDeps []depset.DepSet[InstallPath]
1477 var packagingSpecs []depset.DepSet[PackagingSpec]
Colin Cross5d583952020-11-24 16:21:24 -08001478 ctx.VisitDirectDeps(func(dep Module) {
Jiyong Park1d4907e2024-05-15 02:09:42 +09001479 if isInstallDepNeeded(dep, ctx.OtherModuleDependencyTag(dep)) {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001480 // Installation is still handled by Make, so anything hidden from Make is not
1481 // installable.
Yu Liubad1eef2024-08-21 22:37:35 +00001482 info := OtherModuleProviderOrDefault(ctx, dep, InstallFilesProvider)
Colin Crossbd3a16b2023-04-25 11:30:51 -07001483 if !dep.IsHideFromMake() && !dep.IsSkipInstall() {
Yu Liubad1eef2024-08-21 22:37:35 +00001484 installDeps = append(installDeps, info.TransitiveInstallFiles)
Colin Crossbd3a16b2023-04-25 11:30:51 -07001485 }
1486 // Add packaging deps even when the dependency is not installed so that uninstallable
1487 // modules can still be packaged. Often the package will be installed instead.
Yu Liubad1eef2024-08-21 22:37:35 +00001488 packagingSpecs = append(packagingSpecs, info.TransitivePackagingSpecs)
Colin Cross897266e2020-02-13 13:22:08 -08001489 }
1490 })
Colin Cross3f40fa42015-01-30 17:27:36 -08001491
Colin Crossffe6b9d2020-12-01 15:40:06 -08001492 return installDeps, packagingSpecs
Colin Cross3f40fa42015-01-30 17:27:36 -08001493}
1494
Colin Crossbd3a16b2023-04-25 11:30:51 -07001495// isInstallDepNeeded returns true if installing the output files of the current module
1496// should also install the output files of the given dependency and dependency tag.
1497func isInstallDepNeeded(dep Module, tag blueprint.DependencyTag) bool {
1498 // Don't add a dependency from the platform to a library provided by an apex.
1499 if dep.base().commonProperties.UninstallableApexPlatformVariant {
1500 return false
1501 }
1502 // Only install modules if the dependency tag is an InstallDepNeeded tag.
1503 return IsInstallDepNeededTag(tag)
1504}
1505
Colin Cross4157e882019-06-06 16:57:04 -07001506func (m *ModuleBase) NoAddressSanitizer() bool {
1507 return m.noAddressSanitizer
Colin Cross3f40fa42015-01-30 17:27:36 -08001508}
1509
Colin Cross4157e882019-06-06 16:57:04 -07001510func (m *ModuleBase) InstallInData() bool {
Dan Willemsen782a2d12015-12-21 14:55:28 -08001511 return false
1512}
1513
Jaewoong Jung0949f312019-09-11 10:25:18 -07001514func (m *ModuleBase) InstallInTestcases() bool {
1515 return false
1516}
1517
Colin Cross4157e882019-06-06 16:57:04 -07001518func (m *ModuleBase) InstallInSanitizerDir() bool {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001519 return false
1520}
1521
Yifan Hong1b3348d2020-01-21 15:53:22 -08001522func (m *ModuleBase) InstallInRamdisk() bool {
1523 return Bool(m.commonProperties.Ramdisk)
1524}
1525
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001526func (m *ModuleBase) InstallInVendorRamdisk() bool {
1527 return Bool(m.commonProperties.Vendor_ramdisk)
1528}
1529
Inseob Kim08758f02021-04-08 21:13:22 +09001530func (m *ModuleBase) InstallInDebugRamdisk() bool {
1531 return Bool(m.commonProperties.Debug_ramdisk)
1532}
1533
Colin Cross4157e882019-06-06 16:57:04 -07001534func (m *ModuleBase) InstallInRecovery() bool {
1535 return Bool(m.commonProperties.Recovery)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001536}
1537
Colin Crossea30d852023-11-29 16:00:16 -08001538func (m *ModuleBase) InstallInOdm() bool {
1539 return false
1540}
1541
1542func (m *ModuleBase) InstallInProduct() bool {
1543 return false
1544}
1545
Kiyoung Kimae11c232021-07-19 11:38:04 +09001546func (m *ModuleBase) InstallInVendor() bool {
Kiyoung Kimf160f7f2022-11-29 10:58:08 +09001547 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Soc_specific) || Bool(m.commonProperties.Proprietary)
Kiyoung Kimae11c232021-07-19 11:38:04 +09001548}
1549
Spandan Das950deca2024-10-01 18:35:23 +00001550func (m *ModuleBase) InstallInSystemExt() bool {
1551 return Bool(m.commonProperties.System_ext_specific)
1552}
1553
Colin Cross90ba5f42019-10-02 11:10:58 -07001554func (m *ModuleBase) InstallInRoot() bool {
1555 return false
1556}
1557
Spandan Das27ff7672024-11-06 19:23:57 +00001558func (m *ModuleBase) InstallInSystemDlkm() bool {
1559 return Bool(m.commonProperties.System_dlkm_specific)
1560}
1561
1562func (m *ModuleBase) InstallInVendorDlkm() bool {
1563 return Bool(m.commonProperties.Vendor_dlkm_specific)
1564}
1565
1566func (m *ModuleBase) InstallInOdmDlkm() bool {
1567 return Bool(m.commonProperties.Odm_dlkm_specific)
1568}
1569
Jiyong Park87788b52020-09-01 12:37:45 +09001570func (m *ModuleBase) InstallForceOS() (*OsType, *ArchType) {
1571 return nil, nil
Colin Cross6e359402020-02-10 15:29:54 -08001572}
1573
Colin Cross4157e882019-06-06 16:57:04 -07001574func (m *ModuleBase) Owner() string {
1575 return String(m.commonProperties.Owner)
Sundong Ahn4fd04bb2018-08-31 18:01:37 +09001576}
1577
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001578func (m *ModuleBase) Team() string {
1579 return String(m.commonProperties.Team)
1580}
1581
Colin Cross7228ecd2019-11-18 16:00:16 -08001582func (m *ModuleBase) setImageVariation(variant string) {
1583 m.commonProperties.ImageVariation = variant
1584}
1585
1586func (m *ModuleBase) ImageVariation() blueprint.Variation {
1587 return blueprint.Variation{
1588 Mutator: "image",
1589 Variation: m.base().commonProperties.ImageVariation,
1590 }
1591}
1592
Paul Duffin9b76c0b2020-03-12 10:24:35 +00001593func (m *ModuleBase) getVariationByMutatorName(mutator string) string {
1594 for i, v := range m.commonProperties.DebugMutators {
1595 if v == mutator {
1596 return m.commonProperties.DebugVariations[i]
1597 }
1598 }
1599
1600 return ""
1601}
1602
Yifan Hong1b3348d2020-01-21 15:53:22 -08001603func (m *ModuleBase) InRamdisk() bool {
1604 return m.base().commonProperties.ImageVariation == RamdiskVariation
1605}
1606
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001607func (m *ModuleBase) InVendorRamdisk() bool {
1608 return m.base().commonProperties.ImageVariation == VendorRamdiskVariation
1609}
1610
Inseob Kim08758f02021-04-08 21:13:22 +09001611func (m *ModuleBase) InDebugRamdisk() bool {
1612 return m.base().commonProperties.ImageVariation == DebugRamdiskVariation
1613}
1614
Colin Cross7228ecd2019-11-18 16:00:16 -08001615func (m *ModuleBase) InRecovery() bool {
1616 return m.base().commonProperties.ImageVariation == RecoveryVariation
1617}
1618
Cole Fauste8a87832024-09-11 11:35:46 -07001619func (m *ModuleBase) RequiredModuleNames(ctx ConfigurableEvaluatorContext) []string {
Cole Faust43ddd082024-06-17 12:32:40 -07001620 return m.base().commonProperties.Required.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
Jiyong Park6a8cf5f2019-12-30 16:31:09 +09001621}
1622
1623func (m *ModuleBase) HostRequiredModuleNames() []string {
1624 return m.base().commonProperties.Host_required
1625}
1626
1627func (m *ModuleBase) TargetRequiredModuleNames() []string {
1628 return m.base().commonProperties.Target_required
1629}
1630
Cole Fauste8a87832024-09-11 11:35:46 -07001631func (m *ModuleBase) VintfFragmentModuleNames(ctx ConfigurableEvaluatorContext) []string {
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001632 return m.base().commonProperties.Vintf_fragment_modules.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
1633}
1634
Kiyoung Kim23be5bb2024-11-27 00:50:30 +00001635func (m *ModuleBase) VintfFragments(ctx ConfigurableEvaluatorContext) []string {
1636 return m.base().commonProperties.Vintf_fragments.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
1637}
1638
Colin Crossa6182ab2024-08-21 10:47:44 -07001639func (m *ModuleBase) generateVariantTarget(ctx *moduleContext) {
1640 namespacePrefix := ctx.Namespace().id
1641 if namespacePrefix != "" {
1642 namespacePrefix = namespacePrefix + "-"
1643 }
1644
1645 if !ctx.uncheckedModule {
1646 name := namespacePrefix + ctx.ModuleName() + "-" + ctx.ModuleSubDir() + "-checkbuild"
1647 ctx.Phony(name, ctx.checkbuildFiles...)
1648 ctx.checkbuildTarget = PathForPhony(ctx, name)
1649 }
1650
1651}
1652
Yu Liuddc28332024-08-09 22:48:30 +00001653func (m *ModuleBase) generateModuleTarget(ctx *moduleContext) {
Colin Cross897266e2020-02-13 13:22:08 -08001654 var allInstalledFiles InstallPaths
Colin Crossa6182ab2024-08-21 10:47:44 -07001655 var allCheckbuildTargets Paths
Yu Liub5275322024-11-13 18:40:43 +00001656 ctx.VisitAllModuleVariantProxies(func(module ModuleProxy) {
Colin Crossa6182ab2024-08-21 10:47:44 -07001657 var checkbuildTarget Path
1658 var uncheckedModule bool
Yu Liub5275322024-11-13 18:40:43 +00001659 var skipAndroidMkProcessing bool
1660 if ctx.EqualModules(m.module, module) {
Yu Liuddc28332024-08-09 22:48:30 +00001661 allInstalledFiles = append(allInstalledFiles, ctx.installFiles...)
Colin Crossa6182ab2024-08-21 10:47:44 -07001662 checkbuildTarget = ctx.checkbuildTarget
1663 uncheckedModule = ctx.uncheckedModule
Yu Liub5275322024-11-13 18:40:43 +00001664 skipAndroidMkProcessing = shouldSkipAndroidMkProcessing(ctx, m)
Yu Liuddc28332024-08-09 22:48:30 +00001665 } else {
Yu Liud46e5ae2024-08-15 18:46:17 +00001666 info := OtherModuleProviderOrDefault(ctx, module, InstallFilesProvider)
1667 allInstalledFiles = append(allInstalledFiles, info.InstallFiles...)
Colin Crossa6182ab2024-08-21 10:47:44 -07001668 checkbuildTarget = info.CheckbuildTarget
1669 uncheckedModule = info.UncheckedModule
Yu Liub5275322024-11-13 18:40:43 +00001670 skipAndroidMkProcessing = OtherModuleProviderOrDefault(ctx, module, CommonModuleInfoKey).SkipAndroidMkProcessing
Yu Liuddc28332024-08-09 22:48:30 +00001671 }
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001672 // A module's -checkbuild phony targets should
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001673 // not be created if the module is not exported to make.
1674 // Those could depend on the build target and fail to compile
1675 // for the current build target.
Yu Liub5275322024-11-13 18:40:43 +00001676 if (!ctx.Config().KatiEnabled() || !skipAndroidMkProcessing) && !uncheckedModule && checkbuildTarget != nil {
Colin Crossa6182ab2024-08-21 10:47:44 -07001677 allCheckbuildTargets = append(allCheckbuildTargets, checkbuildTarget)
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001678 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001679 })
1680
Colin Cross0875c522017-11-28 17:34:01 -08001681 var deps Paths
Colin Cross9454bfa2015-03-17 13:24:18 -07001682
Yu Liu460c0fa2024-08-20 19:31:15 +00001683 var namespacePrefix string
1684 nameSpace := ctx.Namespace().Path
1685 if nameSpace != "." {
1686 namespacePrefix = strings.ReplaceAll(nameSpace, "/", ".") + "-"
Jeff Gaston088e29e2017-11-29 16:47:17 -08001687 }
1688
Yu Liuddc2e1a2024-08-20 21:31:22 +00001689 var info FinalModuleBuildTargetsInfo
1690
Colin Cross3f40fa42015-01-30 17:27:36 -08001691 if len(allInstalledFiles) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001692 name := namespacePrefix + ctx.ModuleName() + "-install"
1693 ctx.Phony(name, allInstalledFiles.Paths()...)
Yu Liuddc2e1a2024-08-20 21:31:22 +00001694 info.InstallTarget = PathForPhony(ctx, name)
1695 deps = append(deps, info.InstallTarget)
Colin Cross9454bfa2015-03-17 13:24:18 -07001696 }
1697
Colin Crossa6182ab2024-08-21 10:47:44 -07001698 if len(allCheckbuildTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001699 name := namespacePrefix + ctx.ModuleName() + "-checkbuild"
Colin Crossa6182ab2024-08-21 10:47:44 -07001700 ctx.Phony(name, allCheckbuildTargets...)
1701 deps = append(deps, PathForPhony(ctx, name))
Colin Cross9454bfa2015-03-17 13:24:18 -07001702 }
1703
1704 if len(deps) > 0 {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001705 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05001706 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001707 suffix = "-soong"
1708 }
1709
Colin Crossc3d87d32020-06-04 13:25:17 -07001710 ctx.Phony(namespacePrefix+ctx.ModuleName()+suffix, deps...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07001711
Yu Liuddc2e1a2024-08-20 21:31:22 +00001712 info.BlueprintDir = ctx.ModuleDir()
1713 SetProvider(ctx, FinalModuleBuildTargetsProvider, info)
Colin Cross3f40fa42015-01-30 17:27:36 -08001714 }
1715}
1716
Cole Faust5b7635d2024-10-28 13:01:12 -07001717func determineModuleKind(m *ModuleBase, ctx ModuleErrorContext) moduleKind {
Colin Cross4157e882019-06-06 16:57:04 -07001718 var socSpecific = Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
1719 var deviceSpecific = Bool(m.commonProperties.Device_specific)
1720 var productSpecific = Bool(m.commonProperties.Product_specific)
Justin Yund5f6c822019-06-25 16:47:17 +09001721 var systemExtSpecific = Bool(m.commonProperties.System_ext_specific)
Jiyong Park2db76922017-11-08 16:03:48 +09001722
Dario Frenifd05a742018-05-29 13:28:54 +01001723 msg := "conflicting value set here"
1724 if socSpecific && deviceSpecific {
1725 ctx.PropertyErrorf("device_specific", "a module cannot be specific to SoC and device at the same time.")
Colin Cross4157e882019-06-06 16:57:04 -07001726 if Bool(m.commonProperties.Vendor) {
Jiyong Park2db76922017-11-08 16:03:48 +09001727 ctx.PropertyErrorf("vendor", msg)
1728 }
Colin Cross4157e882019-06-06 16:57:04 -07001729 if Bool(m.commonProperties.Proprietary) {
Jiyong Park2db76922017-11-08 16:03:48 +09001730 ctx.PropertyErrorf("proprietary", msg)
1731 }
Colin Cross4157e882019-06-06 16:57:04 -07001732 if Bool(m.commonProperties.Soc_specific) {
Jiyong Park2db76922017-11-08 16:03:48 +09001733 ctx.PropertyErrorf("soc_specific", msg)
1734 }
1735 }
1736
Justin Yund5f6c822019-06-25 16:47:17 +09001737 if productSpecific && systemExtSpecific {
1738 ctx.PropertyErrorf("product_specific", "a module cannot be specific to product and system_ext at the same time.")
1739 ctx.PropertyErrorf("system_ext_specific", msg)
Dario Frenifd05a742018-05-29 13:28:54 +01001740 }
1741
Justin Yund5f6c822019-06-25 16:47:17 +09001742 if (socSpecific || deviceSpecific) && (productSpecific || systemExtSpecific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001743 if productSpecific {
1744 ctx.PropertyErrorf("product_specific", "a module cannot be specific to SoC or device and product at the same time.")
1745 } else {
Justin Yund5f6c822019-06-25 16:47:17 +09001746 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 +01001747 }
1748 if deviceSpecific {
1749 ctx.PropertyErrorf("device_specific", msg)
1750 } else {
Colin Cross4157e882019-06-06 16:57:04 -07001751 if Bool(m.commonProperties.Vendor) {
Dario Frenifd05a742018-05-29 13:28:54 +01001752 ctx.PropertyErrorf("vendor", msg)
1753 }
Colin Cross4157e882019-06-06 16:57:04 -07001754 if Bool(m.commonProperties.Proprietary) {
Dario Frenifd05a742018-05-29 13:28:54 +01001755 ctx.PropertyErrorf("proprietary", msg)
1756 }
Colin Cross4157e882019-06-06 16:57:04 -07001757 if Bool(m.commonProperties.Soc_specific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001758 ctx.PropertyErrorf("soc_specific", msg)
1759 }
1760 }
1761 }
1762
Jiyong Park2db76922017-11-08 16:03:48 +09001763 if productSpecific {
1764 return productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +09001765 } else if systemExtSpecific {
1766 return systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +09001767 } else if deviceSpecific {
1768 return deviceSpecificModule
1769 } else if socSpecific {
1770 return socSpecificModule
1771 } else {
1772 return platformModule
1773 }
1774}
1775
Colin Crossc34d2322020-01-03 15:23:27 -08001776func (m *ModuleBase) earlyModuleContextFactory(ctx blueprint.EarlyModuleContext) earlyModuleContext {
Colin Cross1184b642019-12-30 18:43:07 -08001777 return earlyModuleContext{
Colin Crossc34d2322020-01-03 15:23:27 -08001778 EarlyModuleContext: ctx,
1779 kind: determineModuleKind(m, ctx),
1780 config: ctx.Config().(Config),
Colin Cross3f40fa42015-01-30 17:27:36 -08001781 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001782}
1783
Colin Cross1184b642019-12-30 18:43:07 -08001784func (m *ModuleBase) baseModuleContextFactory(ctx blueprint.BaseModuleContext) baseModuleContext {
1785 return baseModuleContext{
1786 bp: ctx,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001787 archModuleContext: m.archModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001788 earlyModuleContext: m.earlyModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001789 }
1790}
1791
Colin Crosse1a85552024-06-14 12:17:37 -07001792type archModuleContextFactoryContext interface {
1793 Config() interface{}
1794}
1795
1796func (m *ModuleBase) archModuleContextFactory(ctx archModuleContextFactoryContext) archModuleContext {
Colin Cross1d3d9f12024-01-18 14:30:22 -08001797 config := ctx.Config().(Config)
1798 target := m.Target()
1799 primaryArch := false
1800 if len(config.Targets[target.Os]) <= 1 {
1801 primaryArch = true
1802 } else {
1803 primaryArch = target.Arch.ArchType == config.Targets[target.Os][0].Arch.ArchType
1804 }
1805
1806 return archModuleContext{
Cole Faust0aa21cc2024-03-20 12:28:03 -07001807 ready: m.commonProperties.ArchReady,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001808 os: m.commonProperties.CompileOS,
1809 target: m.commonProperties.CompileTarget,
1810 targetPrimary: m.commonProperties.CompilePrimary,
1811 multiTargets: m.commonProperties.CompileMultiTargets,
1812 primaryArch: primaryArch,
1813 }
1814
1815}
1816
Yu Liuddc28332024-08-09 22:48:30 +00001817type InstallFilesInfo struct {
Colin Crossa6182ab2024-08-21 10:47:44 -07001818 InstallFiles InstallPaths
1819 CheckbuildFiles Paths
1820 CheckbuildTarget Path
1821 UncheckedModule bool
1822 PackagingSpecs []PackagingSpec
Yu Liud46e5ae2024-08-15 18:46:17 +00001823 // katiInstalls tracks the install rules that were created by Soong but are being exported
1824 // to Make to convert to ninja rules so that Make can add additional dependencies.
Yu Liuec810542024-08-26 18:09:15 +00001825 KatiInstalls katiInstalls
1826 KatiSymlinks katiInstalls
1827 TestData []DataPath
Colin Crossa14fb6a2024-10-23 16:57:06 -07001828 TransitivePackagingSpecs depset.DepSet[PackagingSpec]
Yu Liuec810542024-08-26 18:09:15 +00001829 LicenseMetadataFile WritablePath
1830
1831 // The following fields are private before, make it private again once we have
1832 // better solution.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001833 TransitiveInstallFiles depset.DepSet[InstallPath]
Yu Liu82a6d142024-08-27 19:02:29 +00001834 // katiInitRcInstalls and katiVintfInstalls track the install rules created by Soong that are
1835 // allowed to have duplicates across modules and variants.
1836 KatiInitRcInstalls katiInstalls
1837 KatiVintfInstalls katiInstalls
1838 InitRcPaths Paths
1839 VintfFragmentsPaths Paths
1840 InstalledInitRcPaths InstallPaths
1841 InstalledVintfFragmentsPaths InstallPaths
1842
Yu Liuec810542024-08-26 18:09:15 +00001843 // The files to copy to the dist as explicitly specified in the .bp file.
1844 DistFiles TaggedDistFiles
Yu Liuddc28332024-08-09 22:48:30 +00001845}
1846
Yu Liubad1eef2024-08-21 22:37:35 +00001847var InstallFilesProvider = blueprint.NewProvider[InstallFilesInfo]()
Yu Liuddc2e1a2024-08-20 21:31:22 +00001848
Yu Liud3228ac2024-11-08 23:11:47 +00001849type SourceFilesInfo struct {
1850 Srcs Paths
1851}
1852
1853var SourceFilesInfoKey = blueprint.NewProvider[SourceFilesInfo]()
1854
Yu Liuddc2e1a2024-08-20 21:31:22 +00001855type FinalModuleBuildTargetsInfo struct {
1856 // Used by buildTargetSingleton to create checkbuild and per-directory build targets
1857 // Only set on the final variant of each module
1858 InstallTarget WritablePath
1859 CheckbuildTarget WritablePath
1860 BlueprintDir string
1861}
1862
Yu Liubad1eef2024-08-21 22:37:35 +00001863var FinalModuleBuildTargetsProvider = blueprint.NewProvider[FinalModuleBuildTargetsInfo]()
Yu Liuddc28332024-08-09 22:48:30 +00001864
Yu Liub5275322024-11-13 18:40:43 +00001865type CommonModuleInfo struct {
Yu Liudd9ccb42024-10-07 17:07:44 +00001866 Enabled bool
1867 // Whether the module has been replaced by a prebuilt
1868 ReplacedByPrebuilt bool
Yu Liuec7043d2024-11-05 18:22:20 +00001869 // The Target of artifacts that this module variant is responsible for creating.
Yu Liub5275322024-11-13 18:40:43 +00001870 CompileTarget Target
1871 SkipAndroidMkProcessing bool
Yu Liudd9ccb42024-10-07 17:07:44 +00001872}
1873
Yu Liub5275322024-11-13 18:40:43 +00001874var CommonModuleInfoKey = blueprint.NewProvider[CommonModuleInfo]()
Yu Liudd9ccb42024-10-07 17:07:44 +00001875
1876type PrebuiltModuleProviderData struct {
1877 // Empty for now
1878}
1879
1880var PrebuiltModuleProviderKey = blueprint.NewProvider[PrebuiltModuleProviderData]()
1881
1882type HostToolProviderData struct {
1883 HostToolPath OptionalPath
1884}
1885
1886var HostToolProviderKey = blueprint.NewProvider[HostToolProviderData]()
1887
Colin Cross4157e882019-06-06 16:57:04 -07001888func (m *ModuleBase) GenerateBuildActions(blueprintCtx blueprint.ModuleContext) {
Colin Cross25de6c32019-06-06 14:29:25 -07001889 ctx := &moduleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001890 module: m.module,
Colin Crossdc35e212019-06-06 16:13:11 -07001891 bp: blueprintCtx,
Colin Cross0ea8ba82019-06-06 14:33:29 -07001892 baseModuleContext: m.baseModuleContextFactory(blueprintCtx),
Colin Cross0ea8ba82019-06-06 14:33:29 -07001893 variables: make(map[string]string),
Yu Liu54513622024-08-19 20:00:32 +00001894 phonies: make(map[string]Paths),
Colin Cross3f40fa42015-01-30 17:27:36 -08001895 }
1896
Jihoon Kangc3d4e112024-06-24 22:16:27 +00001897 setContainerInfo(ctx)
Jihoon Kang85bc1932024-07-01 17:04:46 +00001898 if ctx.Config().Getenv("DISABLE_CONTAINER_CHECK") != "true" {
1899 checkContainerViolations(ctx)
1900 }
Jihoon Kangc3d4e112024-06-24 22:16:27 +00001901
Yu Liuec810542024-08-26 18:09:15 +00001902 ctx.licenseMetadataFile = PathForModuleOut(ctx, "meta_lic")
Colin Crossaa1cab02022-01-28 14:49:24 -08001903
Colin Crossffe6b9d2020-12-01 15:40:06 -08001904 dependencyInstallFiles, dependencyPackagingSpecs := m.computeInstallDeps(ctx)
Yu Liubad1eef2024-08-21 22:37:35 +00001905 // set the TransitiveInstallFiles to only the transitive dependencies to be used as the dependencies
Colin Cross5d583952020-11-24 16:21:24 -08001906 // of installed files of this module. It will be replaced by a depset including the installed
1907 // files of this module at the end for use by modules that depend on this one.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001908 ctx.TransitiveInstallFiles = depset.New[InstallPath](depset.TOPOLOGICAL, nil, dependencyInstallFiles)
Colin Cross5d583952020-11-24 16:21:24 -08001909
Colin Cross6c4f21f2019-06-06 15:41:36 -07001910 // Temporarily continue to call blueprintCtx.GetMissingDependencies() to maintain the previous behavior of never
1911 // reporting missing dependency errors in Blueprint when AllowMissingDependencies == true.
1912 // TODO: This will be removed once defaults modules handle missing dependency errors
1913 blueprintCtx.GetMissingDependencies()
1914
Colin Crossdc35e212019-06-06 16:13:11 -07001915 // For the final GenerateAndroidBuildActions pass, require that all visited dependencies Soong modules and
Paul Duffin1356d8c2020-02-25 19:26:33 +00001916 // are enabled. Unless the module is a CommonOS variant which may have dependencies on disabled variants
1917 // (because the dependencies are added before the modules are disabled). The
1918 // GetOsSpecificVariantsOfCommonOSVariant(...) method will ensure that the disabled variants are
1919 // ignored.
1920 ctx.baseModuleContext.strictVisitDeps = !m.IsCommonOSVariant()
Colin Crossdc35e212019-06-06 16:13:11 -07001921
Colin Cross4c83e5c2019-02-25 14:54:28 -08001922 if ctx.config.captureBuild {
1923 ctx.ruleParams = make(map[blueprint.Rule]blueprint.RuleParams)
1924 }
1925
Colin Cross67a5c132017-05-09 13:45:28 -07001926 desc := "//" + ctx.ModuleDir() + ":" + ctx.ModuleName() + " "
1927 var suffix []string
Colin Cross0875c522017-11-28 17:34:01 -08001928 if ctx.Os().Class != Device && ctx.Os().Class != Generic {
1929 suffix = append(suffix, ctx.Os().String())
Colin Cross67a5c132017-05-09 13:45:28 -07001930 }
Colin Cross0875c522017-11-28 17:34:01 -08001931 if !ctx.PrimaryArch() {
1932 suffix = append(suffix, ctx.Arch().ArchType.String())
Colin Cross67a5c132017-05-09 13:45:28 -07001933 }
Colin Crossff694a82023-12-13 15:54:49 -08001934 if apexInfo, _ := ModuleProvider(ctx, ApexInfoProvider); !apexInfo.IsForPlatform() {
Colin Cross56a83212020-09-15 18:30:11 -07001935 suffix = append(suffix, apexInfo.ApexVariationName)
Dan Willemsenb13a9482020-02-14 11:25:54 -08001936 }
Colin Cross67a5c132017-05-09 13:45:28 -07001937
1938 ctx.Variable(pctx, "moduleDesc", desc)
1939
1940 s := ""
1941 if len(suffix) > 0 {
1942 s = " [" + strings.Join(suffix, " ") + "]"
1943 }
1944 ctx.Variable(pctx, "moduleDescSuffix", s)
1945
Dan Willemsen569edc52018-11-19 09:33:29 -08001946 // Some common property checks for properties that will be used later in androidmk.go
Paul Duffin89968e32020-11-23 18:17:03 +00001947 checkDistProperties(ctx, "dist", &m.distProperties.Dist)
Sasha Smundake198eaf2022-08-04 13:07:02 -07001948 for i := range m.distProperties.Dists {
Paul Duffin89968e32020-11-23 18:17:03 +00001949 checkDistProperties(ctx, fmt.Sprintf("dists[%d]", i), &m.distProperties.Dists[i])
Dan Willemsen569edc52018-11-19 09:33:29 -08001950 }
1951
Yu Liubad1eef2024-08-21 22:37:35 +00001952 var installFiles InstallFilesInfo
1953
Cole Fausta963b942024-04-11 17:43:00 -07001954 if m.Enabled(ctx) {
Jooyung Hand48f3c32019-08-23 11:18:57 +09001955 // ensure all direct android.Module deps are enabled
Yu Liu4552aeb2024-11-13 00:59:49 +00001956 ctx.VisitDirectDepsProxy(func(m ModuleProxy) {})
Jooyung Hand48f3c32019-08-23 11:18:57 +09001957
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001958 if m.Device() {
1959 // Handle any init.rc and vintf fragment files requested by the module. All files installed by this
1960 // module will automatically have a dependency on the installed init.rc or vintf fragment file.
1961 // The same init.rc or vintf fragment file may be requested by multiple modules or variants,
1962 // so instead of installing them now just compute the install path and store it for later.
1963 // The full list of all init.rc and vintf fragment install rules will be deduplicated later
1964 // so only a single rule is created for each init.rc or vintf fragment file.
1965
1966 if !m.InVendorRamdisk() {
Inseob Kim713b87d2024-09-13 11:29:54 +09001967 ctx.initRcPaths = PathsForModuleSrc(ctx, m.commonProperties.Init_rc.GetOrDefault(ctx, nil))
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001968 rcDir := PathForModuleInstall(ctx, "etc", "init")
Yu Liu82a6d142024-08-27 19:02:29 +00001969 for _, src := range ctx.initRcPaths {
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001970 installedInitRc := rcDir.Join(ctx, src.Base())
Yu Liu82a6d142024-08-27 19:02:29 +00001971 ctx.katiInitRcInstalls = append(ctx.katiInitRcInstalls, katiInstall{
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001972 from: src,
1973 to: installedInitRc,
1974 })
1975 ctx.PackageFile(rcDir, src.Base(), src)
Yu Liu82a6d142024-08-27 19:02:29 +00001976 ctx.installedInitRcPaths = append(ctx.installedInitRcPaths, installedInitRc)
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001977 }
Yu Liu82a6d142024-08-27 19:02:29 +00001978 installFiles.InitRcPaths = ctx.initRcPaths
1979 installFiles.KatiInitRcInstalls = ctx.katiInitRcInstalls
1980 installFiles.InstalledInitRcPaths = ctx.installedInitRcPaths
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001981 }
1982
Yu Liu82a6d142024-08-27 19:02:29 +00001983 ctx.vintfFragmentsPaths = PathsForModuleSrc(ctx, m.commonProperties.Vintf_fragments.GetOrDefault(ctx, nil))
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001984 vintfDir := PathForModuleInstall(ctx, "etc", "vintf", "manifest")
Yu Liu82a6d142024-08-27 19:02:29 +00001985 for _, src := range ctx.vintfFragmentsPaths {
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001986 installedVintfFragment := vintfDir.Join(ctx, src.Base())
Yu Liu82a6d142024-08-27 19:02:29 +00001987 ctx.katiVintfInstalls = append(ctx.katiVintfInstalls, katiInstall{
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001988 from: src,
1989 to: installedVintfFragment,
1990 })
1991 ctx.PackageFile(vintfDir, src.Base(), src)
Yu Liu82a6d142024-08-27 19:02:29 +00001992 ctx.installedVintfFragmentsPaths = append(ctx.installedVintfFragmentsPaths, installedVintfFragment)
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001993 }
Yu Liu82a6d142024-08-27 19:02:29 +00001994 installFiles.VintfFragmentsPaths = ctx.vintfFragmentsPaths
1995 installFiles.KatiVintfInstalls = ctx.katiVintfInstalls
1996 installFiles.InstalledVintfFragmentsPaths = ctx.installedVintfFragmentsPaths
Colin Crossd9bbf4b2023-11-17 16:23:48 -08001997 }
1998
Bob Badour37af0462021-01-07 03:34:31 +00001999 licensesPropertyFlattener(ctx)
2000 if ctx.Failed() {
2001 return
2002 }
2003
Joe Onorato349ae8d2024-02-05 22:46:00 +00002004 if jarJarPrefixHandler != nil {
2005 jarJarPrefixHandler(ctx)
2006 if ctx.Failed() {
2007 return
2008 }
2009 }
2010
Justin Yun40182b62024-05-07 10:22:19 +09002011 // Call aconfigUpdateAndroidBuildActions to collect merged aconfig files before being used
2012 // in m.module.GenerateAndroidBuildActions
2013 aconfigUpdateAndroidBuildActions(ctx)
Jaewoong Jung5b425e22019-06-17 17:40:56 -07002014 if ctx.Failed() {
2015 return
2016 }
2017
Yu Liu26a716d2024-08-30 23:40:32 +00002018 m.module.GenerateAndroidBuildActions(ctx)
2019 if ctx.Failed() {
2020 return
Yu Liufa297642024-06-11 00:13:02 +00002021 }
2022
Yu Liu26a716d2024-08-30 23:40:32 +00002023 if x, ok := m.module.(IDEInfo); ok {
2024 var result IdeInfo
2025 x.IDEInfo(ctx, &result)
2026 result.BaseModuleName = x.BaseModuleName()
2027 SetProvider(ctx, IdeInfoProviderKey, result)
LaMont Jonesb5099382024-01-10 23:42:36 +00002028 }
2029
Paul Duffinaf970a22020-11-23 23:32:56 +00002030 // Create the set of tagged dist files after calling GenerateAndroidBuildActions
2031 // as GenerateTaggedDistFiles() calls OutputFiles(tag) and so relies on the
2032 // output paths being set which must be done before or during
2033 // GenerateAndroidBuildActions.
Yu Liuec810542024-08-26 18:09:15 +00002034 installFiles.DistFiles = m.GenerateTaggedDistFiles(ctx)
Paul Duffinaf970a22020-11-23 23:32:56 +00002035 if ctx.Failed() {
2036 return
2037 }
2038
Colin Crossa6182ab2024-08-21 10:47:44 -07002039 m.generateVariantTarget(ctx)
2040
Yu Liuec810542024-08-26 18:09:15 +00002041 installFiles.LicenseMetadataFile = ctx.licenseMetadataFile
Yu Liubad1eef2024-08-21 22:37:35 +00002042 installFiles.InstallFiles = ctx.installFiles
2043 installFiles.CheckbuildFiles = ctx.checkbuildFiles
Colin Crossa6182ab2024-08-21 10:47:44 -07002044 installFiles.CheckbuildTarget = ctx.checkbuildTarget
2045 installFiles.UncheckedModule = ctx.uncheckedModule
Yu Liubad1eef2024-08-21 22:37:35 +00002046 installFiles.PackagingSpecs = ctx.packagingSpecs
2047 installFiles.KatiInstalls = ctx.katiInstalls
2048 installFiles.KatiSymlinks = ctx.katiSymlinks
2049 installFiles.TestData = ctx.testData
Colin Crossdc35e212019-06-06 16:13:11 -07002050 } else if ctx.Config().AllowMissingDependencies() {
2051 // If the module is not enabled it will not create any build rules, nothing will call
2052 // ctx.GetMissingDependencies(), and blueprint will consider the missing dependencies to be unhandled
2053 // and report them as an error even when AllowMissingDependencies = true. Call
2054 // ctx.GetMissingDependencies() here to tell blueprint not to handle them.
2055 ctx.GetMissingDependencies()
Colin Cross3f40fa42015-01-30 17:27:36 -08002056 }
2057
Yu Liud3228ac2024-11-08 23:11:47 +00002058 if sourceFileProducer, ok := m.module.(SourceFileProducer); ok {
2059 SetProvider(ctx, SourceFilesInfoKey, SourceFilesInfo{Srcs: sourceFileProducer.Srcs()})
2060 }
2061
Yu Liu88ea9ff2024-11-07 19:19:42 +00002062 if ctx.IsFinalModule(m.module) {
Colin Cross4157e882019-06-06 16:57:04 -07002063 m.generateModuleTarget(ctx)
Colin Cross9b1d13d2016-09-19 15:18:11 -07002064 if ctx.Failed() {
2065 return
2066 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002067 }
Colin Crosscec81712017-07-13 14:43:27 -07002068
Colin Crossa14fb6a2024-10-23 16:57:06 -07002069 ctx.TransitiveInstallFiles = depset.New[InstallPath](depset.TOPOLOGICAL, ctx.installFiles, dependencyInstallFiles)
Yu Liubad1eef2024-08-21 22:37:35 +00002070 installFiles.TransitiveInstallFiles = ctx.TransitiveInstallFiles
Colin Crossa14fb6a2024-10-23 16:57:06 -07002071 installFiles.TransitivePackagingSpecs = depset.New[PackagingSpec](depset.TOPOLOGICAL, ctx.packagingSpecs, dependencyPackagingSpecs)
Colin Cross5d583952020-11-24 16:21:24 -08002072
Yu Liubad1eef2024-08-21 22:37:35 +00002073 SetProvider(ctx, InstallFilesProvider, installFiles)
Yu Liuec810542024-08-26 18:09:15 +00002074 buildLicenseMetadata(ctx, ctx.licenseMetadataFile)
Colin Cross4acaea92021-12-10 23:05:02 +00002075
Yu Liu4297ad92024-08-27 19:50:13 +00002076 if ctx.moduleInfoJSON != nil {
Colin Crossd6fd0132023-11-06 13:54:06 -08002077 var installed InstallPaths
Yu Liud46e5ae2024-08-15 18:46:17 +00002078 installed = append(installed, ctx.katiInstalls.InstallPaths()...)
2079 installed = append(installed, ctx.katiSymlinks.InstallPaths()...)
Yu Liu82a6d142024-08-27 19:02:29 +00002080 installed = append(installed, ctx.katiInitRcInstalls.InstallPaths()...)
2081 installed = append(installed, ctx.katiVintfInstalls.InstallPaths()...)
Colin Crossd6fd0132023-11-06 13:54:06 -08002082 installedStrings := installed.Strings()
2083
2084 var targetRequired, hostRequired []string
2085 if ctx.Host() {
2086 targetRequired = m.commonProperties.Target_required
2087 } else {
2088 hostRequired = m.commonProperties.Host_required
2089 }
2090
2091 var data []string
Yu Liud46e5ae2024-08-15 18:46:17 +00002092 for _, d := range ctx.testData {
Colin Crossd6fd0132023-11-06 13:54:06 -08002093 data = append(data, d.ToRelativeInstallPath())
2094 }
2095
Yu Liu4297ad92024-08-27 19:50:13 +00002096 if ctx.moduleInfoJSON.Uninstallable {
Colin Crossd6fd0132023-11-06 13:54:06 -08002097 installedStrings = nil
Yu Liu4297ad92024-08-27 19:50:13 +00002098 if len(ctx.moduleInfoJSON.CompatibilitySuites) == 1 && ctx.moduleInfoJSON.CompatibilitySuites[0] == "null-suite" {
2099 ctx.moduleInfoJSON.CompatibilitySuites = nil
2100 ctx.moduleInfoJSON.TestConfig = nil
2101 ctx.moduleInfoJSON.AutoTestConfig = nil
Colin Crossd6fd0132023-11-06 13:54:06 -08002102 data = nil
2103 }
2104 }
2105
Yu Liu4297ad92024-08-27 19:50:13 +00002106 ctx.moduleInfoJSON.core = CoreModuleInfoJSON{
2107 RegisterName: m.moduleInfoRegisterName(ctx, ctx.moduleInfoJSON.SubName),
Colin Crossd6fd0132023-11-06 13:54:06 -08002108 Path: []string{ctx.ModuleDir()},
2109 Installed: installedStrings,
Yu Liu4297ad92024-08-27 19:50:13 +00002110 ModuleName: m.BaseModuleName() + ctx.moduleInfoJSON.SubName,
Colin Crossd6fd0132023-11-06 13:54:06 -08002111 SupportedVariants: []string{m.moduleInfoVariant(ctx)},
2112 TargetDependencies: targetRequired,
2113 HostDependencies: hostRequired,
2114 Data: data,
Kiyoung Kim74408202024-08-29 17:39:07 +09002115 Required: append(m.RequiredModuleNames(ctx), m.VintfFragmentModuleNames(ctx)...),
Colin Crossd6fd0132023-11-06 13:54:06 -08002116 }
Yu Liu4297ad92024-08-27 19:50:13 +00002117 SetProvider(ctx, ModuleInfoJSONProvider, ctx.moduleInfoJSON)
Colin Crossd6fd0132023-11-06 13:54:06 -08002118 }
2119
Colin Cross4157e882019-06-06 16:57:04 -07002120 m.buildParams = ctx.buildParams
2121 m.ruleParams = ctx.ruleParams
2122 m.variables = ctx.variables
mrziwange6c85812024-05-22 14:36:09 -07002123
Yu Liu876b7ce2024-08-21 18:20:13 +00002124 outputFiles := ctx.GetOutputFiles()
2125 if outputFiles.DefaultOutputFiles != nil || outputFiles.TaggedOutputFiles != nil {
2126 SetProvider(ctx, OutputFilesProvider, outputFiles)
mrziwange6c85812024-05-22 14:36:09 -07002127 }
Wei Lia1aa2972024-06-21 13:08:51 -07002128
Yu Liu54513622024-08-19 20:00:32 +00002129 if len(ctx.phonies) > 0 {
2130 SetProvider(ctx, ModulePhonyProvider, ModulePhonyInfo{
2131 Phonies: ctx.phonies,
2132 })
2133 }
Wei Lia1aa2972024-06-21 13:08:51 -07002134 buildComplianceMetadataProvider(ctx, m)
Yu Liudd9ccb42024-10-07 17:07:44 +00002135
Yu Liub5275322024-11-13 18:40:43 +00002136 commonData := CommonModuleInfo{
2137 ReplacedByPrebuilt: m.commonProperties.ReplacedByPrebuilt,
2138 CompileTarget: m.commonProperties.CompileTarget,
2139 SkipAndroidMkProcessing: shouldSkipAndroidMkProcessing(ctx, m),
Yu Liudd9ccb42024-10-07 17:07:44 +00002140 }
2141 if m.commonProperties.ForcedDisabled {
2142 commonData.Enabled = false
2143 } else {
2144 commonData.Enabled = m.commonProperties.Enabled.GetOrDefault(m.ConfigurableEvaluator(ctx), !m.Os().DefaultDisabled)
2145 }
Yu Liub5275322024-11-13 18:40:43 +00002146 SetProvider(ctx, CommonModuleInfoKey, commonData)
Yu Liudd9ccb42024-10-07 17:07:44 +00002147 if p, ok := m.module.(PrebuiltInterface); ok && p.Prebuilt() != nil {
2148 SetProvider(ctx, PrebuiltModuleProviderKey, PrebuiltModuleProviderData{})
2149 }
2150 if h, ok := m.module.(HostToolProvider); ok {
2151 SetProvider(ctx, HostToolProviderKey, HostToolProviderData{
2152 HostToolPath: h.HostToolPath()})
2153 }
Yu Liue70976d2024-10-15 20:45:35 +00002154
Yu Liub5275322024-11-13 18:40:43 +00002155 if p, ok := m.module.(AndroidMkProviderInfoProducer); ok && !commonData.SkipAndroidMkProcessing {
Yu Liue70976d2024-10-15 20:45:35 +00002156 SetProvider(ctx, AndroidMkInfoProvider, p.PrepareAndroidMKProviderInfo(ctx.Config()))
2157 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002158}
2159
Joe Onorato349ae8d2024-02-05 22:46:00 +00002160func SetJarJarPrefixHandler(handler func(ModuleContext)) {
2161 if jarJarPrefixHandler != nil {
2162 panic("jarJarPrefixHandler already set")
2163 }
2164 jarJarPrefixHandler = handler
2165}
2166
Colin Crossd6fd0132023-11-06 13:54:06 -08002167func (m *ModuleBase) moduleInfoRegisterName(ctx ModuleContext, subName string) string {
2168 name := m.BaseModuleName()
2169
2170 prefix := ""
2171 if ctx.Host() {
2172 if ctx.Os() != ctx.Config().BuildOS {
2173 prefix = "host_cross_"
2174 }
2175 }
2176 suffix := ""
2177 arches := slices.Clone(ctx.Config().Targets[ctx.Os()])
2178 arches = slices.DeleteFunc(arches, func(target Target) bool {
2179 return target.NativeBridge != ctx.Target().NativeBridge
2180 })
2181 if len(arches) > 0 && ctx.Arch().ArchType != arches[0].Arch.ArchType {
2182 if ctx.Arch().ArchType.Multilib == "lib32" {
2183 suffix = "_32"
2184 } else {
2185 suffix = "_64"
2186 }
2187 }
2188 return prefix + name + subName + suffix
2189}
2190
2191func (m *ModuleBase) moduleInfoVariant(ctx ModuleContext) string {
2192 variant := "DEVICE"
2193 if ctx.Host() {
2194 if ctx.Os() != ctx.Config().BuildOS {
2195 variant = "HOST_CROSS"
2196 } else {
2197 variant = "HOST"
2198 }
2199 }
2200 return variant
2201}
2202
Paul Duffin89968e32020-11-23 18:17:03 +00002203// Check the supplied dist structure to make sure that it is valid.
2204//
2205// property - the base property, e.g. dist or dists[1], which is combined with the
2206// name of the nested property to produce the full property, e.g. dist.dest or
2207// dists[1].dir.
2208func checkDistProperties(ctx *moduleContext, property string, dist *Dist) {
2209 if dist.Dest != nil {
2210 _, err := validateSafePath(*dist.Dest)
2211 if err != nil {
2212 ctx.PropertyErrorf(property+".dest", "%s", err.Error())
2213 }
2214 }
2215 if dist.Dir != nil {
2216 _, err := validateSafePath(*dist.Dir)
2217 if err != nil {
2218 ctx.PropertyErrorf(property+".dir", "%s", err.Error())
2219 }
2220 }
2221 if dist.Suffix != nil {
2222 if strings.Contains(*dist.Suffix, "/") {
2223 ctx.PropertyErrorf(property+".suffix", "Suffix may not contain a '/' character.")
2224 }
2225 }
2226
2227}
2228
Colin Cross6301c3c2021-09-28 17:40:21 -07002229// katiInstall stores a request from Soong to Make to create an install rule.
2230type katiInstall struct {
2231 from Path
2232 to InstallPath
2233 implicitDeps Paths
2234 orderOnlyDeps Paths
2235 executable bool
Colin Cross50ed1f92021-11-12 17:41:02 -08002236 extraFiles *extraFilesZip
Yu Liu467d7c52024-09-18 21:54:44 +00002237 absFrom string
Colin Cross6301c3c2021-09-28 17:40:21 -07002238}
2239
Yu Liu467d7c52024-09-18 21:54:44 +00002240type katiInstallGob struct {
2241 From Path
2242 To InstallPath
2243 ImplicitDeps Paths
2244 OrderOnlyDeps Paths
2245 Executable bool
2246 ExtraFiles *extraFilesZip
2247 AbsFrom string
Yu Liu26a716d2024-08-30 23:40:32 +00002248}
2249
Yu Liu467d7c52024-09-18 21:54:44 +00002250func (k *katiInstall) ToGob() *katiInstallGob {
2251 return &katiInstallGob{
2252 From: k.from,
2253 To: k.to,
2254 ImplicitDeps: k.implicitDeps,
2255 OrderOnlyDeps: k.orderOnlyDeps,
2256 Executable: k.executable,
2257 ExtraFiles: k.extraFiles,
2258 AbsFrom: k.absFrom,
Yu Liu26a716d2024-08-30 23:40:32 +00002259 }
Yu Liu467d7c52024-09-18 21:54:44 +00002260}
Yu Liu26a716d2024-08-30 23:40:32 +00002261
Yu Liu467d7c52024-09-18 21:54:44 +00002262func (k *katiInstall) FromGob(data *katiInstallGob) {
2263 k.from = data.From
2264 k.to = data.To
2265 k.implicitDeps = data.ImplicitDeps
2266 k.orderOnlyDeps = data.OrderOnlyDeps
2267 k.executable = data.Executable
2268 k.extraFiles = data.ExtraFiles
2269 k.absFrom = data.AbsFrom
2270}
2271
2272func (k *katiInstall) GobEncode() ([]byte, error) {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002273 return gobtools.CustomGobEncode[katiInstallGob](k)
Yu Liu467d7c52024-09-18 21:54:44 +00002274}
2275
2276func (k *katiInstall) GobDecode(data []byte) error {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002277 return gobtools.CustomGobDecode[katiInstallGob](data, k)
Yu Liu26a716d2024-08-30 23:40:32 +00002278}
2279
Colin Cross50ed1f92021-11-12 17:41:02 -08002280type extraFilesZip struct {
2281 zip Path
2282 dir InstallPath
2283}
2284
Yu Liu467d7c52024-09-18 21:54:44 +00002285type extraFilesZipGob struct {
2286 Zip Path
2287 Dir InstallPath
Yu Liu26a716d2024-08-30 23:40:32 +00002288}
2289
Yu Liu467d7c52024-09-18 21:54:44 +00002290func (e *extraFilesZip) ToGob() *extraFilesZipGob {
2291 return &extraFilesZipGob{
2292 Zip: e.zip,
2293 Dir: e.dir,
Yu Liu26a716d2024-08-30 23:40:32 +00002294 }
Yu Liu467d7c52024-09-18 21:54:44 +00002295}
Yu Liu26a716d2024-08-30 23:40:32 +00002296
Yu Liu467d7c52024-09-18 21:54:44 +00002297func (e *extraFilesZip) FromGob(data *extraFilesZipGob) {
2298 e.zip = data.Zip
2299 e.dir = data.Dir
2300}
2301
2302func (e *extraFilesZip) GobEncode() ([]byte, error) {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002303 return gobtools.CustomGobEncode[extraFilesZipGob](e)
Yu Liu467d7c52024-09-18 21:54:44 +00002304}
2305
2306func (e *extraFilesZip) GobDecode(data []byte) error {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002307 return gobtools.CustomGobDecode[extraFilesZipGob](data, e)
Yu Liu26a716d2024-08-30 23:40:32 +00002308}
2309
Colin Cross6301c3c2021-09-28 17:40:21 -07002310type katiInstalls []katiInstall
2311
2312// BuiltInstalled returns the katiInstalls in the form used by $(call copy-many-files) in Make, a
2313// space separated list of from:to tuples.
2314func (installs katiInstalls) BuiltInstalled() string {
2315 sb := strings.Builder{}
2316 for i, install := range installs {
2317 if i != 0 {
2318 sb.WriteRune(' ')
2319 }
2320 sb.WriteString(install.from.String())
2321 sb.WriteRune(':')
2322 sb.WriteString(install.to.String())
2323 }
2324 return sb.String()
2325}
2326
2327// InstallPaths returns the install path of each entry.
2328func (installs katiInstalls) InstallPaths() InstallPaths {
2329 paths := make(InstallPaths, 0, len(installs))
2330 for _, install := range installs {
2331 paths = append(paths, install.to)
2332 }
2333 return paths
2334}
2335
Jiyong Park5baac542018-08-28 09:55:37 +09002336// Makes this module a platform module, i.e. not specific to soc, device,
Justin Yund5f6c822019-06-25 16:47:17 +09002337// product, or system_ext.
Colin Cross4157e882019-06-06 16:57:04 -07002338func (m *ModuleBase) MakeAsPlatform() {
2339 m.commonProperties.Vendor = boolPtr(false)
2340 m.commonProperties.Proprietary = boolPtr(false)
2341 m.commonProperties.Soc_specific = boolPtr(false)
2342 m.commonProperties.Product_specific = boolPtr(false)
Justin Yund5f6c822019-06-25 16:47:17 +09002343 m.commonProperties.System_ext_specific = boolPtr(false)
Jiyong Park5baac542018-08-28 09:55:37 +09002344}
2345
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002346func (m *ModuleBase) MakeAsSystemExt() {
Jooyung Han91df2082019-11-20 01:49:42 +09002347 m.commonProperties.Vendor = boolPtr(false)
2348 m.commonProperties.Proprietary = boolPtr(false)
2349 m.commonProperties.Soc_specific = boolPtr(false)
2350 m.commonProperties.Product_specific = boolPtr(false)
2351 m.commonProperties.System_ext_specific = boolPtr(true)
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002352}
2353
Jooyung Han344d5432019-08-23 11:17:39 +09002354// IsNativeBridgeSupported returns true if "native_bridge_supported" is explicitly set as "true"
2355func (m *ModuleBase) IsNativeBridgeSupported() bool {
2356 return proptools.Bool(m.commonProperties.Native_bridge_supported)
2357}
2358
Jihoon Kang0d545b82024-10-11 00:21:57 +00002359func (m *ModuleBase) DecodeMultilib(ctx ConfigContext) (string, string) {
2360 return decodeMultilib(ctx, m)
2361}
2362
Spandan Dase1860e42024-10-24 22:29:50 +00002363func (m *ModuleBase) Overrides() []string {
2364 return m.commonProperties.Overrides
2365}
2366
Colin Cross8bbc3d52024-09-11 15:33:54 -07002367type ConfigContext interface {
2368 Config() Config
2369}
2370
Cole Fauste8a87832024-09-11 11:35:46 -07002371type ConfigurableEvaluatorContext interface {
Cole Faust55b56fe2024-08-23 12:06:11 -07002372 OtherModuleProviderContext
Cole Faust02987bd2024-03-21 17:58:43 -07002373 Config() Config
2374 OtherModulePropertyErrorf(module Module, property string, fmt string, args ...interface{})
Cole Faustd7067092024-09-13 13:37:59 -07002375 HasMutatorFinished(mutatorName string) bool
Cole Faust02987bd2024-03-21 17:58:43 -07002376}
2377
2378type configurationEvalutor struct {
Cole Fauste8a87832024-09-11 11:35:46 -07002379 ctx ConfigurableEvaluatorContext
Cole Faust02987bd2024-03-21 17:58:43 -07002380 m Module
2381}
2382
Cole Fauste8a87832024-09-11 11:35:46 -07002383func (m *ModuleBase) ConfigurableEvaluator(ctx ConfigurableEvaluatorContext) proptools.ConfigurableEvaluator {
Cole Faust02987bd2024-03-21 17:58:43 -07002384 return configurationEvalutor{
2385 ctx: ctx,
2386 m: m.module,
2387 }
2388}
2389
2390func (e configurationEvalutor) PropertyErrorf(property string, fmt string, args ...interface{}) {
Cole Fausta963b942024-04-11 17:43:00 -07002391 e.ctx.OtherModulePropertyErrorf(e.m, property, fmt, args...)
Cole Faust02987bd2024-03-21 17:58:43 -07002392}
2393
Cole Faustfdbf5d42024-04-10 15:01:23 -07002394func (e configurationEvalutor) EvaluateConfiguration(condition proptools.ConfigurableCondition, property string) proptools.ConfigurableValue {
Cole Faust02987bd2024-03-21 17:58:43 -07002395 ctx := e.ctx
2396 m := e.m
Cole Faustd7067092024-09-13 13:37:59 -07002397
2398 if !ctx.HasMutatorFinished("defaults") {
2399 ctx.OtherModulePropertyErrorf(m, property, "Cannot evaluate configurable property before the defaults mutator has run")
2400 return proptools.ConfigurableValueUndefined()
2401 }
2402
Cole Faust8afc5142024-04-26 16:30:19 -07002403 switch condition.FunctionName() {
Cole Fauste19f7412024-05-09 15:14:04 -07002404 case "release_flag":
Cole Faust8afc5142024-04-26 16:30:19 -07002405 if condition.NumArgs() != 1 {
Cole Fauste19f7412024-05-09 15:14:04 -07002406 ctx.OtherModulePropertyErrorf(m, property, "release_flag requires 1 argument, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002407 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002408 }
Cole Faust751a4a52024-05-21 16:51:59 -07002409 if ty, ok := ctx.Config().productVariables.BuildFlagTypes[condition.Arg(0)]; ok {
2410 v := ctx.Config().productVariables.BuildFlags[condition.Arg(0)]
2411 switch ty {
2412 case "unspecified", "obsolete":
2413 return proptools.ConfigurableValueUndefined()
2414 case "string":
2415 return proptools.ConfigurableValueString(v)
2416 case "bool":
2417 return proptools.ConfigurableValueBool(v == "true")
2418 default:
2419 panic("unhandled release flag type: " + ty)
2420 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002421 }
2422 return proptools.ConfigurableValueUndefined()
2423 case "product_variable":
Jiyong Parke3250752024-05-17 14:56:10 +09002424 if condition.NumArgs() != 1 {
2425 ctx.OtherModulePropertyErrorf(m, property, "product_variable requires 1 argument, found %d", condition.NumArgs())
2426 return proptools.ConfigurableValueUndefined()
2427 }
2428 variable := condition.Arg(0)
2429 switch variable {
Jihoon Kang82bea762024-09-30 18:50:54 +00002430 case "build_from_text_stub":
2431 return proptools.ConfigurableValueBool(ctx.Config().BuildFromTextStub())
Jiyong Parke3250752024-05-17 14:56:10 +09002432 case "debuggable":
2433 return proptools.ConfigurableValueBool(ctx.Config().Debuggable())
Kiyoung Kim881e4652024-07-08 11:02:23 +09002434 case "use_debug_art":
2435 // TODO(b/234351700): Remove once ART does not have separated debug APEX
2436 return proptools.ConfigurableValueBool(ctx.Config().UseDebugArt())
kellyhung1e613d22024-07-29 12:56:51 +00002437 case "selinux_ignore_neverallows":
2438 return proptools.ConfigurableValueBool(ctx.Config().SelinuxIgnoreNeverallows())
Jiyong Parke3250752024-05-17 14:56:10 +09002439 default:
2440 // TODO(b/323382414): Might add these on a case-by-case basis
2441 ctx.OtherModulePropertyErrorf(m, property, fmt.Sprintf("TODO(b/323382414): Product variable %q is not yet supported in selects", variable))
2442 return proptools.ConfigurableValueUndefined()
2443 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002444 case "soong_config_variable":
Cole Faust8afc5142024-04-26 16:30:19 -07002445 if condition.NumArgs() != 2 {
2446 ctx.OtherModulePropertyErrorf(m, property, "soong_config_variable requires 2 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002447 return proptools.ConfigurableValueUndefined()
2448 }
Cole Faust8afc5142024-04-26 16:30:19 -07002449 namespace := condition.Arg(0)
2450 variable := condition.Arg(1)
Cole Faust02987bd2024-03-21 17:58:43 -07002451 if n, ok := ctx.Config().productVariables.VendorVars[namespace]; ok {
2452 if v, ok := n[variable]; ok {
Cole Faust46f6e2f2024-06-20 12:57:43 -07002453 ty := ""
2454 if namespaces, ok := ctx.Config().productVariables.VendorVarTypes[namespace]; ok {
2455 ty = namespaces[variable]
2456 }
2457 switch ty {
2458 case "":
2459 // strings are the default, we don't bother writing them to the soong variables json file
2460 return proptools.ConfigurableValueString(v)
2461 case "bool":
2462 return proptools.ConfigurableValueBool(v == "true")
Cole Faust4143ee82024-11-21 11:20:06 -08002463 case "string_list":
2464 return proptools.ConfigurableValueStringList(strings.Split(v, " "))
Cole Faust46f6e2f2024-06-20 12:57:43 -07002465 default:
2466 panic("unhandled soong config variable type: " + ty)
2467 }
2468
Cole Faust02987bd2024-03-21 17:58:43 -07002469 }
2470 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002471 return proptools.ConfigurableValueUndefined()
Cole Faustfc57d402024-04-11 12:09:44 -07002472 case "arch":
Cole Faust8afc5142024-04-26 16:30:19 -07002473 if condition.NumArgs() != 0 {
2474 ctx.OtherModulePropertyErrorf(m, property, "arch requires no arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002475 return proptools.ConfigurableValueUndefined()
2476 }
Cole Faustfc57d402024-04-11 12:09:44 -07002477 if !m.base().ArchReady() {
2478 ctx.OtherModulePropertyErrorf(m, property, "A select on arch was attempted before the arch mutator ran")
2479 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002480 }
Cole Faustfc57d402024-04-11 12:09:44 -07002481 return proptools.ConfigurableValueString(m.base().Arch().ArchType.Name)
2482 case "os":
Cole Faust8afc5142024-04-26 16:30:19 -07002483 if condition.NumArgs() != 0 {
2484 ctx.OtherModulePropertyErrorf(m, property, "os requires no arguments, found %d", condition.NumArgs())
Cole Faustfc57d402024-04-11 12:09:44 -07002485 return proptools.ConfigurableValueUndefined()
2486 }
2487 // the arch mutator runs after the os mutator, we can just use this to enforce that os is ready.
2488 if !m.base().ArchReady() {
2489 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)")
2490 return proptools.ConfigurableValueUndefined()
2491 }
2492 return proptools.ConfigurableValueString(m.base().Os().Name)
Cole Faustfdbf5d42024-04-10 15:01:23 -07002493 case "boolean_var_for_testing":
2494 // We currently don't have any other boolean variables (we should add support for typing
2495 // the soong config variables), so add this fake one for testing the boolean select
2496 // functionality.
Cole Faust8afc5142024-04-26 16:30:19 -07002497 if condition.NumArgs() != 0 {
2498 ctx.OtherModulePropertyErrorf(m, property, "boolean_var_for_testing requires 0 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002499 return proptools.ConfigurableValueUndefined()
2500 }
2501
2502 if n, ok := ctx.Config().productVariables.VendorVars["boolean_var"]; ok {
2503 if v, ok := n["for_testing"]; ok {
2504 switch v {
2505 case "true":
2506 return proptools.ConfigurableValueBool(true)
2507 case "false":
2508 return proptools.ConfigurableValueBool(false)
2509 default:
2510 ctx.OtherModulePropertyErrorf(m, property, "testing:my_boolean_var can only be true or false, found %q", v)
2511 }
2512 }
2513 }
2514 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002515 default:
Cole Faustfdbf5d42024-04-10 15:01:23 -07002516 ctx.OtherModulePropertyErrorf(m, property, "Unknown select condition %s", condition.FunctionName)
2517 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002518 }
2519}
2520
Colin Crossb63d7b32023-12-07 16:54:51 -08002521// ModuleNameWithPossibleOverride returns the name of the OverrideModule that overrides the current
2522// variant of this OverridableModule, or ctx.ModuleName() if this module is not an OverridableModule
2523// or if this variant is not overridden.
2524func ModuleNameWithPossibleOverride(ctx BaseModuleContext) string {
2525 if overridable, ok := ctx.Module().(OverridableModule); ok {
2526 if o := overridable.GetOverriddenBy(); o != "" {
2527 return o
2528 }
2529 }
2530 return ctx.ModuleName()
2531}
2532
Paul Duffine6ba0722021-07-12 20:12:12 +01002533// SrcIsModule decodes module references in the format ":unqualified-name" or "//namespace:name"
2534// into the module name, or empty string if the input was not a module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002535func SrcIsModule(s string) (module string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002536 if len(s) > 1 {
2537 if s[0] == ':' {
2538 module = s[1:]
2539 if !isUnqualifiedModuleName(module) {
2540 // The module name should be unqualified but is not so do not treat it as a module.
2541 module = ""
2542 }
2543 } else if s[0] == '/' && s[1] == '/' {
2544 module = s
2545 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002546 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002547 return module
Colin Cross068e0fe2016-12-13 15:23:47 -08002548}
2549
Yi-Yo Chiangba9ea322021-07-15 17:18:21 +08002550// SrcIsModuleWithTag decodes module references in the format ":unqualified-name{.tag}" or
2551// "//namespace:name{.tag}" into the module name and tag, ":unqualified-name" or "//namespace:name"
2552// into the module name and an empty string for the tag, or empty strings if the input was not a
2553// module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002554func SrcIsModuleWithTag(s string) (module, tag string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002555 if len(s) > 1 {
2556 if s[0] == ':' {
2557 module = s[1:]
2558 } else if s[0] == '/' && s[1] == '/' {
2559 module = s
2560 }
2561
2562 if module != "" {
2563 if tagStart := strings.IndexByte(module, '{'); tagStart > 0 {
2564 if module[len(module)-1] == '}' {
2565 tag = module[tagStart+1 : len(module)-1]
2566 module = module[:tagStart]
2567 }
2568 }
2569
2570 if s[0] == ':' && !isUnqualifiedModuleName(module) {
2571 // The module name should be unqualified but is not so do not treat it as a module.
2572 module = ""
2573 tag = ""
Colin Cross41955e82019-05-29 14:40:35 -07002574 }
2575 }
Colin Cross41955e82019-05-29 14:40:35 -07002576 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002577
2578 return module, tag
2579}
2580
2581// isUnqualifiedModuleName makes sure that the supplied module is an unqualified module name, i.e.
2582// does not contain any /.
2583func isUnqualifiedModuleName(module string) bool {
2584 return strings.IndexByte(module, '/') == -1
Colin Cross068e0fe2016-12-13 15:23:47 -08002585}
2586
Paul Duffin40131a32021-07-09 17:10:35 +01002587// sourceOrOutputDependencyTag is the dependency tag added automatically by pathDepsMutator for any
2588// module reference in a property annotated with `android:"path"` or passed to ExtractSourceDeps
2589// or ExtractSourcesDeps.
2590//
2591// If uniquely identifies the dependency that was added as it contains both the module name used to
2592// add the dependency as well as the tag. That makes it very simple to find the matching dependency
2593// in GetModuleFromPathDep as all it needs to do is find the dependency whose tag matches the tag
2594// used to add it. It does not need to check that the module name as returned by one of
2595// Module.Name(), BaseModuleContext.OtherModuleName() or ModuleBase.BaseModuleName() matches the
2596// name supplied in the tag. That means it does not need to handle differences in module names
2597// caused by prebuilt_ prefix, or fully qualified module names.
Colin Cross41955e82019-05-29 14:40:35 -07002598type sourceOrOutputDependencyTag struct {
2599 blueprint.BaseDependencyTag
Yu Liu67a28422024-03-05 00:36:31 +00002600 AlwaysPropagateAconfigValidationDependencyTag
Paul Duffin40131a32021-07-09 17:10:35 +01002601
2602 // The name of the module.
2603 moduleName string
2604
mrziwangd38e63d2024-07-15 13:43:37 -07002605 // The tag that will be used to get the specific output file(s).
Colin Cross41955e82019-05-29 14:40:35 -07002606 tag string
2607}
2608
Paul Duffin40131a32021-07-09 17:10:35 +01002609func sourceOrOutputDepTag(moduleName, tag string) blueprint.DependencyTag {
2610 return sourceOrOutputDependencyTag{moduleName: moduleName, tag: tag}
Colin Cross41955e82019-05-29 14:40:35 -07002611}
2612
Paul Duffind5cf92e2021-07-09 17:38:55 +01002613// IsSourceDepTagWithOutputTag returns true if the supplied blueprint.DependencyTag is one that was
2614// used to add dependencies by either ExtractSourceDeps, ExtractSourcesDeps or automatically for
2615// properties tagged with `android:"path"` AND it was added using a module reference of
2616// :moduleName{outputTag}.
2617func IsSourceDepTagWithOutputTag(depTag blueprint.DependencyTag, outputTag string) bool {
2618 t, ok := depTag.(sourceOrOutputDependencyTag)
2619 return ok && t.tag == outputTag
2620}
2621
Colin Cross366938f2017-12-11 16:29:02 -08002622// Adds necessary dependencies to satisfy filegroup or generated sources modules listed in srcFiles
2623// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002624//
2625// Deprecated: tag the property with `android:"path"` instead.
Colin Cross068e0fe2016-12-13 15:23:47 -08002626func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) {
Nan Zhang2439eb72017-04-10 11:27:50 -07002627 set := make(map[string]bool)
2628
Colin Cross068e0fe2016-12-13 15:23:47 -08002629 for _, s := range srcFiles {
Colin Cross41955e82019-05-29 14:40:35 -07002630 if m, t := SrcIsModuleWithTag(s); m != "" {
2631 if _, found := set[s]; found {
2632 ctx.ModuleErrorf("found source dependency duplicate: %q!", s)
Nan Zhang2439eb72017-04-10 11:27:50 -07002633 } else {
Colin Cross41955e82019-05-29 14:40:35 -07002634 set[s] = true
Paul Duffin40131a32021-07-09 17:10:35 +01002635 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Nan Zhang2439eb72017-04-10 11:27:50 -07002636 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002637 }
2638 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002639}
2640
Colin Cross366938f2017-12-11 16:29:02 -08002641// Adds necessary dependencies to satisfy filegroup or generated sources modules specified in s
2642// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002643//
2644// Deprecated: tag the property with `android:"path"` instead.
Colin Cross366938f2017-12-11 16:29:02 -08002645func ExtractSourceDeps(ctx BottomUpMutatorContext, s *string) {
2646 if s != nil {
Colin Cross41955e82019-05-29 14:40:35 -07002647 if m, t := SrcIsModuleWithTag(*s); m != "" {
Paul Duffin40131a32021-07-09 17:10:35 +01002648 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Colin Cross366938f2017-12-11 16:29:02 -08002649 }
2650 }
2651}
2652
Colin Cross41955e82019-05-29 14:40:35 -07002653// A module that implements SourceFileProducer can be referenced from any property that is tagged with `android:"path"`
2654// 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 -08002655type SourceFileProducer interface {
2656 Srcs() Paths
2657}
2658
mrziwangd38e63d2024-07-15 13:43:37 -07002659// OutputFilesForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002660// module produced zero paths, it reports errors to the ctx and returns nil.
Yu Liud3228ac2024-11-08 23:11:47 +00002661func OutputFilesForModule(ctx PathContext, module Module, tag string) Paths {
Colin Cross5e708052019-08-06 13:59:50 -07002662 paths, err := outputFilesForModule(ctx, module, tag)
2663 if err != nil {
2664 reportPathError(ctx, err)
2665 return nil
2666 }
2667 return paths
2668}
2669
mrziwangd38e63d2024-07-15 13:43:37 -07002670// OutputFileForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002671// module produced zero or multiple paths, it reports errors to the ctx and returns nil.
Yu Liud3228ac2024-11-08 23:11:47 +00002672func OutputFileForModule(ctx PathContext, module Module, tag string) Path {
Colin Cross5e708052019-08-06 13:59:50 -07002673 paths, err := outputFilesForModule(ctx, module, tag)
2674 if err != nil {
2675 reportPathError(ctx, err)
2676 return nil
2677 }
Colin Cross14ec66c2022-10-03 21:02:27 -07002678 if len(paths) == 0 {
2679 type addMissingDependenciesIntf interface {
2680 AddMissingDependencies([]string)
2681 OtherModuleName(blueprint.Module) string
2682 }
2683 if mctx, ok := ctx.(addMissingDependenciesIntf); ok && ctx.Config().AllowMissingDependencies() {
2684 mctx.AddMissingDependencies([]string{mctx.OtherModuleName(module)})
2685 } else {
2686 ReportPathErrorf(ctx, "failed to get output files from module %q", pathContextName(ctx, module))
2687 }
2688 // Return a fake output file to avoid nil dereferences of Path objects later.
2689 // This should never get used for an actual build as the error or missing
2690 // dependency has already been reported.
2691 p, err := pathForSource(ctx, filepath.Join("missing_output_file", pathContextName(ctx, module)))
2692 if err != nil {
2693 reportPathError(ctx, err)
2694 return nil
2695 }
2696 return p
2697 }
Colin Cross5e708052019-08-06 13:59:50 -07002698 if len(paths) > 1 {
Ulya Trafimovich5ab276a2020-08-25 12:45:15 +01002699 ReportPathErrorf(ctx, "got multiple output files from module %q, expected exactly one",
Colin Cross5e708052019-08-06 13:59:50 -07002700 pathContextName(ctx, module))
Colin Cross5e708052019-08-06 13:59:50 -07002701 }
2702 return paths[0]
2703}
2704
Yu Liud3228ac2024-11-08 23:11:47 +00002705type OutputFilesProviderModuleContext interface {
2706 OtherModuleProviderContext
2707 Module() Module
2708 GetOutputFiles() OutputFilesInfo
2709 EqualModules(m1, m2 Module) bool
2710}
2711
2712func outputFilesForModule(ctx PathContext, module Module, tag string) (Paths, error) {
mrziwange6c85812024-05-22 14:36:09 -07002713 outputFilesFromProvider, err := outputFilesForModuleFromProvider(ctx, module, tag)
mrziwangabdb2932024-06-18 12:43:41 -07002714 if outputFilesFromProvider != nil || err != OutputFilesProviderNotSet {
mrziwange6c85812024-05-22 14:36:09 -07002715 return outputFilesFromProvider, err
2716 }
Yu Liud3228ac2024-11-08 23:11:47 +00002717
2718 if octx, ok := ctx.(OutputFilesProviderModuleContext); ok {
2719 if octx.EqualModules(octx.Module(), module) {
2720 if sourceFileProducer, ok := module.(SourceFileProducer); ok {
2721 return sourceFileProducer.Srcs(), nil
2722 }
2723 } else if sourceFiles, ok := OtherModuleProvider(octx, module, SourceFilesInfoKey); ok {
2724 if tag != "" {
2725 return nil, fmt.Errorf("module %q is a SourceFileProducer, which does not support tag %q", pathContextName(ctx, module), tag)
2726 }
2727 paths := sourceFiles.Srcs
2728 return paths, nil
Colin Cross74b1e2b2020-11-22 20:23:02 -08002729 }
Colin Cross5e708052019-08-06 13:59:50 -07002730 }
Yu Liud3228ac2024-11-08 23:11:47 +00002731
2732 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 -07002733}
2734
mrziwange6c85812024-05-22 14:36:09 -07002735// This method uses OutputFilesProvider for output files
2736// *inter-module-communication*.
2737// If mctx module is the same as the param module the output files are obtained
2738// from outputFiles property of module base, to avoid both setting and
mrziwang42953592024-06-20 09:53:33 -07002739// reading OutputFilesProvider before GenerateBuildActions is finished.
mrziwange6c85812024-05-22 14:36:09 -07002740// If a module doesn't have the OutputFilesProvider, nil is returned.
Yu Liud3228ac2024-11-08 23:11:47 +00002741func outputFilesForModuleFromProvider(ctx PathContext, module Module, tag string) (Paths, error) {
mrziwangabdb2932024-06-18 12:43:41 -07002742 var outputFiles OutputFilesInfo
2743 fromProperty := false
mrziwang0cbd3b02024-06-20 16:39:25 -07002744
mrziwang1ea01e32024-07-12 12:26:34 -07002745 if mctx, isMctx := ctx.(OutputFilesProviderModuleContext); isMctx {
Yu Liud3228ac2024-11-08 23:11:47 +00002746 if !mctx.EqualModules(mctx.Module(), module) {
mrziwangabdb2932024-06-18 12:43:41 -07002747 outputFiles, _ = OtherModuleProvider(mctx, module, OutputFilesProvider)
mrziwang0cbd3b02024-06-20 16:39:25 -07002748 } else {
Yu Liu876b7ce2024-08-21 18:20:13 +00002749 outputFiles = mctx.GetOutputFiles()
mrziwangabdb2932024-06-18 12:43:41 -07002750 fromProperty = true
mrziwange6c85812024-05-22 14:36:09 -07002751 }
mrziwang0cbd3b02024-06-20 16:39:25 -07002752 } else if cta, isCta := ctx.(*singletonContextAdaptor); isCta {
Yu Liud3228ac2024-11-08 23:11:47 +00002753 outputFiles, _ = OtherModuleProvider(cta, module, OutputFilesProvider)
mrziwang7a47bd32024-07-17 11:11:05 -07002754 } else {
2755 return nil, fmt.Errorf("unsupported context %q in method outputFilesForModuleFromProvider", reflect.TypeOf(ctx))
mrziwang0cbd3b02024-06-20 16:39:25 -07002756 }
mrziwang0cbd3b02024-06-20 16:39:25 -07002757
mrziwangabdb2932024-06-18 12:43:41 -07002758 if outputFiles.isEmpty() {
mrziwangabdb2932024-06-18 12:43:41 -07002759 return nil, OutputFilesProviderNotSet
2760 }
2761
2762 if tag == "" {
2763 return outputFiles.DefaultOutputFiles, nil
2764 } else if taggedOutputFiles, hasTag := outputFiles.TaggedOutputFiles[tag]; hasTag {
2765 return taggedOutputFiles, nil
2766 } else {
2767 if fromProperty {
2768 return nil, fmt.Errorf("unsupported tag %q for module getting its own output files", tag)
mrziwange6c85812024-05-22 14:36:09 -07002769 } else {
mrziwang0cbd3b02024-06-20 16:39:25 -07002770 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
mrziwange6c85812024-05-22 14:36:09 -07002771 }
2772 }
mrziwange6c85812024-05-22 14:36:09 -07002773}
2774
mrziwang0cbd3b02024-06-20 16:39:25 -07002775func (o OutputFilesInfo) isEmpty() bool {
2776 return o.DefaultOutputFiles == nil && o.TaggedOutputFiles == nil
2777}
2778
mrziwange6c85812024-05-22 14:36:09 -07002779type OutputFilesInfo struct {
2780 // default output files when tag is an empty string ""
2781 DefaultOutputFiles Paths
2782
2783 // the corresponding output files for given tags
2784 TaggedOutputFiles map[string]Paths
2785}
2786
2787var OutputFilesProvider = blueprint.NewProvider[OutputFilesInfo]()
2788
mrziwangabdb2932024-06-18 12:43:41 -07002789// This is used to mark the case where OutputFilesProvider is not set on some modules.
2790var OutputFilesProviderNotSet = fmt.Errorf("No output files from provider")
2791
Colin Cross41589502020-12-01 14:00:21 -08002792// Modules can implement HostToolProvider and return a valid OptionalPath from HostToolPath() to
2793// specify that they can be used as a tool by a genrule module.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002794type HostToolProvider interface {
Colin Crossba9e4032020-11-24 16:32:22 -08002795 Module
Colin Cross41589502020-12-01 14:00:21 -08002796 // HostToolPath returns the path to the host tool for the module if it is one, or an invalid
2797 // OptionalPath.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002798 HostToolPath() OptionalPath
2799}
2800
Colin Cross463a90e2015-06-17 14:20:06 -07002801func init() {
LaMont Jones0c10e4d2023-05-16 00:58:37 +00002802 RegisterParallelSingletonType("buildtarget", BuildTargetSingleton)
Colin Cross463a90e2015-06-17 14:20:06 -07002803}
2804
Colin Cross0875c522017-11-28 17:34:01 -08002805func BuildTargetSingleton() Singleton {
Colin Cross1f8c52b2015-06-16 16:38:17 -07002806 return &buildTargetSingleton{}
2807}
2808
Colin Cross87d8b562017-04-25 10:01:55 -07002809func parentDir(dir string) string {
2810 dir, _ = filepath.Split(dir)
2811 return filepath.Clean(dir)
2812}
2813
Colin Cross1f8c52b2015-06-16 16:38:17 -07002814type buildTargetSingleton struct{}
2815
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002816func AddAncestors(ctx SingletonContext, dirMap map[string]Paths, mmName func(string) string) ([]string, []string) {
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002817 // Ensure ancestor directories are in dirMap
2818 // Make directories build their direct subdirectories
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002819 // Returns a slice of all directories and a slice of top-level directories.
Cole Faust18994c72023-02-28 16:02:16 -08002820 dirs := SortedKeys(dirMap)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002821 for _, dir := range dirs {
2822 dir := parentDir(dir)
2823 for dir != "." && dir != "/" {
2824 if _, exists := dirMap[dir]; exists {
2825 break
2826 }
2827 dirMap[dir] = nil
2828 dir = parentDir(dir)
2829 }
2830 }
Cole Faust18994c72023-02-28 16:02:16 -08002831 dirs = SortedKeys(dirMap)
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002832 var topDirs []string
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002833 for _, dir := range dirs {
2834 p := parentDir(dir)
2835 if p != "." && p != "/" {
2836 dirMap[p] = append(dirMap[p], PathForPhony(ctx, mmName(dir)))
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002837 } else if dir != "." && dir != "/" && dir != "" {
2838 topDirs = append(topDirs, dir)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002839 }
2840 }
Cole Faust18994c72023-02-28 16:02:16 -08002841 return SortedKeys(dirMap), topDirs
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002842}
2843
Colin Cross0875c522017-11-28 17:34:01 -08002844func (c *buildTargetSingleton) GenerateBuildActions(ctx SingletonContext) {
2845 var checkbuildDeps Paths
Colin Cross1f8c52b2015-06-16 16:38:17 -07002846
Colin Crossc3d87d32020-06-04 13:25:17 -07002847 mmTarget := func(dir string) string {
2848 return "MODULES-IN-" + strings.Replace(filepath.Clean(dir), "/", "-", -1)
Colin Cross87d8b562017-04-25 10:01:55 -07002849 }
2850
Colin Cross0875c522017-11-28 17:34:01 -08002851 modulesInDir := make(map[string]Paths)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002852
Colin Cross0875c522017-11-28 17:34:01 -08002853 ctx.VisitAllModules(func(module Module) {
Yu Liuddc2e1a2024-08-20 21:31:22 +00002854 info := OtherModuleProviderOrDefault(ctx, module, FinalModuleBuildTargetsProvider)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002855
Yu Liuddc2e1a2024-08-20 21:31:22 +00002856 if info.CheckbuildTarget != nil {
2857 checkbuildDeps = append(checkbuildDeps, info.CheckbuildTarget)
2858 modulesInDir[info.BlueprintDir] = append(modulesInDir[info.BlueprintDir], info.CheckbuildTarget)
Colin Cross0875c522017-11-28 17:34:01 -08002859 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07002860
Yu Liuddc2e1a2024-08-20 21:31:22 +00002861 if info.InstallTarget != nil {
2862 modulesInDir[info.BlueprintDir] = append(modulesInDir[info.BlueprintDir], info.InstallTarget)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002863 }
2864 })
2865
Dan Willemsen5ba07e82015-12-11 13:51:06 -08002866 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05002867 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08002868 suffix = "-soong"
2869 }
2870
Colin Cross1f8c52b2015-06-16 16:38:17 -07002871 // Create a top-level checkbuild target that depends on all modules
Colin Crossc3d87d32020-06-04 13:25:17 -07002872 ctx.Phony("checkbuild"+suffix, checkbuildDeps...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002873
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002874 // Make will generate the MODULES-IN-* targets
Jingwen Chencda22c92020-11-23 00:22:30 -05002875 if ctx.Config().KatiEnabled() {
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002876 return
2877 }
2878
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002879 dirs, _ := AddAncestors(ctx, modulesInDir, mmTarget)
Colin Cross87d8b562017-04-25 10:01:55 -07002880
Dan Willemsend2e95fb2017-09-20 14:30:50 -07002881 // Create a MODULES-IN-<directory> target that depends on all modules in a directory, and
2882 // depends on the MODULES-IN-* targets of all of its subdirectories that contain Android.bp
2883 // files.
Colin Cross1f8c52b2015-06-16 16:38:17 -07002884 for _, dir := range dirs {
Colin Crossc3d87d32020-06-04 13:25:17 -07002885 ctx.Phony(mmTarget(dir), modulesInDir[dir]...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07002886 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07002887
2888 // Create (host|host-cross|target)-<OS> phony rules to build a reduced checkbuild.
Jiyong Park1613e552020-09-14 19:43:17 +09002889 type osAndCross struct {
2890 os OsType
2891 hostCross bool
2892 }
2893 osDeps := map[osAndCross]Paths{}
Colin Cross0875c522017-11-28 17:34:01 -08002894 ctx.VisitAllModules(func(module Module) {
Cole Fausta963b942024-04-11 17:43:00 -07002895 if module.Enabled(ctx) {
Jiyong Park1613e552020-09-14 19:43:17 +09002896 key := osAndCross{os: module.Target().Os, hostCross: module.Target().HostCross}
Yu Liud46e5ae2024-08-15 18:46:17 +00002897 osDeps[key] = append(osDeps[key], OtherModuleProviderOrDefault(ctx, module, InstallFilesProvider).CheckbuildFiles...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002898 }
2899 })
2900
Colin Cross0875c522017-11-28 17:34:01 -08002901 osClass := make(map[string]Paths)
Jiyong Park1613e552020-09-14 19:43:17 +09002902 for key, deps := range osDeps {
Dan Willemsen61d88b82017-09-20 17:29:08 -07002903 var className string
2904
Jiyong Park1613e552020-09-14 19:43:17 +09002905 switch key.os.Class {
Dan Willemsen61d88b82017-09-20 17:29:08 -07002906 case Host:
Jiyong Park1613e552020-09-14 19:43:17 +09002907 if key.hostCross {
2908 className = "host-cross"
2909 } else {
2910 className = "host"
2911 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07002912 case Device:
2913 className = "target"
2914 default:
2915 continue
2916 }
2917
Jiyong Park1613e552020-09-14 19:43:17 +09002918 name := className + "-" + key.os.Name
Colin Crossc3d87d32020-06-04 13:25:17 -07002919 osClass[className] = append(osClass[className], PathForPhony(ctx, name))
Dan Willemsen61d88b82017-09-20 17:29:08 -07002920
Colin Crossc3d87d32020-06-04 13:25:17 -07002921 ctx.Phony(name, deps...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002922 }
2923
2924 // Wrap those into host|host-cross|target phony rules
Cole Faust18994c72023-02-28 16:02:16 -08002925 for _, class := range SortedKeys(osClass) {
Colin Crossc3d87d32020-06-04 13:25:17 -07002926 ctx.Phony(class, osClass[class]...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07002927 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07002928}
Colin Crossd779da42015-12-17 18:00:23 -08002929
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002930// Collect information for opening IDE project files in java/jdeps.go.
2931type IDEInfo interface {
Cole Faustb36d31d2024-08-27 16:04:28 -07002932 IDEInfo(ctx BaseModuleContext, ideInfo *IdeInfo)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002933 BaseModuleName() string
2934}
2935
2936// Extract the base module name from the Import name.
2937// Often the Import name has a prefix "prebuilt_".
2938// Remove the prefix explicitly if needed
2939// until we find a better solution to get the Import name.
2940type IDECustomizedModuleName interface {
2941 IDECustomizedModuleName() string
2942}
2943
Cole Faust08c7f862024-08-27 15:03:59 -07002944// Collect information for opening IDE project files in java/jdeps.go.
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002945type IdeInfo struct {
Cole Faust08c7f862024-08-27 15:03:59 -07002946 BaseModuleName string `json:"-"`
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002947 Deps []string `json:"dependencies,omitempty"`
2948 Srcs []string `json:"srcs,omitempty"`
2949 Aidl_include_dirs []string `json:"aidl_include_dirs,omitempty"`
2950 Jarjar_rules []string `json:"jarjar_rules,omitempty"`
2951 Jars []string `json:"jars,omitempty"`
2952 Classes []string `json:"class,omitempty"`
2953 Installed_paths []string `json:"installed,omitempty"`
patricktu18c82ff2019-05-10 15:48:50 +08002954 SrcJars []string `json:"srcjars,omitempty"`
bralee1fbf4402020-05-21 10:11:59 +08002955 Paths []string `json:"path,omitempty"`
Yikef6282022022-04-13 20:41:01 +08002956 Static_libs []string `json:"static_libs,omitempty"`
2957 Libs []string `json:"libs,omitempty"`
Brandon Lee5d45c6f2018-08-15 15:35:38 -07002958}
Paul Duffinf88d8e02020-05-07 20:21:34 +01002959
Cole Faust08c7f862024-08-27 15:03:59 -07002960// Merge merges two IdeInfos and produces a new one, leaving the origional unchanged
2961func (i IdeInfo) Merge(other IdeInfo) IdeInfo {
2962 return IdeInfo{
2963 Deps: mergeStringLists(i.Deps, other.Deps),
2964 Srcs: mergeStringLists(i.Srcs, other.Srcs),
2965 Aidl_include_dirs: mergeStringLists(i.Aidl_include_dirs, other.Aidl_include_dirs),
2966 Jarjar_rules: mergeStringLists(i.Jarjar_rules, other.Jarjar_rules),
2967 Jars: mergeStringLists(i.Jars, other.Jars),
2968 Classes: mergeStringLists(i.Classes, other.Classes),
2969 Installed_paths: mergeStringLists(i.Installed_paths, other.Installed_paths),
2970 SrcJars: mergeStringLists(i.SrcJars, other.SrcJars),
2971 Paths: mergeStringLists(i.Paths, other.Paths),
2972 Static_libs: mergeStringLists(i.Static_libs, other.Static_libs),
2973 Libs: mergeStringLists(i.Libs, other.Libs),
2974 }
2975}
2976
2977// mergeStringLists appends the two string lists together and returns a new string list,
2978// leaving the originals unchanged. Duplicate strings will be deduplicated.
2979func mergeStringLists(a, b []string) []string {
2980 return FirstUniqueStrings(Concat(a, b))
2981}
2982
2983var IdeInfoProviderKey = blueprint.NewProvider[IdeInfo]()
2984
Paul Duffinf88d8e02020-05-07 20:21:34 +01002985func CheckBlueprintSyntax(ctx BaseModuleContext, filename string, contents string) []error {
2986 bpctx := ctx.blueprintBaseModuleContext()
2987 return blueprint.CheckBlueprintSyntax(bpctx.ModuleFactories(), filename, contents)
2988}