blob: 0ffb6cb53d17ca6319cd4f9b2cdb14d790030ed3 [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 Yun885a7de2021-06-29 20:34:53 +090097 EffectiveLicenseFiles() Paths
Colin Cross36242852017-06-23 15:06:31 -070098
99 AddProperties(props ...interface{})
100 GetProperties() []interface{}
Colin Crosscec81712017-07-13 14:43:27 -0700101
Colin Crossae887032017-10-23 17:16:14 -0700102 BuildParamsForTests() []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -0800103 RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800104 VariablesForTests() map[string]string
Paul Duffine2453c72019-05-31 14:00:04 +0100105
Colin Cross9a362232019-07-01 15:32:45 -0700106 // String returns a string that includes the module name and variants for printing during debugging.
107 String() string
108
Paul Duffine2453c72019-05-31 14:00:04 +0100109 // Get the qualified module id for this module.
110 qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName
111
112 // Get information about the properties that can contain visibility rules.
113 visibilityProperties() []visibilityProperty
Paul Duffin63c6e182019-07-24 14:24:38 +0100114
Cole Fauste8a87832024-09-11 11:35:46 -0700115 RequiredModuleNames(ctx ConfigurableEvaluatorContext) []string
Jiyong Park6a8cf5f2019-12-30 16:31:09 +0900116 HostRequiredModuleNames() []string
117 TargetRequiredModuleNames() []string
Cole Fauste8a87832024-09-11 11:35:46 -0700118 VintfFragmentModuleNames(ctx ConfigurableEvaluatorContext) []string
Kiyoung Kim23be5bb2024-11-27 00:50:30 +0000119 VintfFragments(ctx ConfigurableEvaluatorContext) []string
Colin Cross897266e2020-02-13 13:22:08 -0800120
Cole Fauste8a87832024-09-11 11:35:46 -0700121 ConfigurableEvaluator(ctx ConfigurableEvaluatorContext) proptools.ConfigurableEvaluator
Jihoon Kang0d545b82024-10-11 00:21:57 +0000122
123 // The usage of this method is experimental and should not be used outside of fsgen package.
124 // This will be removed once product packaging migration to Soong is complete.
125 DecodeMultilib(ctx ConfigContext) (string, string)
Spandan Dase1860e42024-10-24 22:29:50 +0000126
127 // WARNING: This should not be used outside build/soong/fsgen
128 // Overrides returns the list of modules which should not be installed if this module is installed.
129 Overrides() []string
Paul Duffine2453c72019-05-31 14:00:04 +0100130}
131
132// Qualified id for a module
133type qualifiedModuleName struct {
134 // The package (i.e. directory) in which the module is defined, without trailing /
135 pkg string
136
137 // The name of the module, empty string if package.
138 name string
139}
140
141func (q qualifiedModuleName) String() string {
142 if q.name == "" {
143 return "//" + q.pkg
144 }
145 return "//" + q.pkg + ":" + q.name
146}
147
Paul Duffine484f472019-06-20 16:38:08 +0100148func (q qualifiedModuleName) isRootPackage() bool {
149 return q.pkg == "" && q.name == ""
150}
151
Paul Duffine2453c72019-05-31 14:00:04 +0100152// Get the id for the package containing this module.
153func (q qualifiedModuleName) getContainingPackageId() qualifiedModuleName {
154 pkg := q.pkg
155 if q.name == "" {
Paul Duffine484f472019-06-20 16:38:08 +0100156 if pkg == "" {
157 panic(fmt.Errorf("Cannot get containing package id of root package"))
158 }
159
160 index := strings.LastIndex(pkg, "/")
161 if index == -1 {
162 pkg = ""
163 } else {
164 pkg = pkg[:index]
165 }
Paul Duffine2453c72019-05-31 14:00:04 +0100166 }
167 return newPackageId(pkg)
168}
169
170func newPackageId(pkg string) qualifiedModuleName {
171 // A qualified id for a package module has no name.
172 return qualifiedModuleName{pkg: pkg, name: ""}
Colin Cross3f40fa42015-01-30 17:27:36 -0800173}
174
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000175type Dist struct {
176 // Copy the output of this module to the $DIST_DIR when `dist` is specified on the
177 // command line and any of these targets are also on the command line, or otherwise
178 // built
179 Targets []string `android:"arch_variant"`
180
181 // The name of the output artifact. This defaults to the basename of the output of
182 // the module.
183 Dest *string `android:"arch_variant"`
184
185 // The directory within the dist directory to store the artifact. Defaults to the
186 // top level directory ("").
187 Dir *string `android:"arch_variant"`
188
189 // A suffix to add to the artifact file name (before any extension).
190 Suffix *string `android:"arch_variant"`
191
Trevor Radcliffe90727f42022-03-21 19:34:02 +0000192 // If true, then the artifact file will be appended with _<product name>. For
193 // example, if the product is coral and the module is an android_app module
194 // of name foo, then the artifact would be foo_coral.apk. If false, there is
195 // no change to the artifact file name.
196 Append_artifact_with_product *bool `android:"arch_variant"`
197
Paul Duffin74f05592020-11-25 16:37:46 +0000198 // A string tag to select the OutputFiles associated with the tag.
199 //
200 // If no tag is specified then it will select the default dist paths provided
201 // by the module type. If a tag of "" is specified then it will return the
202 // default output files provided by the modules, i.e. the result of calling
203 // OutputFiles("").
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000204 Tag *string `android:"arch_variant"`
205}
206
Bob Badour4101c712022-02-09 11:54:35 -0800207// NamedPath associates a path with a name. e.g. a license text path with a package name
208type NamedPath struct {
209 Path Path
210 Name string
211}
212
213// String returns an escaped string representing the `NamedPath`.
214func (p NamedPath) String() string {
215 if len(p.Name) > 0 {
216 return p.Path.String() + ":" + url.QueryEscape(p.Name)
217 }
218 return p.Path.String()
219}
220
221// NamedPaths describes a list of paths each associated with a name.
222type NamedPaths []NamedPath
223
224// Strings returns a list of escaped strings representing each `NamedPath` in the list.
225func (l NamedPaths) Strings() []string {
226 result := make([]string, 0, len(l))
227 for _, p := range l {
228 result = append(result, p.String())
229 }
230 return result
231}
232
233// SortedUniqueNamedPaths modifies `l` in place to return the sorted unique subset.
234func SortedUniqueNamedPaths(l NamedPaths) NamedPaths {
235 if len(l) == 0 {
236 return l
237 }
238 sort.Slice(l, func(i, j int) bool {
239 return l[i].String() < l[j].String()
240 })
241 k := 0
242 for i := 1; i < len(l); i++ {
243 if l[i].String() == l[k].String() {
244 continue
245 }
246 k++
247 if k < i {
248 l[k] = l[i]
249 }
250 }
251 return l[:k+1]
252}
253
Colin Crossfc754582016-05-17 16:34:16 -0700254type nameProperties struct {
255 // The name of the module. Must be unique across all modules.
Nan Zhang0007d812017-11-07 10:57:05 -0800256 Name *string
Colin Crossfc754582016-05-17 16:34:16 -0700257}
258
Cole Faust2239ae62025-01-27 15:32:11 -0800259// Properties common to all modules inheriting from ModuleBase. These properties are automatically
260// inherited by sub-modules created with ctx.CreateModule()
Colin Cross08d6f8f2020-11-19 02:33:19 +0000261type commonProperties struct {
Dan Willemsen0effe062015-11-30 16:06:01 -0800262 // emit build rules for this module
Paul Duffin54d9bb72020-02-12 10:20:56 +0000263 //
264 // Disabling a module should only be done for those modules that cannot be built
265 // in the current environment. Modules that can build in the current environment
266 // but are not usually required (e.g. superceded by a prebuilt) should not be
267 // disabled as that will prevent them from being built by the checkbuild target
268 // and so prevent early detection of changes that have broken those modules.
Cole Fausta963b942024-04-11 17:43:00 -0700269 Enabled proptools.Configurable[bool] `android:"arch_variant,replace_instead_of_append"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800270
Paul Duffin2e61fa62019-03-28 14:10:57 +0000271 // Controls the visibility of this module to other modules. Allowable values are one or more of
272 // these formats:
273 //
274 // ["//visibility:public"]: Anyone can use this module.
275 // ["//visibility:private"]: Only rules in the module's package (not its subpackages) can use
276 // this module.
Paul Duffin51084ff2020-05-05 19:19:22 +0100277 // ["//visibility:override"]: Discards any rules inherited from defaults or a creating module.
278 // Can only be used at the beginning of a list of visibility rules.
Paul Duffin2e61fa62019-03-28 14:10:57 +0000279 // ["//some/package:__pkg__", "//other/package:__pkg__"]: Only modules in some/package and
280 // other/package (defined in some/package/*.bp and other/package/*.bp) have access to
281 // this module. Note that sub-packages do not have access to the rule; for example,
282 // //some/package/foo:bar or //other/package/testing:bla wouldn't have access. __pkg__
283 // is a special module and must be used verbatim. It represents all of the modules in the
284 // package.
285 // ["//project:__subpackages__", "//other:__subpackages__"]: Only modules in packages project
286 // or other or in one of their sub-packages have access to this module. For example,
287 // //project:rule, //project/library:lib or //other/testing/internal:munge are allowed
288 // to depend on this rule (but not //independent:evil)
289 // ["//project"]: This is shorthand for ["//project:__pkg__"]
290 // [":__subpackages__"]: This is shorthand for ["//project:__subpackages__"] where
291 // //project is the module's package. e.g. using [":__subpackages__"] in
292 // packages/apps/Settings/Android.bp is equivalent to
293 // //packages/apps/Settings:__subpackages__.
294 // ["//visibility:legacy_public"]: The default visibility, behaves as //visibility:public
295 // for now. It is an error if it is used in a module.
Paul Duffine2453c72019-05-31 14:00:04 +0100296 //
297 // If a module does not specify the `visibility` property then it uses the
298 // `default_visibility` property of the `package` module in the module's package.
299 //
300 // If the `default_visibility` property is not set for the module's package then
Paul Duffine484f472019-06-20 16:38:08 +0100301 // it will use the `default_visibility` of its closest ancestor package for which
302 // a `default_visibility` property is specified.
303 //
304 // If no `default_visibility` property can be found then the module uses the
305 // global default of `//visibility:legacy_public`.
Paul Duffine2453c72019-05-31 14:00:04 +0100306 //
Paul Duffin95d53b52019-07-24 13:45:05 +0100307 // The `visibility` property has no effect on a defaults module although it does
308 // apply to any non-defaults module that uses it. To set the visibility of a
309 // defaults module, use the `defaults_visibility` property on the defaults module;
310 // not to be confused with the `default_visibility` property on the package module.
311 //
Elliott Hughes10363162024-01-09 22:02:03 +0000312 // See https://android.googlesource.com/platform/build/soong/+/main/README.md#visibility for
Paul Duffin2e61fa62019-03-28 14:10:57 +0000313 // more details.
314 Visibility []string
315
Bob Badour37af0462021-01-07 03:34:31 +0000316 // Describes the licenses applicable to this module. Must reference license modules.
317 Licenses []string
318
Bob Badour37af0462021-01-07 03:34:31 +0000319 // Override of module name when reporting licenses
320 Effective_package_name *string `blueprint:"mutated"`
321 // Notice files
Bob Badour4101c712022-02-09 11:54:35 -0800322 Effective_license_text NamedPaths `blueprint:"mutated"`
Bob Badour37af0462021-01-07 03:34:31 +0000323 // License names
324 Effective_license_kinds []string `blueprint:"mutated"`
325 // License conditions
326 Effective_license_conditions []string `blueprint:"mutated"`
327
Colin Cross7d5136f2015-05-11 13:39:40 -0700328 // control whether this module compiles for 32-bit, 64-bit, or both. Possible values
Colin Cross3f40fa42015-01-30 17:27:36 -0800329 // are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
330 // 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 +0000331 // platform).
Colin Cross7d716ba2017-11-01 10:38:29 -0700332 Compile_multilib *string `android:"arch_variant"`
Colin Cross69617d32016-09-06 10:39:07 -0700333
334 Target struct {
335 Host struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700336 Compile_multilib *string
Colin Cross69617d32016-09-06 10:39:07 -0700337 }
338 Android struct {
Colin Cross7d716ba2017-11-01 10:38:29 -0700339 Compile_multilib *string
Spandan Dasde588a32024-12-03 22:52:24 +0000340 Enabled *bool
Colin Cross69617d32016-09-06 10:39:07 -0700341 }
342 }
343
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000344 // If set to true then the archMutator will create variants for each arch specific target
345 // (e.g. 32/64) that the module is required to produce. If set to false then it will only
346 // create a variant for the architecture and will list the additional arch specific targets
347 // that the variant needs to produce in the CompileMultiTargets property.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700348 UseTargetVariants bool `blueprint:"mutated"`
349 Default_multilib string `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800350
Dan Willemsen782a2d12015-12-21 14:55:28 -0800351 // whether this is a proprietary vendor module, and should be installed into /vendor
Colin Cross7d716ba2017-11-01 10:38:29 -0700352 Proprietary *bool
Dan Willemsen782a2d12015-12-21 14:55:28 -0800353
Colin Cross55708f32017-03-20 13:23:34 -0700354 // vendor who owns this module
Dan Willemsenefac4a82017-07-18 19:42:09 -0700355 Owner *string
Colin Cross55708f32017-03-20 13:23:34 -0700356
Jiyong Park2db76922017-11-08 16:03:48 +0900357 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
358 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
359 // Use `soc_specific` instead for better meaning.
Colin Cross7d716ba2017-11-01 10:38:29 -0700360 Vendor *bool
Dan Willemsenaa118f92017-04-06 12:49:58 -0700361
Jiyong Park2db76922017-11-08 16:03:48 +0900362 // whether this module is specific to an SoC (System-On-a-Chip). When set to true,
363 // it is installed into /vendor (or /system/vendor if vendor partition does not exist).
364 Soc_specific *bool
365
366 // whether this module is specific to a device, not only for SoC, but also for off-chip
367 // peripherals. When set to true, it is installed into /odm (or /vendor/odm if odm partition
368 // does not exist, or /system/vendor/odm if both odm and vendor partitions do not exist).
369 // This implies `soc_specific:true`.
370 Device_specific *bool
371
372 // whether this module is specific to a software configuration of a product (e.g. country,
Jaekyun Seok5cfbfbb2018-01-10 19:00:15 +0900373 // network operator, etc). When set to true, it is installed into /product (or
374 // /system/product if product partition does not exist).
Jiyong Park2db76922017-11-08 16:03:48 +0900375 Product_specific *bool
376
Justin Yund5f6c822019-06-25 16:47:17 +0900377 // whether this module extends system. When set to true, it is installed into /system_ext
378 // (or /system/system_ext if system_ext partition does not exist).
379 System_ext_specific *bool
380
Jiyong Parkf9332f12018-02-01 00:54:12 +0900381 // Whether this module is installed to recovery partition
382 Recovery *bool
383
Yifan Hong1b3348d2020-01-21 15:53:22 -0800384 // Whether this module is installed to ramdisk
385 Ramdisk *bool
386
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700387 // Whether this module is installed to vendor ramdisk
388 Vendor_ramdisk *bool
389
Inseob Kim08758f02021-04-08 21:13:22 +0900390 // Whether this module is installed to debug ramdisk
391 Debug_ramdisk *bool
392
Spandan Das27ff7672024-11-06 19:23:57 +0000393 // Install to partition system_dlkm when set to true.
394 System_dlkm_specific *bool
395
396 // Install to partition vendor_dlkm when set to true.
397 Vendor_dlkm_specific *bool
398
399 // Install to partition odm_dlkm when set to true.
400 Odm_dlkm_specific *bool
401
Jaewoong Jung8e93aba2021-03-02 16:58:08 -0800402 // Whether this module is built for non-native architectures (also known as native bridge binary)
dimitry1f33e402019-03-26 12:39:31 +0100403 Native_bridge_supported *bool `android:"arch_variant"`
404
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700405 // init.rc files to be installed if this module is installed
Inseob Kim713b87d2024-09-13 11:29:54 +0900406 Init_rc proptools.Configurable[[]string] `android:"arch_variant,path"`
Dan Willemsen2277bcb2016-07-25 20:27:39 -0700407
Steven Moreland57a23d22018-04-04 15:42:19 -0700408 // VINTF manifest fragments to be installed if this module is installed
Inseob Kimf2237022024-07-23 13:36:31 +0900409 Vintf_fragments proptools.Configurable[[]string] `android:"path"`
Steven Moreland57a23d22018-04-04 15:42:19 -0700410
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000411 // The OsType of artifacts that this module variant is responsible for creating.
412 //
413 // Set by osMutator
414 CompileOS OsType `blueprint:"mutated"`
415
Cole Faust0aa21cc2024-03-20 12:28:03 -0700416 // Set to true after the arch mutator has run on this module and set CompileTarget,
417 // CompileMultiTargets, and CompilePrimary
418 ArchReady bool `blueprint:"mutated"`
419
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000420 // The Target of artifacts that this module variant is responsible for creating.
421 //
422 // Set by archMutator
423 CompileTarget Target `blueprint:"mutated"`
424
425 // The additional arch specific targets (e.g. 32/64 bit) that this module variant is
426 // responsible for creating.
427 //
428 // By default this is nil as, where necessary, separate variants are created for the
429 // different multilib types supported and that information is encapsulated in the
430 // CompileTarget so the module variant simply needs to create artifacts for that.
431 //
432 // However, if UseTargetVariants is set to false (e.g. by
433 // InitAndroidMultiTargetsArchModule) then no separate variants are created for the
434 // multilib targets. Instead a single variant is created for the architecture and
435 // this contains the multilib specific targets that this variant should create.
436 //
437 // Set by archMutator
Colin Crossee0bc3b2018-10-02 22:01:37 -0700438 CompileMultiTargets []Target `blueprint:"mutated"`
Paul Duffinca7f0ef2020-02-25 15:50:49 +0000439
440 // True if the module variant's CompileTarget is the primary target
441 //
442 // Set by archMutator
443 CompilePrimary bool `blueprint:"mutated"`
Colin Cross3f40fa42015-01-30 17:27:36 -0800444
445 // Set by InitAndroidModule
446 HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
Dan Willemsen0b24c742016-10-04 15:13:37 -0700447 ArchSpecific bool `blueprint:"mutated"`
Colin Crossce75d2c2016-10-06 16:12:58 -0700448
Paul Duffin1356d8c2020-02-25 19:26:33 +0000449 // If set to true then a CommonOS variant will be created which will have dependencies
450 // on all its OsType specific variants. Used by sdk/module_exports to create a snapshot
451 // that covers all os and architecture variants.
452 //
453 // The OsType specific variants can be retrieved by calling
454 // GetOsSpecificVariantsOfCommonOSVariant
455 //
456 // Set at module initialization time by calling InitCommonOSAndroidMultiTargetsArchModule
457 CreateCommonOSVariant bool `blueprint:"mutated"`
458
Jiyong Park3f627e62024-05-01 16:14:38 +0900459 // When set to true, this module is not installed to the full install path (ex: under
460 // out/target/product/<name>/<partition>). It can be installed only to the packaging
461 // modules like android_filesystem.
462 No_full_install *bool
463
Colin Crossa9c8c9f2020-12-16 10:20:23 -0800464 // When HideFromMake is set to true, no entry for this variant will be emitted in the
465 // generated Android.mk file.
466 HideFromMake bool `blueprint:"mutated"`
467
468 // When SkipInstall is set to true, calls to ctx.InstallFile, ctx.InstallExecutable,
469 // ctx.InstallSymlink and ctx.InstallAbsoluteSymlink act like calls to ctx.PackageFile
470 // and don't create a rule to install the file.
Colin Crossce75d2c2016-10-06 16:12:58 -0700471 SkipInstall bool `blueprint:"mutated"`
Jeff Gaston088e29e2017-11-29 16:47:17 -0800472
Colin Crossbd3a16b2023-04-25 11:30:51 -0700473 // UninstallableApexPlatformVariant is set by MakeUninstallable called by the apex
474 // mutator. MakeUninstallable also sets HideFromMake. UninstallableApexPlatformVariant
475 // is used to avoid adding install or packaging dependencies into libraries provided
476 // by apexes.
477 UninstallableApexPlatformVariant bool `blueprint:"mutated"`
478
Liz Kammer5ca3a622020-08-05 15:40:41 -0700479 // Whether the module has been replaced by a prebuilt
480 ReplacedByPrebuilt bool `blueprint:"mutated"`
481
Justin Yun32f053b2020-07-31 23:07:17 +0900482 // Disabled by mutators. If set to true, it overrides Enabled property.
483 ForcedDisabled bool `blueprint:"mutated"`
484
Jeff Gaston088e29e2017-11-29 16:47:17 -0800485 NamespaceExportedToMake bool `blueprint:"mutated"`
Colin Cross6c4f21f2019-06-06 15:41:36 -0700486
Liz Kammerc13f7852023-05-17 13:01:48 -0400487 MissingDeps []string `blueprint:"mutated"`
488 CheckedMissingDeps bool `blueprint:"mutated"`
Colin Cross9a362232019-07-01 15:32:45 -0700489
490 // Name and variant strings stored by mutators to enable Module.String()
491 DebugName string `blueprint:"mutated"`
492 DebugMutators []string `blueprint:"mutated"`
493 DebugVariations []string `blueprint:"mutated"`
Colin Cross7228ecd2019-11-18 16:00:16 -0800494
Colin Crossa6845402020-11-16 15:08:19 -0800495 // ImageVariation is set by ImageMutator to specify which image this variation is for,
496 // for example "" for core or "recovery" for recovery. It will often be set to one of the
497 // constants in image.go, but can also be set to a custom value by individual module types.
Colin Cross7228ecd2019-11-18 16:00:16 -0800498 ImageVariation string `blueprint:"mutated"`
Liz Kammer2ada09a2021-08-11 00:17:36 -0400499
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800500 // The team (defined by the owner/vendor) who owns the property.
501 Team *string `android:"path"`
Kiyoung Kimfaf6af32024-08-12 11:15:19 +0900502
503 // vintf_fragment Modules required from this module.
504 Vintf_fragment_modules proptools.Configurable[[]string] `android:"path"`
Jiyong Parka574d532024-08-28 18:06:43 +0900505
506 // List of module names that are prevented from being installed when this module gets
507 // installed.
508 Overrides []string
Colin Cross3f40fa42015-01-30 17:27:36 -0800509}
510
Cole Faust2239ae62025-01-27 15:32:11 -0800511// Properties common to all modules inheriting from ModuleBase. Unlike commonProperties, these
512// properties are NOT automatically inherited by sub-modules created with ctx.CreateModule()
513type baseProperties struct {
514 // names of other modules to install if this module is installed
515 Required proptools.Configurable[[]string] `android:"arch_variant"`
516
517 // names of other modules to install on host if this module is installed
518 Host_required []string `android:"arch_variant"`
519
520 // names of other modules to install on target if this module is installed
521 Target_required []string `android:"arch_variant"`
522}
523
Paul Duffined875132020-09-02 13:08:57 +0100524type distProperties struct {
525 // configuration to distribute output files from this module to the distribution
526 // directory (default: $OUT/dist, configurable with $DIST_DIR)
527 Dist Dist `android:"arch_variant"`
528
529 // a list of configurations to distribute output files from this module to the
530 // distribution directory (default: $OUT/dist, configurable with $DIST_DIR)
531 Dists []Dist `android:"arch_variant"`
532}
533
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800534type TeamDepTagType struct {
535 blueprint.BaseDependencyTag
536}
537
538var teamDepTag = TeamDepTagType{}
539
Jiyong Park8bcf3c62024-03-18 18:37:10 +0900540// Dependency tag for required, host_required, and target_required modules.
541var RequiredDepTag = struct {
542 blueprint.BaseDependencyTag
543 InstallAlwaysNeededDependencyTag
544 // Requiring disabled module has been supported (as a side effect of this being implemented
545 // in Make). We may want to make it an error, but for now, let's keep the existing behavior.
546 AlwaysAllowDisabledModuleDependencyTag
547}{}
548
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800549// CommonTestOptions represents the common `test_options` properties in
550// Android.bp.
551type CommonTestOptions struct {
552 // If the test is a hostside (no device required) unittest that shall be run
553 // during presubmit check.
554 Unit_test *bool
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800555
556 // Tags provide additional metadata to customize test execution by downstream
557 // test runners. The tags have no special meaning to Soong.
558 Tags []string
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800559}
560
561// SetAndroidMkEntries sets AndroidMkEntries according to the value of base
562// `test_options`.
563func (t *CommonTestOptions) SetAndroidMkEntries(entries *AndroidMkEntries) {
564 entries.SetBoolIfTrue("LOCAL_IS_UNIT_TEST", Bool(t.Unit_test))
Zhenhuang Wang409d2772022-08-22 16:00:05 +0800565 if len(t.Tags) > 0 {
566 entries.AddStrings("LOCAL_TEST_OPTIONS_TAGS", t.Tags...)
567 }
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800568}
569
Yu Liue70976d2024-10-15 20:45:35 +0000570func (t *CommonTestOptions) SetAndroidMkInfoEntries(entries *AndroidMkInfo) {
571 entries.SetBoolIfTrue("LOCAL_IS_UNIT_TEST", Bool(t.Unit_test))
572 if len(t.Tags) > 0 {
573 entries.AddStrings("LOCAL_TEST_OPTIONS_TAGS", t.Tags...)
574 }
575}
576
Paul Duffin74f05592020-11-25 16:37:46 +0000577// The key to use in TaggedDistFiles when a Dist structure does not specify a
578// tag property. This intentionally does not use "" as the default because that
579// would mean that an empty tag would have a different meaning when used in a dist
580// structure that when used to reference a specific set of output paths using the
581// :module{tag} syntax, which passes tag to the OutputFiles(tag) method.
582const DefaultDistTag = "<default-dist-tag>"
583
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000584// A map of OutputFile tag keys to Paths, for disting purposes.
585type TaggedDistFiles map[string]Paths
586
Paul Duffin74f05592020-11-25 16:37:46 +0000587// addPathsForTag adds a mapping from the tag to the paths. If the map is nil
588// then it will create a map, update it and then return it. If a mapping already
589// exists for the tag then the paths are appended to the end of the current list
590// of paths, ignoring any duplicates.
591func (t TaggedDistFiles) addPathsForTag(tag string, paths ...Path) TaggedDistFiles {
592 if t == nil {
593 t = make(TaggedDistFiles)
594 }
595
596 for _, distFile := range paths {
597 if distFile != nil && !t[tag].containsPath(distFile) {
598 t[tag] = append(t[tag], distFile)
599 }
600 }
601
602 return t
603}
604
605// merge merges the entries from the other TaggedDistFiles object into this one.
606// If the TaggedDistFiles is nil then it will create a new instance, merge the
607// other into it, and then return it.
608func (t TaggedDistFiles) merge(other TaggedDistFiles) TaggedDistFiles {
609 for tag, paths := range other {
610 t = t.addPathsForTag(tag, paths...)
611 }
612
613 return t
614}
615
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000616func MakeDefaultDistFiles(paths ...Path) TaggedDistFiles {
Sasha Smundake198eaf2022-08-04 13:07:02 -0700617 for _, p := range paths {
618 if p == nil {
Jingwen Chen7b27ca72020-07-24 09:13:49 +0000619 panic("The path to a dist file cannot be nil.")
620 }
621 }
622
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000623 // The default OutputFile tag is the empty "" string.
Paul Duffin74f05592020-11-25 16:37:46 +0000624 return TaggedDistFiles{DefaultDistTag: paths}
Jingwen Chen40fd90a2020-06-15 05:24:19 +0000625}
626
Colin Cross3f40fa42015-01-30 17:27:36 -0800627type hostAndDeviceProperties struct {
Colin Cross4e81d702018-11-09 10:36:55 -0800628 // If set to true, build a variant of the module for the host. Defaults to false.
629 Host_supported *bool
630
631 // If set to true, build a variant of the module for the device. Defaults to true.
Colin Crossa4190c12016-07-12 13:11:25 -0700632 Device_supported *bool
Colin Cross3f40fa42015-01-30 17:27:36 -0800633}
634
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000635type hostCrossProperties struct {
636 // If set to true, build a variant of the module for the host cross. Defaults to true.
637 Host_cross_supported *bool
638}
639
Colin Crossc472d572015-03-17 15:06:21 -0700640type Multilib string
641
642const (
Cole Faustb9c67e22024-10-08 16:39:56 -0700643 MultilibBoth Multilib = "both"
644 MultilibFirst Multilib = "first"
645 MultilibCommon Multilib = "common"
Colin Crossc472d572015-03-17 15:06:21 -0700646)
647
Colin Crossa1ad8d12016-06-01 17:09:44 -0700648type HostOrDeviceSupported int
649
650const (
Colin Cross34037c62020-11-17 13:19:17 -0800651 hostSupported = 1 << iota
652 hostCrossSupported
653 deviceSupported
654 hostDefault
655 deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700656
657 // Host and HostCross are built by default. Device is not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800658 HostSupported = hostSupported | hostCrossSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700659
660 // Host is built by default. HostCross and Device are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800661 HostSupportedNoCross = hostSupported | hostDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700662
663 // Device is built by default. Host and HostCross are not supported.
Colin Cross34037c62020-11-17 13:19:17 -0800664 DeviceSupported = deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700665
Liz Kammer8631cc72021-08-23 21:12:07 +0000666 // By default, _only_ device variant is built. Device variant can be disabled with `device_supported: false`
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700667 // Host and HostCross are disabled by default and can be enabled with `host_supported: true`
Colin Cross34037c62020-11-17 13:19:17 -0800668 HostAndDeviceSupported = hostSupported | hostCrossSupported | deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700669
670 // Host, HostCross, and Device are built by default.
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -0700671 // Building Device can be disabled with `device_supported: false`
672 // Building Host and HostCross can be disabled with `host_supported: false`
Colin Cross34037c62020-11-17 13:19:17 -0800673 HostAndDeviceDefault = hostSupported | hostCrossSupported | hostDefault |
674 deviceSupported | deviceDefault
Dan Albert0981b5c2018-08-02 13:46:35 -0700675
676 // Nothing is supported. This is not exposed to the user, but used to mark a
677 // host only module as unsupported when the module type is not supported on
678 // the host OS. E.g. benchmarks are supported on Linux but not Darwin.
Colin Cross34037c62020-11-17 13:19:17 -0800679 NeitherHostNorDeviceSupported = 0
Colin Crossa1ad8d12016-06-01 17:09:44 -0700680)
681
Jiyong Park2db76922017-11-08 16:03:48 +0900682type moduleKind int
683
684const (
685 platformModule moduleKind = iota
686 deviceSpecificModule
687 socSpecificModule
688 productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +0900689 systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +0900690)
691
692func (k moduleKind) String() string {
693 switch k {
694 case platformModule:
695 return "platform"
696 case deviceSpecificModule:
697 return "device-specific"
698 case socSpecificModule:
699 return "soc-specific"
700 case productSpecificModule:
701 return "product-specific"
Justin Yund5f6c822019-06-25 16:47:17 +0900702 case systemExtSpecificModule:
703 return "systemext-specific"
Jiyong Park2db76922017-11-08 16:03:48 +0900704 default:
705 panic(fmt.Errorf("unknown module kind %d", k))
706 }
707}
708
Colin Cross9d34f352019-11-22 16:03:51 -0800709func initAndroidModuleBase(m Module) {
710 m.base().module = m
711}
712
Colin Crossa6845402020-11-16 15:08:19 -0800713// InitAndroidModule initializes the Module as an Android module that is not architecture-specific.
714// It adds the common properties, for example "name" and "enabled".
Colin Cross36242852017-06-23 15:06:31 -0700715func InitAndroidModule(m Module) {
Colin Cross9d34f352019-11-22 16:03:51 -0800716 initAndroidModuleBase(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800717 base := m.base()
Colin Cross5049f022015-03-18 13:28:46 -0700718
Colin Cross36242852017-06-23 15:06:31 -0700719 m.AddProperties(
Colin Crossfc754582016-05-17 16:34:16 -0700720 &base.nameProperties,
Paul Duffined875132020-09-02 13:08:57 +0100721 &base.commonProperties,
Cole Faust2239ae62025-01-27 15:32:11 -0800722 &base.baseProperties,
Paul Duffined875132020-09-02 13:08:57 +0100723 &base.distProperties)
Colin Cross18c46802019-09-24 22:19:02 -0700724
Colin Crosseabaedd2020-02-06 17:01:55 -0800725 initProductVariableModule(m)
Colin Cross18c46802019-09-24 22:19:02 -0700726
Paul Duffin63c6e182019-07-24 14:24:38 +0100727 // The default_visibility property needs to be checked and parsed by the visibility module during
Paul Duffin5ec73ec2020-05-01 17:52:01 +0100728 // its checking and parsing phases so make it the primary visibility property.
729 setPrimaryVisibilityProperty(m, "visibility", &base.commonProperties.Visibility)
Bob Badour37af0462021-01-07 03:34:31 +0000730
731 // The default_applicable_licenses property needs to be checked and parsed by the licenses module during
732 // its checking and parsing phases so make it the primary licenses property.
733 setPrimaryLicensesProperty(m, "licenses", &base.commonProperties.Licenses)
Colin Cross5049f022015-03-18 13:28:46 -0700734}
735
Colin Crossa6845402020-11-16 15:08:19 -0800736// InitAndroidArchModule initializes the Module as an Android module that is architecture-specific.
737// It adds the common properties, for example "name" and "enabled", as well as runtime generated
738// property structs for architecture-specific versions of generic properties tagged with
739// `android:"arch_variant"`.
740//
Colin Crossd079e0b2022-08-16 10:27:33 -0700741// InitAndroidModule should not be called if InitAndroidArchModule was called.
Colin Cross36242852017-06-23 15:06:31 -0700742func InitAndroidArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
743 InitAndroidModule(m)
Colin Cross5049f022015-03-18 13:28:46 -0700744
745 base := m.base()
Colin Cross3f40fa42015-01-30 17:27:36 -0800746 base.commonProperties.HostOrDeviceSupported = hod
Colin Cross69617d32016-09-06 10:39:07 -0700747 base.commonProperties.Default_multilib = string(defaultMultilib)
Dan Willemsen0b24c742016-10-04 15:13:37 -0700748 base.commonProperties.ArchSpecific = true
Colin Crossee0bc3b2018-10-02 22:01:37 -0700749 base.commonProperties.UseTargetVariants = true
Colin Cross3f40fa42015-01-30 17:27:36 -0800750
Colin Cross34037c62020-11-17 13:19:17 -0800751 if hod&hostSupported != 0 && hod&deviceSupported != 0 {
Colin Cross36242852017-06-23 15:06:31 -0700752 m.AddProperties(&base.hostAndDeviceProperties)
Colin Cross3f40fa42015-01-30 17:27:36 -0800753 }
754
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000755 if hod&hostCrossSupported != 0 {
756 m.AddProperties(&base.hostCrossProperties)
757 }
758
Colin Crossa6845402020-11-16 15:08:19 -0800759 initArchModule(m)
Colin Cross3f40fa42015-01-30 17:27:36 -0800760}
761
Colin Crossa6845402020-11-16 15:08:19 -0800762// InitAndroidMultiTargetsArchModule initializes the Module as an Android module that is
763// architecture-specific, but will only have a single variant per OS that handles all the
764// architectures simultaneously. The list of Targets that it must handle will be available from
765// ModuleContext.MultiTargets. It adds the common properties, for example "name" and "enabled", as
766// well as runtime generated property structs for architecture-specific versions of generic
767// properties tagged with `android:"arch_variant"`.
768//
769// InitAndroidModule or InitAndroidArchModule should not be called if
770// InitAndroidMultiTargetsArchModule was called.
Colin Crossee0bc3b2018-10-02 22:01:37 -0700771func InitAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
772 InitAndroidArchModule(m, hod, defaultMultilib)
773 m.base().commonProperties.UseTargetVariants = false
774}
775
Colin Crossa6845402020-11-16 15:08:19 -0800776// InitCommonOSAndroidMultiTargetsArchModule initializes the Module as an Android module that is
777// architecture-specific, but will only have a single variant per OS that handles all the
778// architectures simultaneously, and will also have an additional CommonOS variant that has
779// dependencies on all the OS-specific variants. The list of Targets that it must handle will be
780// available from ModuleContext.MultiTargets. It adds the common properties, for example "name" and
781// "enabled", as well as runtime generated property structs for architecture-specific versions of
782// generic properties tagged with `android:"arch_variant"`.
783//
784// InitAndroidModule, InitAndroidArchModule or InitAndroidMultiTargetsArchModule should not be
785// called if InitCommonOSAndroidMultiTargetsArchModule was called.
Paul Duffin1356d8c2020-02-25 19:26:33 +0000786func InitCommonOSAndroidMultiTargetsArchModule(m Module, hod HostOrDeviceSupported, defaultMultilib Multilib) {
787 InitAndroidArchModule(m, hod, defaultMultilib)
788 m.base().commonProperties.UseTargetVariants = false
789 m.base().commonProperties.CreateCommonOSVariant = true
790}
791
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800792// A ModuleBase object contains the properties that are common to all Android
Colin Cross3f40fa42015-01-30 17:27:36 -0800793// modules. It should be included as an anonymous field in every module
794// struct definition. InitAndroidModule should then be called from the module's
795// factory function, and the return values from InitAndroidModule should be
796// returned from the factory function.
797//
Nan Zhangb9eeb1d2017-02-02 10:46:07 -0800798// The ModuleBase type is responsible for implementing the GenerateBuildActions
799// method to support the blueprint.Module interface. This method will then call
800// the module's GenerateAndroidBuildActions method once for each build variant
Colin Cross25de6c32019-06-06 14:29:25 -0700801// that is to be built. GenerateAndroidBuildActions is passed a ModuleContext
802// rather than the usual blueprint.ModuleContext.
803// ModuleContext exposes extra functionality specific to the Android build
Colin Cross3f40fa42015-01-30 17:27:36 -0800804// system including details about the particular build variant that is to be
805// generated.
806//
807// For example:
808//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800809// import (
810// "android/soong/android"
811// )
Colin Cross3f40fa42015-01-30 17:27:36 -0800812//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800813// type myModule struct {
814// android.ModuleBase
815// properties struct {
816// MyProperty string
817// }
818// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800819//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800820// func NewMyModule() android.Module {
821// m := &myModule{}
822// m.AddProperties(&m.properties)
823// android.InitAndroidModule(m)
824// return m
825// }
Colin Cross3f40fa42015-01-30 17:27:36 -0800826//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800827// func (m *myModule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
828// // Get the CPU architecture for the current build variant.
829// variantArch := ctx.Arch()
Colin Cross3f40fa42015-01-30 17:27:36 -0800830//
Zhenhuang Wang0ac5a432022-08-12 18:49:20 +0800831// // ...
832// }
Colin Cross635c3b02016-05-18 15:37:25 -0700833type ModuleBase struct {
Colin Cross3f40fa42015-01-30 17:27:36 -0800834 // Putting the curiously recurring thing pointing to the thing that contains
835 // the thing pattern to good use.
Colin Cross36242852017-06-23 15:06:31 -0700836 // TODO: remove this
Colin Cross635c3b02016-05-18 15:37:25 -0700837 module Module
Colin Cross3f40fa42015-01-30 17:27:36 -0800838
Colin Crossfc754582016-05-17 16:34:16 -0700839 nameProperties nameProperties
Colin Cross3f40fa42015-01-30 17:27:36 -0800840 commonProperties commonProperties
Cole Faust2239ae62025-01-27 15:32:11 -0800841 baseProperties baseProperties
Paul Duffined875132020-09-02 13:08:57 +0100842 distProperties distProperties
Colin Cross18c46802019-09-24 22:19:02 -0700843 variableProperties interface{}
Colin Cross3f40fa42015-01-30 17:27:36 -0800844 hostAndDeviceProperties hostAndDeviceProperties
Ivan Lozanoc7eafa72024-07-16 17:55:33 +0000845 hostCrossProperties hostCrossProperties
Jingwen Chen5d864492021-02-24 07:20:12 -0500846
Usta851a3272022-01-05 23:42:33 -0500847 // Arch specific versions of structs in GetProperties() prior to
848 // initialization in InitAndroidArchModule, lets call it `generalProperties`.
849 // The outer index has the same order as generalProperties and the inner index
850 // chooses the props specific to the architecture. The interface{} value is an
851 // archPropRoot that is filled with arch specific values by the arch mutator.
Jingwen Chen5d864492021-02-24 07:20:12 -0500852 archProperties [][]interface{}
853
Paul Duffin63c6e182019-07-24 14:24:38 +0100854 // Information about all the properties on the module that contains visibility rules that need
855 // checking.
856 visibilityPropertyInfo []visibilityProperty
857
858 // The primary visibility property, may be nil, that controls access to the module.
859 primaryVisibilityProperty visibilityProperty
860
Bob Badour37af0462021-01-07 03:34:31 +0000861 // The primary licenses property, may be nil, records license metadata for the module.
862 primaryLicensesProperty applicableLicensesProperty
863
Yu Liueb6d7052024-08-27 22:35:54 +0000864 noAddressSanitizer bool
Colin Cross1f8c52b2015-06-16 16:38:17 -0700865
Colin Cross178a5092016-09-13 13:42:32 -0700866 hooks hooks
Colin Cross36242852017-06-23 15:06:31 -0700867
868 registerProps []interface{}
Colin Crosscec81712017-07-13 14:43:27 -0700869
870 // For tests
Colin Crossae887032017-10-23 17:16:14 -0700871 buildParams []BuildParams
Colin Cross4c83e5c2019-02-25 14:54:28 -0800872 ruleParams map[blueprint.Rule]blueprint.RuleParams
Jaewoong Jung38e4fb22018-12-12 09:01:34 -0800873 variables map[string]string
Colin Cross36242852017-06-23 15:06:31 -0700874}
875
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200876func (m *ModuleBase) AddJSONData(d *map[string]interface{}) {
Liz Kammer9525e712022-01-05 13:46:24 -0500877 (*d)["Android"] = map[string]interface{}{
878 // Properties set in Blueprint or in blueprint of a defaults modules
879 "SetProperties": m.propertiesWithValues(),
880 }
881}
882
883type propInfo struct {
Liz Kammer898e0762022-03-22 11:27:26 -0400884 Name string
885 Type string
886 Value string
887 Values []string
Liz Kammer9525e712022-01-05 13:46:24 -0500888}
889
890func (m *ModuleBase) propertiesWithValues() []propInfo {
891 var info []propInfo
892 props := m.GetProperties()
893
894 var propsWithValues func(name string, v reflect.Value)
895 propsWithValues = func(name string, v reflect.Value) {
896 kind := v.Kind()
897 switch kind {
898 case reflect.Ptr, reflect.Interface:
899 if v.IsNil() {
900 return
901 }
902 propsWithValues(name, v.Elem())
903 case reflect.Struct:
904 if v.IsZero() {
905 return
906 }
907 for i := 0; i < v.NumField(); i++ {
908 namePrefix := name
909 sTyp := v.Type().Field(i)
910 if proptools.ShouldSkipProperty(sTyp) {
911 continue
912 }
913 if name != "" && !strings.HasSuffix(namePrefix, ".") {
914 namePrefix += "."
915 }
916 if !proptools.IsEmbedded(sTyp) {
917 namePrefix += sTyp.Name
918 }
919 sVal := v.Field(i)
920 propsWithValues(namePrefix, sVal)
921 }
922 case reflect.Array, reflect.Slice:
923 if v.IsNil() {
924 return
925 }
926 elKind := v.Type().Elem().Kind()
Liz Kammer898e0762022-03-22 11:27:26 -0400927 info = append(info, propInfo{Name: name, Type: elKind.String() + " " + kind.String(), Values: sliceReflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500928 default:
Liz Kammer898e0762022-03-22 11:27:26 -0400929 info = append(info, propInfo{Name: name, Type: kind.String(), Value: reflectionValue(v)})
Liz Kammer9525e712022-01-05 13:46:24 -0500930 }
931 }
932
933 for _, p := range props {
934 propsWithValues("", reflect.ValueOf(p).Elem())
935 }
Liz Kammer898e0762022-03-22 11:27:26 -0400936 sort.Slice(info, func(i, j int) bool {
937 return info[i].Name < info[j].Name
938 })
Liz Kammer9525e712022-01-05 13:46:24 -0500939 return info
Lukacs T. Berkid18d8ca2021-06-25 09:11:22 +0200940}
941
Liz Kammer898e0762022-03-22 11:27:26 -0400942func reflectionValue(value reflect.Value) string {
943 switch value.Kind() {
944 case reflect.Bool:
945 return fmt.Sprintf("%t", value.Bool())
946 case reflect.Int64:
947 return fmt.Sprintf("%d", value.Int())
948 case reflect.String:
949 return fmt.Sprintf("%s", value.String())
950 case reflect.Struct:
951 if value.IsZero() {
952 return "{}"
953 }
954 length := value.NumField()
955 vals := make([]string, length, length)
956 for i := 0; i < length; i++ {
957 sTyp := value.Type().Field(i)
958 if proptools.ShouldSkipProperty(sTyp) {
959 continue
960 }
961 name := sTyp.Name
962 vals[i] = fmt.Sprintf("%s: %s", name, reflectionValue(value.Field(i)))
963 }
964 return fmt.Sprintf("%s{%s}", value.Type(), strings.Join(vals, ", "))
965 case reflect.Array, reflect.Slice:
966 vals := sliceReflectionValue(value)
967 return fmt.Sprintf("[%s]", strings.Join(vals, ", "))
968 }
969 return ""
970}
971
972func sliceReflectionValue(value reflect.Value) []string {
973 length := value.Len()
974 vals := make([]string, length, length)
975 for i := 0; i < length; i++ {
976 vals[i] = reflectionValue(value.Index(i))
977 }
978 return vals
979}
980
Paul Duffin44f1d842020-06-26 20:17:02 +0100981func (m *ModuleBase) ComponentDepsMutator(BottomUpMutatorContext) {}
982
Colin Cross4157e882019-06-06 16:57:04 -0700983func (m *ModuleBase) DepsMutator(BottomUpMutatorContext) {}
Colin Cross5f692ec2019-02-01 16:53:07 -0800984
Ronald Braunstein73b08ff2023-12-19 10:24:47 -0800985func (m *ModuleBase) baseDepsMutator(ctx BottomUpMutatorContext) {
986 if m.Team() != "" {
987 ctx.AddDependency(ctx.Module(), teamDepTag, m.Team())
988 }
Jiyong Park8bcf3c62024-03-18 18:37:10 +0900989
990 // TODO(jiyong): remove below case. This is to work around build errors happening
991 // on branches with reduced manifest like aosp_kernel-build-tools.
992 // In the branch, a build error occurs as follows.
993 // 1. aosp_kernel-build-tools is a reduced manifest branch. It doesn't have some git
994 // projects like external/bouncycastle
995 // 2. `boot_signer` is `required` by modules like `build_image` which is explicitly list as
996 // the top-level build goal (in the shell file that invokes Soong).
997 // 3. `boot_signer` depends on `bouncycastle-unbundled` which is in the missing git project.
Cole Faust88f469e2025-01-21 13:05:05 -0800998 // 4. aosp_kernel-build-tools invokes soong with `--soong-only`. Therefore, the absence of
999 // ALLOW_MISSING_DEPENDENCIES didn't cause a problem, as previously only make processed required
1000 // dependencies.
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001001 // 5. Now, since Soong understands `required` deps, it tries to build `boot_signer` and the
1002 // absence of external/bouncycastle fails the build.
1003 //
1004 // Unfortunately, there's no way for Soong to correctly determine if it's running in a
1005 // reduced manifest branch. Instead, here, we use the absence of DeviceArch or DeviceName as
1006 // a strong signal, because that's very common across reduced manifest branches.
1007 pv := ctx.Config().productVariables
1008 fullManifest := pv.DeviceArch != nil && pv.DeviceName != nil
1009 if fullManifest {
Jiyong Parkf21dd652024-04-17 05:22:37 +00001010 addRequiredDeps(ctx)
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001011 addVintfFragmentDeps(ctx)
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001012 }
1013}
1014
1015// addRequiredDeps adds required, target_required, and host_required as dependencies.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001016func addRequiredDeps(ctx BottomUpMutatorContext) {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001017 addDep := func(target Target, depName string) {
1018 if !ctx.OtherModuleExists(depName) {
1019 if ctx.Config().AllowMissingDependencies() {
1020 return
1021 }
1022 }
1023
1024 // If Android native module requires another Android native module, ensure that
1025 // they have the same bitness. This mimics the policy in select-bitness-of-required-modules
1026 // in build/make/core/main.mk.
1027 // TODO(jiyong): the Make-side does this only when the required module is a shared
1028 // library or a native test.
Jiyong Parkf21dd652024-04-17 05:22:37 +00001029 bothInAndroid := ctx.Device() && target.Os.Class == Device
Jiyong Parkc4b1d552024-05-13 16:47:30 +09001030 nativeArch := InList(ctx.Arch().ArchType.Multilib, []string{"lib32", "lib64"}) &&
1031 InList(target.Arch.ArchType.Multilib, []string{"lib32", "lib64"})
Jiyong Parkf21dd652024-04-17 05:22:37 +00001032 sameBitness := ctx.Arch().ArchType.Multilib == target.Arch.ArchType.Multilib
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001033 if bothInAndroid && nativeArch && !sameBitness {
1034 return
1035 }
1036
Jiyong Park8db44152024-05-28 12:22:04 +09001037 // ... also don't make a dependency between native bridge arch and non-native bridge
1038 // arches. b/342945184
1039 if ctx.Target().NativeBridge != target.NativeBridge {
1040 return
1041 }
1042
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001043 variation := target.Variations()
1044 if ctx.OtherModuleFarDependencyVariantExists(variation, depName) {
1045 ctx.AddFarVariationDependencies(variation, RequiredDepTag, depName)
1046 }
1047 }
1048
Jiyong Park73e5bab2024-04-05 13:37:21 +09001049 var deviceTargets []Target
1050 deviceTargets = append(deviceTargets, ctx.Config().Targets[Android]...)
1051 deviceTargets = append(deviceTargets, ctx.Config().AndroidCommonTarget)
1052
1053 var hostTargets []Target
1054 hostTargets = append(hostTargets, ctx.Config().Targets[ctx.Config().BuildOS]...)
1055 hostTargets = append(hostTargets, ctx.Config().BuildOSCommonTarget)
1056
Jiyong Parkf21dd652024-04-17 05:22:37 +00001057 if ctx.Device() {
Jihoon Kangd1a01422024-12-26 19:07:13 +00001058 for _, depName := range append(ctx.Module().RequiredModuleNames(ctx), ctx.Module().VintfFragmentModuleNames(ctx)...) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001059 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001060 addDep(target, depName)
1061 }
1062 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001063 for _, depName := range ctx.Module().HostRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001064 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001065 addDep(target, depName)
1066 }
1067 }
1068 }
1069
Jiyong Parkf21dd652024-04-17 05:22:37 +00001070 if ctx.Host() {
Jihoon Kangd1a01422024-12-26 19:07:13 +00001071 for _, depName := range append(ctx.Module().RequiredModuleNames(ctx), ctx.Module().VintfFragmentModuleNames(ctx)...) {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001072 for _, target := range hostTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001073 // When a host module requires another host module, don't make a
1074 // dependency if they have different OSes (i.e. hostcross).
Jiyong Parkf21dd652024-04-17 05:22:37 +00001075 if ctx.Target().HostCross != target.HostCross {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001076 continue
1077 }
1078 addDep(target, depName)
1079 }
1080 }
Jiyong Parkf21dd652024-04-17 05:22:37 +00001081 for _, depName := range ctx.Module().TargetRequiredModuleNames() {
Jiyong Park73e5bab2024-04-05 13:37:21 +09001082 for _, target := range deviceTargets {
Jiyong Park8bcf3c62024-03-18 18:37:10 +09001083 addDep(target, depName)
1084 }
1085 }
1086 }
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001087}
1088
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001089var vintfDepTag = struct {
1090 blueprint.BaseDependencyTag
1091 InstallAlwaysNeededDependencyTag
1092}{}
1093
Kiyoung Kim11ad4e92024-09-04 14:16:47 +09001094func IsVintfDepTag(depTag blueprint.DependencyTag) bool {
1095 return depTag == vintfDepTag
1096}
1097
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001098func addVintfFragmentDeps(ctx BottomUpMutatorContext) {
Kiyoung Kim55234812024-09-11 17:00:24 +09001099 // Vintf manifests in the recovery partition will be ignored.
1100 if !ctx.Device() || ctx.Module().InstallInRecovery() {
1101 return
1102 }
1103
1104 deviceConfig := ctx.DeviceConfig()
1105
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001106 mod := ctx.Module()
Kiyoung Kim55234812024-09-11 17:00:24 +09001107 vintfModules := ctx.AddDependency(mod, vintfDepTag, mod.VintfFragmentModuleNames(ctx)...)
1108
1109 modPartition := mod.PartitionTag(deviceConfig)
1110 for _, vintf := range vintfModules {
Cole Faust69788792024-10-10 11:00:36 -07001111 if vintf == nil {
1112 // TODO(b/372091092): Remove this. Having it gives us missing dependency errors instead
1113 // of nil pointer dereference errors, but we should resolve the missing dependencies.
1114 continue
1115 }
Kiyoung Kim11ad4e92024-09-04 14:16:47 +09001116 if vintfModule, ok := vintf.(*VintfFragmentModule); ok {
Kiyoung Kim55234812024-09-11 17:00:24 +09001117 vintfPartition := vintfModule.PartitionTag(deviceConfig)
1118 if modPartition != vintfPartition {
1119 ctx.ModuleErrorf("Module %q(%q) and Vintf_fragment %q(%q) are installed to different partitions.",
1120 mod.Name(), modPartition,
1121 vintfModule.Name(), vintfPartition)
1122 }
1123 } else {
1124 ctx.ModuleErrorf("Only vintf_fragment type module should be listed in vintf_fragment_modules : %q", vintf.Name())
1125 }
1126 }
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001127}
1128
Usta355a5872021-12-01 15:16:32 -05001129// AddProperties "registers" the provided props
1130// each value in props MUST be a pointer to a struct
Colin Cross4157e882019-06-06 16:57:04 -07001131func (m *ModuleBase) AddProperties(props ...interface{}) {
1132 m.registerProps = append(m.registerProps, props...)
Colin Cross36242852017-06-23 15:06:31 -07001133}
1134
Colin Cross4157e882019-06-06 16:57:04 -07001135func (m *ModuleBase) GetProperties() []interface{} {
1136 return m.registerProps
Colin Cross3f40fa42015-01-30 17:27:36 -08001137}
1138
Colin Cross4157e882019-06-06 16:57:04 -07001139func (m *ModuleBase) BuildParamsForTests() []BuildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001140 // Expand the references to module variables like $flags[0-9]*,
1141 // so we do not need to change many existing unit tests.
1142 // This looks like undoing the shareFlags optimization in cc's
1143 // transformSourceToObj, and should only affects unit tests.
1144 vars := m.VariablesForTests()
1145 buildParams := append([]BuildParams(nil), m.buildParams...)
Sasha Smundake198eaf2022-08-04 13:07:02 -07001146 for i := range buildParams {
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -07001147 newArgs := make(map[string]string)
1148 for k, v := range buildParams[i].Args {
1149 newArgs[k] = v
1150 // Replaces both ${flags1} and $flags1 syntax.
1151 if strings.HasPrefix(v, "${") && strings.HasSuffix(v, "}") {
1152 if value, found := vars[v[2:len(v)-1]]; found {
1153 newArgs[k] = value
1154 }
1155 } else if strings.HasPrefix(v, "$") {
1156 if value, found := vars[v[1:]]; found {
1157 newArgs[k] = value
1158 }
1159 }
1160 }
1161 buildParams[i].Args = newArgs
1162 }
1163 return buildParams
Colin Crosscec81712017-07-13 14:43:27 -07001164}
1165
Colin Cross4157e882019-06-06 16:57:04 -07001166func (m *ModuleBase) RuleParamsForTests() map[blueprint.Rule]blueprint.RuleParams {
1167 return m.ruleParams
Colin Cross4c83e5c2019-02-25 14:54:28 -08001168}
1169
Colin Cross4157e882019-06-06 16:57:04 -07001170func (m *ModuleBase) VariablesForTests() map[string]string {
1171 return m.variables
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001172}
1173
Colin Crossce75d2c2016-10-06 16:12:58 -07001174// Name returns the name of the module. It may be overridden by individual module types, for
1175// example prebuilts will prepend prebuilt_ to the name.
Colin Cross4157e882019-06-06 16:57:04 -07001176func (m *ModuleBase) Name() string {
1177 return String(m.nameProperties.Name)
Colin Crossfc754582016-05-17 16:34:16 -07001178}
1179
Colin Cross9a362232019-07-01 15:32:45 -07001180// String returns a string that includes the module name and variants for printing during debugging.
1181func (m *ModuleBase) String() string {
1182 sb := strings.Builder{}
1183 sb.WriteString(m.commonProperties.DebugName)
1184 sb.WriteString("{")
1185 for i := range m.commonProperties.DebugMutators {
1186 if i != 0 {
1187 sb.WriteString(",")
1188 }
1189 sb.WriteString(m.commonProperties.DebugMutators[i])
1190 sb.WriteString(":")
1191 sb.WriteString(m.commonProperties.DebugVariations[i])
1192 }
1193 sb.WriteString("}")
1194 return sb.String()
1195}
1196
Colin Crossce75d2c2016-10-06 16:12:58 -07001197// BaseModuleName returns the name of the module as specified in the blueprints file.
Colin Cross4157e882019-06-06 16:57:04 -07001198func (m *ModuleBase) BaseModuleName() string {
1199 return String(m.nameProperties.Name)
Colin Crossce75d2c2016-10-06 16:12:58 -07001200}
1201
Colin Cross4157e882019-06-06 16:57:04 -07001202func (m *ModuleBase) base() *ModuleBase {
1203 return m
Colin Cross3f40fa42015-01-30 17:27:36 -08001204}
1205
Paul Duffine2453c72019-05-31 14:00:04 +01001206func (m *ModuleBase) qualifiedModuleId(ctx BaseModuleContext) qualifiedModuleName {
1207 return qualifiedModuleName{pkg: ctx.ModuleDir(), name: ctx.ModuleName()}
1208}
1209
1210func (m *ModuleBase) visibilityProperties() []visibilityProperty {
Paul Duffin63c6e182019-07-24 14:24:38 +01001211 return m.visibilityPropertyInfo
1212}
1213
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001214func (m *ModuleBase) Dists() []Dist {
Paul Duffined875132020-09-02 13:08:57 +01001215 if len(m.distProperties.Dist.Targets) > 0 {
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001216 // Make a copy of the underlying Dists slice to protect against
1217 // backing array modifications with repeated calls to this method.
Paul Duffined875132020-09-02 13:08:57 +01001218 distsCopy := append([]Dist(nil), m.distProperties.Dists...)
1219 return append(distsCopy, m.distProperties.Dist)
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001220 } else {
Paul Duffined875132020-09-02 13:08:57 +01001221 return m.distProperties.Dists
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001222 }
1223}
1224
1225func (m *ModuleBase) GenerateTaggedDistFiles(ctx BaseModuleContext) TaggedDistFiles {
Paul Duffin74f05592020-11-25 16:37:46 +00001226 var distFiles TaggedDistFiles
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001227 for _, dist := range m.Dists() {
Paul Duffin74f05592020-11-25 16:37:46 +00001228 // If no tag is specified then it means to use the default dist paths so use
1229 // the special tag name which represents that.
1230 tag := proptools.StringDefault(dist.Tag, DefaultDistTag)
1231
mrziwangabdb2932024-06-18 12:43:41 -07001232 distFileForTagFromProvider, err := outputFilesForModuleFromProvider(ctx, m.module, tag)
1233 if err != OutputFilesProviderNotSet {
1234 if err != nil && tag != DefaultDistTag {
1235 ctx.PropertyErrorf("dist.tag", "%s", err.Error())
1236 } else {
1237 distFiles = distFiles.addPathsForTag(tag, distFileForTagFromProvider...)
1238 continue
1239 }
1240 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001241 }
Jingwen Chen40fd90a2020-06-15 05:24:19 +00001242 return distFiles
1243}
1244
Cole Faust02987bd2024-03-21 17:58:43 -07001245func (m *ModuleBase) ArchReady() bool {
1246 return m.commonProperties.ArchReady
1247}
1248
Colin Cross4157e882019-06-06 16:57:04 -07001249func (m *ModuleBase) Target() Target {
1250 return m.commonProperties.CompileTarget
Dan Willemsen490fd492015-11-24 17:53:15 -08001251}
1252
Colin Cross4157e882019-06-06 16:57:04 -07001253func (m *ModuleBase) TargetPrimary() bool {
1254 return m.commonProperties.CompilePrimary
Colin Cross8b74d172016-09-13 09:59:14 -07001255}
1256
Colin Cross4157e882019-06-06 16:57:04 -07001257func (m *ModuleBase) MultiTargets() []Target {
1258 return m.commonProperties.CompileMultiTargets
Colin Crossee0bc3b2018-10-02 22:01:37 -07001259}
1260
Colin Cross4157e882019-06-06 16:57:04 -07001261func (m *ModuleBase) Os() OsType {
1262 return m.Target().Os
Dan Willemsen490fd492015-11-24 17:53:15 -08001263}
1264
Colin Cross4157e882019-06-06 16:57:04 -07001265func (m *ModuleBase) Host() bool {
Jiyong Park1613e552020-09-14 19:43:17 +09001266 return m.Os().Class == Host
Dan Willemsen97750522016-02-09 17:43:51 -08001267}
1268
Yo Chiangbba545e2020-06-09 16:15:37 +08001269func (m *ModuleBase) Device() bool {
1270 return m.Os().Class == Device
1271}
1272
Colin Cross4157e882019-06-06 16:57:04 -07001273func (m *ModuleBase) Arch() Arch {
1274 return m.Target().Arch
Dan Willemsen97750522016-02-09 17:43:51 -08001275}
1276
Colin Cross4157e882019-06-06 16:57:04 -07001277func (m *ModuleBase) ArchSpecific() bool {
1278 return m.commonProperties.ArchSpecific
Dan Willemsen0b24c742016-10-04 15:13:37 -07001279}
1280
Paul Duffin1356d8c2020-02-25 19:26:33 +00001281// True if the current variant is a CommonOS variant, false otherwise.
1282func (m *ModuleBase) IsCommonOSVariant() bool {
Colin Cross8bbc3d52024-09-11 15:33:54 -07001283 return m.commonProperties.CompileOS == CommonOS
Paul Duffin1356d8c2020-02-25 19:26:33 +00001284}
1285
Colin Cross34037c62020-11-17 13:19:17 -08001286// supportsTarget returns true if the given Target is supported by the current module.
1287func (m *ModuleBase) supportsTarget(target Target) bool {
1288 switch target.Os.Class {
1289 case Host:
1290 if target.HostCross {
1291 return m.HostCrossSupported()
1292 } else {
1293 return m.HostSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001294 }
Colin Cross34037c62020-11-17 13:19:17 -08001295 case Device:
1296 return m.DeviceSupported()
Colin Crossa1ad8d12016-06-01 17:09:44 -07001297 default:
Jiyong Park1613e552020-09-14 19:43:17 +09001298 return false
Colin Crossa1ad8d12016-06-01 17:09:44 -07001299 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001300}
1301
Colin Cross34037c62020-11-17 13:19:17 -08001302// DeviceSupported returns true if the current module is supported and enabled for device targets,
1303// i.e. the factory method set the HostOrDeviceSupported value to include device support and
1304// the device support is enabled by default or enabled by the device_supported property.
Colin Cross4157e882019-06-06 16:57:04 -07001305func (m *ModuleBase) DeviceSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001306 hod := m.commonProperties.HostOrDeviceSupported
1307 // deviceEnabled is true if the device_supported property is true or the HostOrDeviceSupported
1308 // value has the deviceDefault bit set.
1309 deviceEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Device_supported, hod&deviceDefault != 0)
1310 return hod&deviceSupported != 0 && deviceEnabled
Colin Cross3f40fa42015-01-30 17:27:36 -08001311}
1312
Colin Cross34037c62020-11-17 13:19:17 -08001313// HostSupported returns true if the current module is supported and enabled for host targets,
1314// i.e. the factory method set the HostOrDeviceSupported value to include host support and
1315// the host support is enabled by default or enabled by the host_supported property.
Paul Duffine44358f2019-11-26 18:04:12 +00001316func (m *ModuleBase) HostSupported() bool {
Colin Cross34037c62020-11-17 13:19:17 -08001317 hod := m.commonProperties.HostOrDeviceSupported
1318 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1319 // value has the hostDefault bit set.
1320 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
1321 return hod&hostSupported != 0 && hostEnabled
1322}
1323
1324// HostCrossSupported returns true if the current module is supported and enabled for host cross
1325// targets, i.e. the factory method set the HostOrDeviceSupported value to include host cross
1326// support and the host cross support is enabled by default or enabled by the
1327// host_supported property.
1328func (m *ModuleBase) HostCrossSupported() bool {
1329 hod := m.commonProperties.HostOrDeviceSupported
1330 // hostEnabled is true if the host_supported property is true or the HostOrDeviceSupported
1331 // value has the hostDefault bit set.
1332 hostEnabled := proptools.BoolDefault(m.hostAndDeviceProperties.Host_supported, hod&hostDefault != 0)
Ivan Lozanoc7eafa72024-07-16 17:55:33 +00001333
1334 // Default true for the Host_cross_supported property
1335 hostCrossEnabled := proptools.BoolDefault(m.hostCrossProperties.Host_cross_supported, true)
1336
1337 return hod&hostCrossSupported != 0 && hostEnabled && hostCrossEnabled
Paul Duffine44358f2019-11-26 18:04:12 +00001338}
1339
Colin Cross4157e882019-06-06 16:57:04 -07001340func (m *ModuleBase) Platform() bool {
Justin Yund5f6c822019-06-25 16:47:17 +09001341 return !m.DeviceSpecific() && !m.SocSpecific() && !m.ProductSpecific() && !m.SystemExtSpecific()
Jiyong Parkc678ad32018-04-10 13:07:10 +09001342}
1343
Colin Cross4157e882019-06-06 16:57:04 -07001344func (m *ModuleBase) DeviceSpecific() bool {
1345 return Bool(m.commonProperties.Device_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001346}
1347
Colin Cross4157e882019-06-06 16:57:04 -07001348func (m *ModuleBase) SocSpecific() bool {
1349 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001350}
1351
Colin Cross4157e882019-06-06 16:57:04 -07001352func (m *ModuleBase) ProductSpecific() bool {
1353 return Bool(m.commonProperties.Product_specific)
Jiyong Parkc678ad32018-04-10 13:07:10 +09001354}
1355
Justin Yund5f6c822019-06-25 16:47:17 +09001356func (m *ModuleBase) SystemExtSpecific() bool {
1357 return Bool(m.commonProperties.System_ext_specific)
Dario Frenifd05a742018-05-29 13:28:54 +01001358}
1359
Colin Crossc2d24052020-05-13 11:05:02 -07001360// RequiresStableAPIs returns true if the module will be installed to a partition that may
1361// be updated separately from the system image.
1362func (m *ModuleBase) RequiresStableAPIs(ctx BaseModuleContext) bool {
1363 return m.SocSpecific() || m.DeviceSpecific() ||
1364 (m.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface())
1365}
1366
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001367func (m *ModuleBase) PartitionTag(config DeviceConfig) string {
1368 partition := "system"
1369 if m.SocSpecific() {
1370 // A SoC-specific module could be on the vendor partition at
1371 // "vendor" or the system partition at "system/vendor".
1372 if config.VendorPath() == "vendor" {
1373 partition = "vendor"
1374 }
1375 } else if m.DeviceSpecific() {
1376 // A device-specific module could be on the odm partition at
1377 // "odm", the vendor partition at "vendor/odm", or the system
1378 // partition at "system/vendor/odm".
1379 if config.OdmPath() == "odm" {
1380 partition = "odm"
Ramy Medhat944839a2020-03-31 22:14:52 -04001381 } else if strings.HasPrefix(config.OdmPath(), "vendor/") {
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001382 partition = "vendor"
1383 }
1384 } else if m.ProductSpecific() {
1385 // A product-specific module could be on the product partition
1386 // at "product" or the system partition at "system/product".
1387 if config.ProductPath() == "product" {
1388 partition = "product"
1389 }
1390 } else if m.SystemExtSpecific() {
1391 // A system_ext-specific module could be on the system_ext
1392 // partition at "system_ext" or the system partition at
1393 // "system/system_ext".
1394 if config.SystemExtPath() == "system_ext" {
1395 partition = "system_ext"
1396 }
Cole Faust76a6e952024-11-07 16:56:45 -08001397 } else if m.InstallInRamdisk() {
1398 partition = "ramdisk"
Jihoon Kang30bf8f62024-11-26 21:50:55 +00001399 } else if m.InstallInVendorRamdisk() {
1400 partition = "vendor_ramdisk"
Jihoon Kang3216c982024-12-02 19:42:20 +00001401 } else if m.InstallInRecovery() {
1402 partition = "recovery"
Bill Peckhamfff3f8a2020-03-20 18:33:20 -07001403 }
1404 return partition
1405}
1406
Cole Fauste8a87832024-09-11 11:35:46 -07001407func (m *ModuleBase) Enabled(ctx ConfigurableEvaluatorContext) bool {
Justin Yun32f053b2020-07-31 23:07:17 +09001408 if m.commonProperties.ForcedDisabled {
1409 return false
1410 }
Cole Fausta963b942024-04-11 17:43:00 -07001411 return m.commonProperties.Enabled.GetOrDefault(m.ConfigurableEvaluator(ctx), !m.Os().DefaultDisabled)
Colin Cross3f40fa42015-01-30 17:27:36 -08001412}
1413
Cole Faust8eeae4b2024-09-12 11:51:04 -07001414// Returns a copy of the enabled property, useful for passing it on to sub-modules
1415func (m *ModuleBase) EnabledProperty() proptools.Configurable[bool] {
1416 if m.commonProperties.ForcedDisabled {
1417 return proptools.NewSimpleConfigurable(false)
1418 }
1419 return m.commonProperties.Enabled.Clone()
1420}
1421
Inseob Kimeec88e12020-01-22 11:11:29 +09001422func (m *ModuleBase) Disable() {
Justin Yun32f053b2020-07-31 23:07:17 +09001423 m.commonProperties.ForcedDisabled = true
Inseob Kimeec88e12020-01-22 11:11:29 +09001424}
1425
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001426// HideFromMake marks this variant so that it is not emitted in the generated Android.mk file.
1427func (m *ModuleBase) HideFromMake() {
1428 m.commonProperties.HideFromMake = true
1429}
1430
1431// IsHideFromMake returns true if HideFromMake was previously called.
1432func (m *ModuleBase) IsHideFromMake() bool {
1433 return m.commonProperties.HideFromMake == true
1434}
1435
1436// SkipInstall marks this variant to not create install rules when ctx.Install* are called.
Colin Cross4157e882019-06-06 16:57:04 -07001437func (m *ModuleBase) SkipInstall() {
1438 m.commonProperties.SkipInstall = true
Colin Crossce75d2c2016-10-06 16:12:58 -07001439}
1440
Martin Stjernholm9e7f45e2020-12-23 03:50:30 +00001441// IsSkipInstall returns true if this variant is marked to not create install
1442// rules when ctx.Install* are called.
1443func (m *ModuleBase) IsSkipInstall() bool {
1444 return m.commonProperties.SkipInstall
1445}
1446
Iván Budnik295da162023-03-10 16:11:26 +00001447// Similar to HideFromMake, but if the AndroidMk entry would set
1448// LOCAL_UNINSTALLABLE_MODULE then this variant may still output that entry
1449// rather than leaving it out altogether. That happens in cases where it would
1450// have other side effects, in particular when it adds a NOTICE file target,
1451// which other install targets might depend on.
1452func (m *ModuleBase) MakeUninstallable() {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001453 m.commonProperties.UninstallableApexPlatformVariant = true
Iván Budnik295da162023-03-10 16:11:26 +00001454 m.HideFromMake()
Spandan Das034af2c2024-10-30 21:45:09 +00001455 m.SkipInstall()
Iván Budnik295da162023-03-10 16:11:26 +00001456}
1457
Liz Kammer5ca3a622020-08-05 15:40:41 -07001458func (m *ModuleBase) ReplacedByPrebuilt() {
1459 m.commonProperties.ReplacedByPrebuilt = true
Colin Crossa9c8c9f2020-12-16 10:20:23 -08001460 m.HideFromMake()
Liz Kammer5ca3a622020-08-05 15:40:41 -07001461}
1462
1463func (m *ModuleBase) IsReplacedByPrebuilt() bool {
1464 return m.commonProperties.ReplacedByPrebuilt
1465}
1466
Colin Cross4157e882019-06-06 16:57:04 -07001467func (m *ModuleBase) ExportedToMake() bool {
1468 return m.commonProperties.NamespaceExportedToMake
Jiyong Park374510b2018-03-19 18:23:01 +09001469}
1470
Justin Yun885a7de2021-06-29 20:34:53 +09001471func (m *ModuleBase) EffectiveLicenseFiles() Paths {
Bob Badour4101c712022-02-09 11:54:35 -08001472 result := make(Paths, 0, len(m.commonProperties.Effective_license_text))
1473 for _, p := range m.commonProperties.Effective_license_text {
1474 result = append(result, p.Path)
1475 }
1476 return result
Justin Yun885a7de2021-06-29 20:34:53 +09001477}
1478
Colin Crosse9fe2942020-11-10 18:12:15 -08001479// computeInstallDeps finds the installed paths of all dependencies that have a dependency
Colin Crossbd3a16b2023-04-25 11:30:51 -07001480// tag that is annotated as needing installation via the isInstallDepNeeded method.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001481func (m *ModuleBase) computeInstallDeps(ctx ModuleContext) ([]depset.DepSet[InstallPath], []depset.DepSet[PackagingSpec]) {
1482 var installDeps []depset.DepSet[InstallPath]
1483 var packagingSpecs []depset.DepSet[PackagingSpec]
Yu Liu5697f8f2024-12-13 23:31:08 +00001484 ctx.VisitDirectDepsProxy(func(dep ModuleProxy) {
1485 if isInstallDepNeeded(ctx, dep) {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001486 // Installation is still handled by Make, so anything hidden from Make is not
1487 // installable.
Yu Liubad1eef2024-08-21 22:37:35 +00001488 info := OtherModuleProviderOrDefault(ctx, dep, InstallFilesProvider)
Yu Liu5697f8f2024-12-13 23:31:08 +00001489 commonInfo := OtherModuleProviderOrDefault(ctx, dep, CommonModuleInfoKey)
1490 if !commonInfo.HideFromMake && !commonInfo.SkipInstall {
Yu Liubad1eef2024-08-21 22:37:35 +00001491 installDeps = append(installDeps, info.TransitiveInstallFiles)
Colin Crossbd3a16b2023-04-25 11:30:51 -07001492 }
1493 // Add packaging deps even when the dependency is not installed so that uninstallable
1494 // modules can still be packaged. Often the package will be installed instead.
Yu Liubad1eef2024-08-21 22:37:35 +00001495 packagingSpecs = append(packagingSpecs, info.TransitivePackagingSpecs)
Colin Cross897266e2020-02-13 13:22:08 -08001496 }
1497 })
Colin Cross3f40fa42015-01-30 17:27:36 -08001498
Colin Crossffe6b9d2020-12-01 15:40:06 -08001499 return installDeps, packagingSpecs
Colin Cross3f40fa42015-01-30 17:27:36 -08001500}
1501
Colin Crossbd3a16b2023-04-25 11:30:51 -07001502// isInstallDepNeeded returns true if installing the output files of the current module
1503// should also install the output files of the given dependency and dependency tag.
Yu Liu5697f8f2024-12-13 23:31:08 +00001504func isInstallDepNeeded(ctx ModuleContext, dep ModuleProxy) bool {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001505 // Don't add a dependency from the platform to a library provided by an apex.
Yu Liu5697f8f2024-12-13 23:31:08 +00001506 if OtherModuleProviderOrDefault(ctx, dep, CommonModuleInfoKey).UninstallableApexPlatformVariant {
Colin Crossbd3a16b2023-04-25 11:30:51 -07001507 return false
1508 }
1509 // Only install modules if the dependency tag is an InstallDepNeeded tag.
Yu Liu5697f8f2024-12-13 23:31:08 +00001510 return IsInstallDepNeededTag(ctx.OtherModuleDependencyTag(dep))
Colin Crossbd3a16b2023-04-25 11:30:51 -07001511}
1512
Colin Cross4157e882019-06-06 16:57:04 -07001513func (m *ModuleBase) NoAddressSanitizer() bool {
1514 return m.noAddressSanitizer
Colin Cross3f40fa42015-01-30 17:27:36 -08001515}
1516
Colin Cross4157e882019-06-06 16:57:04 -07001517func (m *ModuleBase) InstallInData() bool {
Dan Willemsen782a2d12015-12-21 14:55:28 -08001518 return false
1519}
1520
Jaewoong Jung0949f312019-09-11 10:25:18 -07001521func (m *ModuleBase) InstallInTestcases() bool {
1522 return false
1523}
1524
Colin Cross4157e882019-06-06 16:57:04 -07001525func (m *ModuleBase) InstallInSanitizerDir() bool {
Vishwath Mohan1dd88392017-03-29 22:00:18 -07001526 return false
1527}
1528
Yifan Hong1b3348d2020-01-21 15:53:22 -08001529func (m *ModuleBase) InstallInRamdisk() bool {
1530 return Bool(m.commonProperties.Ramdisk)
1531}
1532
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001533func (m *ModuleBase) InstallInVendorRamdisk() bool {
1534 return Bool(m.commonProperties.Vendor_ramdisk)
1535}
1536
Inseob Kim08758f02021-04-08 21:13:22 +09001537func (m *ModuleBase) InstallInDebugRamdisk() bool {
1538 return Bool(m.commonProperties.Debug_ramdisk)
1539}
1540
Colin Cross4157e882019-06-06 16:57:04 -07001541func (m *ModuleBase) InstallInRecovery() bool {
1542 return Bool(m.commonProperties.Recovery)
Jiyong Parkf9332f12018-02-01 00:54:12 +09001543}
1544
Colin Crossea30d852023-11-29 16:00:16 -08001545func (m *ModuleBase) InstallInOdm() bool {
1546 return false
1547}
1548
1549func (m *ModuleBase) InstallInProduct() bool {
1550 return false
1551}
1552
Kiyoung Kimae11c232021-07-19 11:38:04 +09001553func (m *ModuleBase) InstallInVendor() bool {
Kiyoung Kimf160f7f2022-11-29 10:58:08 +09001554 return Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Soc_specific) || Bool(m.commonProperties.Proprietary)
Kiyoung Kimae11c232021-07-19 11:38:04 +09001555}
1556
Spandan Das950deca2024-10-01 18:35:23 +00001557func (m *ModuleBase) InstallInSystemExt() bool {
1558 return Bool(m.commonProperties.System_ext_specific)
1559}
1560
Colin Cross90ba5f42019-10-02 11:10:58 -07001561func (m *ModuleBase) InstallInRoot() bool {
1562 return false
1563}
1564
Spandan Das27ff7672024-11-06 19:23:57 +00001565func (m *ModuleBase) InstallInSystemDlkm() bool {
1566 return Bool(m.commonProperties.System_dlkm_specific)
1567}
1568
1569func (m *ModuleBase) InstallInVendorDlkm() bool {
1570 return Bool(m.commonProperties.Vendor_dlkm_specific)
1571}
1572
1573func (m *ModuleBase) InstallInOdmDlkm() bool {
1574 return Bool(m.commonProperties.Odm_dlkm_specific)
1575}
1576
Jiyong Park87788b52020-09-01 12:37:45 +09001577func (m *ModuleBase) InstallForceOS() (*OsType, *ArchType) {
1578 return nil, nil
Colin Cross6e359402020-02-10 15:29:54 -08001579}
1580
Colin Cross4157e882019-06-06 16:57:04 -07001581func (m *ModuleBase) Owner() string {
1582 return String(m.commonProperties.Owner)
Sundong Ahn4fd04bb2018-08-31 18:01:37 +09001583}
1584
Ronald Braunstein73b08ff2023-12-19 10:24:47 -08001585func (m *ModuleBase) Team() string {
1586 return String(m.commonProperties.Team)
1587}
1588
Colin Cross7228ecd2019-11-18 16:00:16 -08001589func (m *ModuleBase) setImageVariation(variant string) {
1590 m.commonProperties.ImageVariation = variant
1591}
1592
1593func (m *ModuleBase) ImageVariation() blueprint.Variation {
1594 return blueprint.Variation{
1595 Mutator: "image",
1596 Variation: m.base().commonProperties.ImageVariation,
1597 }
1598}
1599
Paul Duffin9b76c0b2020-03-12 10:24:35 +00001600func (m *ModuleBase) getVariationByMutatorName(mutator string) string {
1601 for i, v := range m.commonProperties.DebugMutators {
1602 if v == mutator {
1603 return m.commonProperties.DebugVariations[i]
1604 }
1605 }
1606
1607 return ""
1608}
1609
Yifan Hong1b3348d2020-01-21 15:53:22 -08001610func (m *ModuleBase) InRamdisk() bool {
1611 return m.base().commonProperties.ImageVariation == RamdiskVariation
1612}
1613
Yifan Hong60e0cfb2020-10-21 15:17:56 -07001614func (m *ModuleBase) InVendorRamdisk() bool {
1615 return m.base().commonProperties.ImageVariation == VendorRamdiskVariation
1616}
1617
Inseob Kim08758f02021-04-08 21:13:22 +09001618func (m *ModuleBase) InDebugRamdisk() bool {
1619 return m.base().commonProperties.ImageVariation == DebugRamdiskVariation
1620}
1621
Colin Cross7228ecd2019-11-18 16:00:16 -08001622func (m *ModuleBase) InRecovery() bool {
1623 return m.base().commonProperties.ImageVariation == RecoveryVariation
1624}
1625
Cole Fauste8a87832024-09-11 11:35:46 -07001626func (m *ModuleBase) RequiredModuleNames(ctx ConfigurableEvaluatorContext) []string {
Cole Faust2239ae62025-01-27 15:32:11 -08001627 return m.base().baseProperties.Required.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
Jiyong Park6a8cf5f2019-12-30 16:31:09 +09001628}
1629
1630func (m *ModuleBase) HostRequiredModuleNames() []string {
Cole Faust2239ae62025-01-27 15:32:11 -08001631 return m.base().baseProperties.Host_required
Jiyong Park6a8cf5f2019-12-30 16:31:09 +09001632}
1633
1634func (m *ModuleBase) TargetRequiredModuleNames() []string {
Cole Faust2239ae62025-01-27 15:32:11 -08001635 return m.base().baseProperties.Target_required
Jiyong Park6a8cf5f2019-12-30 16:31:09 +09001636}
1637
Cole Fauste8a87832024-09-11 11:35:46 -07001638func (m *ModuleBase) VintfFragmentModuleNames(ctx ConfigurableEvaluatorContext) []string {
Kiyoung Kimfaf6af32024-08-12 11:15:19 +09001639 return m.base().commonProperties.Vintf_fragment_modules.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
1640}
1641
Kiyoung Kim23be5bb2024-11-27 00:50:30 +00001642func (m *ModuleBase) VintfFragments(ctx ConfigurableEvaluatorContext) []string {
1643 return m.base().commonProperties.Vintf_fragments.GetOrDefault(m.ConfigurableEvaluator(ctx), nil)
1644}
1645
Colin Crossa6182ab2024-08-21 10:47:44 -07001646func (m *ModuleBase) generateVariantTarget(ctx *moduleContext) {
1647 namespacePrefix := ctx.Namespace().id
1648 if namespacePrefix != "" {
1649 namespacePrefix = namespacePrefix + "-"
1650 }
1651
1652 if !ctx.uncheckedModule {
1653 name := namespacePrefix + ctx.ModuleName() + "-" + ctx.ModuleSubDir() + "-checkbuild"
1654 ctx.Phony(name, ctx.checkbuildFiles...)
1655 ctx.checkbuildTarget = PathForPhony(ctx, name)
1656 }
1657
1658}
1659
Yu Liuddc28332024-08-09 22:48:30 +00001660func (m *ModuleBase) generateModuleTarget(ctx *moduleContext) {
Colin Cross897266e2020-02-13 13:22:08 -08001661 var allInstalledFiles InstallPaths
Colin Crossa6182ab2024-08-21 10:47:44 -07001662 var allCheckbuildTargets Paths
Cole Faust71e3e7a2025-01-22 10:44:36 -08001663 var alloutputFiles Paths
Yu Liub5275322024-11-13 18:40:43 +00001664 ctx.VisitAllModuleVariantProxies(func(module ModuleProxy) {
Colin Crossa6182ab2024-08-21 10:47:44 -07001665 var checkbuildTarget Path
1666 var uncheckedModule bool
Yu Liub5275322024-11-13 18:40:43 +00001667 var skipAndroidMkProcessing bool
1668 if ctx.EqualModules(m.module, module) {
Yu Liuddc28332024-08-09 22:48:30 +00001669 allInstalledFiles = append(allInstalledFiles, ctx.installFiles...)
Colin Crossa6182ab2024-08-21 10:47:44 -07001670 checkbuildTarget = ctx.checkbuildTarget
1671 uncheckedModule = ctx.uncheckedModule
Yu Liub5275322024-11-13 18:40:43 +00001672 skipAndroidMkProcessing = shouldSkipAndroidMkProcessing(ctx, m)
Yu Liuddc28332024-08-09 22:48:30 +00001673 } else {
Yu Liud46e5ae2024-08-15 18:46:17 +00001674 info := OtherModuleProviderOrDefault(ctx, module, InstallFilesProvider)
1675 allInstalledFiles = append(allInstalledFiles, info.InstallFiles...)
Colin Crossa6182ab2024-08-21 10:47:44 -07001676 checkbuildTarget = info.CheckbuildTarget
1677 uncheckedModule = info.UncheckedModule
Yu Liub5275322024-11-13 18:40:43 +00001678 skipAndroidMkProcessing = OtherModuleProviderOrDefault(ctx, module, CommonModuleInfoKey).SkipAndroidMkProcessing
Yu Liuddc28332024-08-09 22:48:30 +00001679 }
Cole Faust71e3e7a2025-01-22 10:44:36 -08001680 if outputFiles, err := outputFilesForModule(ctx, module, ""); err == nil {
1681 alloutputFiles = append(alloutputFiles, outputFiles...)
1682 }
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07001683 // A module's -checkbuild phony targets should
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001684 // not be created if the module is not exported to make.
1685 // Those could depend on the build target and fail to compile
1686 // for the current build target.
Yu Liub5275322024-11-13 18:40:43 +00001687 if (!ctx.Config().KatiEnabled() || !skipAndroidMkProcessing) && !uncheckedModule && checkbuildTarget != nil {
Colin Crossa6182ab2024-08-21 10:47:44 -07001688 allCheckbuildTargets = append(allCheckbuildTargets, checkbuildTarget)
Chih-Hung Hsieha3d135b2021-10-14 20:32:53 -07001689 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001690 })
1691
Yu Liu460c0fa2024-08-20 19:31:15 +00001692 var namespacePrefix string
1693 nameSpace := ctx.Namespace().Path
1694 if nameSpace != "." {
1695 namespacePrefix = strings.ReplaceAll(nameSpace, "/", ".") + "-"
Jeff Gaston088e29e2017-11-29 16:47:17 -08001696 }
1697
Cole Faustc5bfbdd2025-01-08 13:05:40 -08001698 var deps Paths
Yu Liuddc2e1a2024-08-20 21:31:22 +00001699 var info FinalModuleBuildTargetsInfo
1700
Colin Cross3f40fa42015-01-30 17:27:36 -08001701 if len(allInstalledFiles) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001702 name := namespacePrefix + ctx.ModuleName() + "-install"
1703 ctx.Phony(name, allInstalledFiles.Paths()...)
Yu Liuddc2e1a2024-08-20 21:31:22 +00001704 info.InstallTarget = PathForPhony(ctx, name)
1705 deps = append(deps, info.InstallTarget)
Colin Cross9454bfa2015-03-17 13:24:18 -07001706 }
1707
Colin Crossa6182ab2024-08-21 10:47:44 -07001708 if len(allCheckbuildTargets) > 0 {
Colin Crossc3d87d32020-06-04 13:25:17 -07001709 name := namespacePrefix + ctx.ModuleName() + "-checkbuild"
Colin Crossa6182ab2024-08-21 10:47:44 -07001710 ctx.Phony(name, allCheckbuildTargets...)
1711 deps = append(deps, PathForPhony(ctx, name))
Colin Cross9454bfa2015-03-17 13:24:18 -07001712 }
1713
Cole Faust71e3e7a2025-01-22 10:44:36 -08001714 if len(alloutputFiles) > 0 {
1715 name := namespacePrefix + ctx.ModuleName() + "-outputs"
1716 ctx.Phony(name, alloutputFiles...)
1717 deps = append(deps, PathForPhony(ctx, name))
1718 }
1719
Colin Cross9454bfa2015-03-17 13:24:18 -07001720 if len(deps) > 0 {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001721 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05001722 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08001723 suffix = "-soong"
1724 }
1725
Colin Crossc3d87d32020-06-04 13:25:17 -07001726 ctx.Phony(namespacePrefix+ctx.ModuleName()+suffix, deps...)
Spandan Das25301f12025-01-24 22:22:37 +00001727 if ctx.Device() {
1728 // Generate a target suffix for use in atest etc.
1729 ctx.Phony(namespacePrefix+ctx.ModuleName()+"-target"+suffix, deps...)
Spandan Das25301f12025-01-24 22:22:37 +00001730 } else {
1731 // Generate a host suffix for use in atest etc.
1732 ctx.Phony(namespacePrefix+ctx.ModuleName()+"-host"+suffix, deps...)
Spandan Das481ec672025-01-27 19:55:52 +00001733 if ctx.Target().HostCross {
1734 // Generate a host-cross suffix for use in atest etc.
1735 ctx.Phony(namespacePrefix+ctx.ModuleName()+"-host-cross"+suffix, deps...)
1736 }
Spandan Das25301f12025-01-24 22:22:37 +00001737 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07001738
Yu Liuddc2e1a2024-08-20 21:31:22 +00001739 info.BlueprintDir = ctx.ModuleDir()
1740 SetProvider(ctx, FinalModuleBuildTargetsProvider, info)
Colin Cross3f40fa42015-01-30 17:27:36 -08001741 }
1742}
1743
Cole Faust5b7635d2024-10-28 13:01:12 -07001744func determineModuleKind(m *ModuleBase, ctx ModuleErrorContext) moduleKind {
Colin Cross4157e882019-06-06 16:57:04 -07001745 var socSpecific = Bool(m.commonProperties.Vendor) || Bool(m.commonProperties.Proprietary) || Bool(m.commonProperties.Soc_specific)
1746 var deviceSpecific = Bool(m.commonProperties.Device_specific)
1747 var productSpecific = Bool(m.commonProperties.Product_specific)
Justin Yund5f6c822019-06-25 16:47:17 +09001748 var systemExtSpecific = Bool(m.commonProperties.System_ext_specific)
Jiyong Park2db76922017-11-08 16:03:48 +09001749
Dario Frenifd05a742018-05-29 13:28:54 +01001750 msg := "conflicting value set here"
1751 if socSpecific && deviceSpecific {
1752 ctx.PropertyErrorf("device_specific", "a module cannot be specific to SoC and device at the same time.")
Colin Cross4157e882019-06-06 16:57:04 -07001753 if Bool(m.commonProperties.Vendor) {
Jiyong Park2db76922017-11-08 16:03:48 +09001754 ctx.PropertyErrorf("vendor", msg)
1755 }
Colin Cross4157e882019-06-06 16:57:04 -07001756 if Bool(m.commonProperties.Proprietary) {
Jiyong Park2db76922017-11-08 16:03:48 +09001757 ctx.PropertyErrorf("proprietary", msg)
1758 }
Colin Cross4157e882019-06-06 16:57:04 -07001759 if Bool(m.commonProperties.Soc_specific) {
Jiyong Park2db76922017-11-08 16:03:48 +09001760 ctx.PropertyErrorf("soc_specific", msg)
1761 }
1762 }
1763
Justin Yund5f6c822019-06-25 16:47:17 +09001764 if productSpecific && systemExtSpecific {
1765 ctx.PropertyErrorf("product_specific", "a module cannot be specific to product and system_ext at the same time.")
1766 ctx.PropertyErrorf("system_ext_specific", msg)
Dario Frenifd05a742018-05-29 13:28:54 +01001767 }
1768
Justin Yund5f6c822019-06-25 16:47:17 +09001769 if (socSpecific || deviceSpecific) && (productSpecific || systemExtSpecific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001770 if productSpecific {
1771 ctx.PropertyErrorf("product_specific", "a module cannot be specific to SoC or device and product at the same time.")
1772 } else {
Justin Yund5f6c822019-06-25 16:47:17 +09001773 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 +01001774 }
1775 if deviceSpecific {
1776 ctx.PropertyErrorf("device_specific", msg)
1777 } else {
Colin Cross4157e882019-06-06 16:57:04 -07001778 if Bool(m.commonProperties.Vendor) {
Dario Frenifd05a742018-05-29 13:28:54 +01001779 ctx.PropertyErrorf("vendor", msg)
1780 }
Colin Cross4157e882019-06-06 16:57:04 -07001781 if Bool(m.commonProperties.Proprietary) {
Dario Frenifd05a742018-05-29 13:28:54 +01001782 ctx.PropertyErrorf("proprietary", msg)
1783 }
Colin Cross4157e882019-06-06 16:57:04 -07001784 if Bool(m.commonProperties.Soc_specific) {
Dario Frenifd05a742018-05-29 13:28:54 +01001785 ctx.PropertyErrorf("soc_specific", msg)
1786 }
1787 }
1788 }
1789
Jiyong Park2db76922017-11-08 16:03:48 +09001790 if productSpecific {
1791 return productSpecificModule
Justin Yund5f6c822019-06-25 16:47:17 +09001792 } else if systemExtSpecific {
1793 return systemExtSpecificModule
Jiyong Park2db76922017-11-08 16:03:48 +09001794 } else if deviceSpecific {
1795 return deviceSpecificModule
1796 } else if socSpecific {
1797 return socSpecificModule
1798 } else {
1799 return platformModule
1800 }
1801}
1802
Colin Crossc34d2322020-01-03 15:23:27 -08001803func (m *ModuleBase) earlyModuleContextFactory(ctx blueprint.EarlyModuleContext) earlyModuleContext {
Colin Cross1184b642019-12-30 18:43:07 -08001804 return earlyModuleContext{
Colin Crossc34d2322020-01-03 15:23:27 -08001805 EarlyModuleContext: ctx,
1806 kind: determineModuleKind(m, ctx),
1807 config: ctx.Config().(Config),
Colin Cross3f40fa42015-01-30 17:27:36 -08001808 }
Colin Cross3f40fa42015-01-30 17:27:36 -08001809}
1810
Colin Cross1184b642019-12-30 18:43:07 -08001811func (m *ModuleBase) baseModuleContextFactory(ctx blueprint.BaseModuleContext) baseModuleContext {
1812 return baseModuleContext{
1813 bp: ctx,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001814 archModuleContext: m.archModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001815 earlyModuleContext: m.earlyModuleContextFactory(ctx),
Colin Cross1184b642019-12-30 18:43:07 -08001816 }
1817}
1818
Colin Crosse1a85552024-06-14 12:17:37 -07001819type archModuleContextFactoryContext interface {
1820 Config() interface{}
1821}
1822
1823func (m *ModuleBase) archModuleContextFactory(ctx archModuleContextFactoryContext) archModuleContext {
Colin Cross1d3d9f12024-01-18 14:30:22 -08001824 config := ctx.Config().(Config)
1825 target := m.Target()
1826 primaryArch := false
1827 if len(config.Targets[target.Os]) <= 1 {
1828 primaryArch = true
1829 } else {
1830 primaryArch = target.Arch.ArchType == config.Targets[target.Os][0].Arch.ArchType
1831 }
1832
1833 return archModuleContext{
Cole Faust0aa21cc2024-03-20 12:28:03 -07001834 ready: m.commonProperties.ArchReady,
Colin Cross1d3d9f12024-01-18 14:30:22 -08001835 os: m.commonProperties.CompileOS,
1836 target: m.commonProperties.CompileTarget,
1837 targetPrimary: m.commonProperties.CompilePrimary,
1838 multiTargets: m.commonProperties.CompileMultiTargets,
1839 primaryArch: primaryArch,
1840 }
1841
1842}
1843
Yu Liuddc28332024-08-09 22:48:30 +00001844type InstallFilesInfo struct {
Colin Crossa6182ab2024-08-21 10:47:44 -07001845 InstallFiles InstallPaths
1846 CheckbuildFiles Paths
1847 CheckbuildTarget Path
1848 UncheckedModule bool
1849 PackagingSpecs []PackagingSpec
Yu Liud46e5ae2024-08-15 18:46:17 +00001850 // katiInstalls tracks the install rules that were created by Soong but are being exported
1851 // to Make to convert to ninja rules so that Make can add additional dependencies.
Yu Liuec810542024-08-26 18:09:15 +00001852 KatiInstalls katiInstalls
1853 KatiSymlinks katiInstalls
1854 TestData []DataPath
Colin Crossa14fb6a2024-10-23 16:57:06 -07001855 TransitivePackagingSpecs depset.DepSet[PackagingSpec]
Yu Liuec810542024-08-26 18:09:15 +00001856 LicenseMetadataFile WritablePath
1857
1858 // The following fields are private before, make it private again once we have
1859 // better solution.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001860 TransitiveInstallFiles depset.DepSet[InstallPath]
Yu Liu82a6d142024-08-27 19:02:29 +00001861 // katiInitRcInstalls and katiVintfInstalls track the install rules created by Soong that are
1862 // allowed to have duplicates across modules and variants.
1863 KatiInitRcInstalls katiInstalls
1864 KatiVintfInstalls katiInstalls
1865 InitRcPaths Paths
1866 VintfFragmentsPaths Paths
1867 InstalledInitRcPaths InstallPaths
1868 InstalledVintfFragmentsPaths InstallPaths
1869
Yu Liuec810542024-08-26 18:09:15 +00001870 // The files to copy to the dist as explicitly specified in the .bp file.
1871 DistFiles TaggedDistFiles
Yu Liuddc28332024-08-09 22:48:30 +00001872}
1873
Yu Liubad1eef2024-08-21 22:37:35 +00001874var InstallFilesProvider = blueprint.NewProvider[InstallFilesInfo]()
Yu Liuddc2e1a2024-08-20 21:31:22 +00001875
Yu Liud3228ac2024-11-08 23:11:47 +00001876type SourceFilesInfo struct {
1877 Srcs Paths
1878}
1879
Yu Liuc41eae52025-01-14 01:03:08 +00001880var SourceFilesInfoProvider = blueprint.NewProvider[SourceFilesInfo]()
Yu Liud3228ac2024-11-08 23:11:47 +00001881
Cole Faustc5bfbdd2025-01-08 13:05:40 -08001882// FinalModuleBuildTargetsInfo is used by buildTargetSingleton to create checkbuild and
1883// per-directory build targets. Only set on the final variant of each module
Yu Liuddc2e1a2024-08-20 21:31:22 +00001884type FinalModuleBuildTargetsInfo struct {
Yu Liuddc2e1a2024-08-20 21:31:22 +00001885 InstallTarget WritablePath
1886 CheckbuildTarget WritablePath
1887 BlueprintDir string
1888}
1889
Yu Liubad1eef2024-08-21 22:37:35 +00001890var FinalModuleBuildTargetsProvider = blueprint.NewProvider[FinalModuleBuildTargetsInfo]()
Yu Liuddc28332024-08-09 22:48:30 +00001891
Yu Liub5275322024-11-13 18:40:43 +00001892type CommonModuleInfo struct {
Yu Liudd9ccb42024-10-07 17:07:44 +00001893 Enabled bool
1894 // Whether the module has been replaced by a prebuilt
1895 ReplacedByPrebuilt bool
Yu Liuec7043d2024-11-05 18:22:20 +00001896 // The Target of artifacts that this module variant is responsible for creating.
Yu Liu8024b922024-12-20 23:31:32 +00001897 Target Target
Yu Liub5275322024-11-13 18:40:43 +00001898 SkipAndroidMkProcessing bool
Yu Liu63bdf632024-12-03 19:54:05 +00001899 BaseModuleName string
Yu Liub1bfa9d2024-12-05 18:57:51 +00001900 CanHaveApexVariants bool
Yu Liu5d3a2cf2025-02-06 00:25:22 +00001901 MinSdkVersion ApiLevelOrPlatform
Yu Liuf6f85492025-01-13 21:02:36 +00001902 SdkVersion string
Yu Liu8f2c5c02024-12-06 00:40:39 +00001903 NotAvailableForPlatform bool
Yu Liu8024b922024-12-20 23:31:32 +00001904 // There some subtle differences between this one and the one above.
1905 NotInPlatform bool
Yu Liu5697f8f2024-12-13 23:31:08 +00001906 // UninstallableApexPlatformVariant is set by MakeUninstallable called by the apex
1907 // mutator. MakeUninstallable also sets HideFromMake. UninstallableApexPlatformVariant
1908 // is used to avoid adding install or packaging dependencies into libraries provided
1909 // by apexes.
1910 UninstallableApexPlatformVariant bool
1911 HideFromMake bool
1912 SkipInstall bool
Yu Liu97880e12025-01-07 19:03:34 +00001913 IsStubsModule bool
Yu Liu68a70b72025-01-08 22:54:44 +00001914 Host bool
Yu Liudf0b8392025-02-12 18:27:03 +00001915 MinSdkVersionSupported ApiLevel
1916 ModuleWithMinSdkVersionCheck bool
Yu Liudd9ccb42024-10-07 17:07:44 +00001917}
1918
Yu Liu5d3a2cf2025-02-06 00:25:22 +00001919type ApiLevelOrPlatform struct {
1920 ApiLevel *ApiLevel
1921 IsPlatform bool
1922}
1923
Yu Liub5275322024-11-13 18:40:43 +00001924var CommonModuleInfoKey = blueprint.NewProvider[CommonModuleInfo]()
Yu Liudd9ccb42024-10-07 17:07:44 +00001925
Yu Liu8a8d5b42025-01-07 00:48:08 +00001926type PrebuiltModuleInfo struct {
1927 SourceExists bool
Yu Liu2da9d9a2025-01-15 00:27:02 +00001928 UsePrebuilt bool
Yu Liudd9ccb42024-10-07 17:07:44 +00001929}
1930
Yu Liu8a8d5b42025-01-07 00:48:08 +00001931var PrebuiltModuleInfoProvider = blueprint.NewProvider[PrebuiltModuleInfo]()
Yu Liudd9ccb42024-10-07 17:07:44 +00001932
Yu Liu2da9d9a2025-01-15 00:27:02 +00001933type HostToolProviderInfo struct {
Yu Liudd9ccb42024-10-07 17:07:44 +00001934 HostToolPath OptionalPath
1935}
1936
Yu Liu2da9d9a2025-01-15 00:27:02 +00001937var HostToolProviderInfoProvider = blueprint.NewProvider[HostToolProviderInfo]()
Yu Liudd9ccb42024-10-07 17:07:44 +00001938
Cole Faustd62a4892025-02-07 16:55:11 -08001939type DistInfo struct {
1940 Dists []dist
1941}
1942
1943var DistProvider = blueprint.NewProvider[DistInfo]()
1944
Yu Liu8024b922024-12-20 23:31:32 +00001945type SourceFileGenerator interface {
1946 GeneratedSourceFiles() Paths
1947 GeneratedHeaderDirs() Paths
1948 GeneratedDeps() Paths
1949}
1950
1951type GeneratedSourceInfo struct {
1952 GeneratedSourceFiles Paths
1953 GeneratedHeaderDirs Paths
1954 GeneratedDeps Paths
1955}
1956
1957var GeneratedSourceInfoProvider = blueprint.NewProvider[GeneratedSourceInfo]()
1958
Colin Cross4157e882019-06-06 16:57:04 -07001959func (m *ModuleBase) GenerateBuildActions(blueprintCtx blueprint.ModuleContext) {
Colin Cross25de6c32019-06-06 14:29:25 -07001960 ctx := &moduleContext{
Colin Cross0ea8ba82019-06-06 14:33:29 -07001961 module: m.module,
Colin Crossdc35e212019-06-06 16:13:11 -07001962 bp: blueprintCtx,
Colin Cross0ea8ba82019-06-06 14:33:29 -07001963 baseModuleContext: m.baseModuleContextFactory(blueprintCtx),
Colin Cross0ea8ba82019-06-06 14:33:29 -07001964 variables: make(map[string]string),
Yu Liu54513622024-08-19 20:00:32 +00001965 phonies: make(map[string]Paths),
Colin Cross3f40fa42015-01-30 17:27:36 -08001966 }
1967
Jihoon Kangc3d4e112024-06-24 22:16:27 +00001968 setContainerInfo(ctx)
Jihoon Kang85bc1932024-07-01 17:04:46 +00001969 if ctx.Config().Getenv("DISABLE_CONTAINER_CHECK") != "true" {
1970 checkContainerViolations(ctx)
1971 }
Jihoon Kangc3d4e112024-06-24 22:16:27 +00001972
Yu Liuec810542024-08-26 18:09:15 +00001973 ctx.licenseMetadataFile = PathForModuleOut(ctx, "meta_lic")
Colin Crossaa1cab02022-01-28 14:49:24 -08001974
Colin Crossffe6b9d2020-12-01 15:40:06 -08001975 dependencyInstallFiles, dependencyPackagingSpecs := m.computeInstallDeps(ctx)
Yu Liubad1eef2024-08-21 22:37:35 +00001976 // set the TransitiveInstallFiles to only the transitive dependencies to be used as the dependencies
Colin Cross5d583952020-11-24 16:21:24 -08001977 // of installed files of this module. It will be replaced by a depset including the installed
1978 // files of this module at the end for use by modules that depend on this one.
Colin Crossa14fb6a2024-10-23 16:57:06 -07001979 ctx.TransitiveInstallFiles = depset.New[InstallPath](depset.TOPOLOGICAL, nil, dependencyInstallFiles)
Colin Cross5d583952020-11-24 16:21:24 -08001980
Colin Cross6c4f21f2019-06-06 15:41:36 -07001981 // Temporarily continue to call blueprintCtx.GetMissingDependencies() to maintain the previous behavior of never
1982 // reporting missing dependency errors in Blueprint when AllowMissingDependencies == true.
1983 // TODO: This will be removed once defaults modules handle missing dependency errors
1984 blueprintCtx.GetMissingDependencies()
1985
Colin Crossdc35e212019-06-06 16:13:11 -07001986 // For the final GenerateAndroidBuildActions pass, require that all visited dependencies Soong modules and
Paul Duffin1356d8c2020-02-25 19:26:33 +00001987 // are enabled. Unless the module is a CommonOS variant which may have dependencies on disabled variants
1988 // (because the dependencies are added before the modules are disabled). The
1989 // GetOsSpecificVariantsOfCommonOSVariant(...) method will ensure that the disabled variants are
1990 // ignored.
1991 ctx.baseModuleContext.strictVisitDeps = !m.IsCommonOSVariant()
Colin Crossdc35e212019-06-06 16:13:11 -07001992
Colin Cross4c83e5c2019-02-25 14:54:28 -08001993 if ctx.config.captureBuild {
1994 ctx.ruleParams = make(map[blueprint.Rule]blueprint.RuleParams)
1995 }
1996
Colin Cross67a5c132017-05-09 13:45:28 -07001997 desc := "//" + ctx.ModuleDir() + ":" + ctx.ModuleName() + " "
1998 var suffix []string
Colin Cross0875c522017-11-28 17:34:01 -08001999 if ctx.Os().Class != Device && ctx.Os().Class != Generic {
2000 suffix = append(suffix, ctx.Os().String())
Colin Cross67a5c132017-05-09 13:45:28 -07002001 }
Colin Cross0875c522017-11-28 17:34:01 -08002002 if !ctx.PrimaryArch() {
2003 suffix = append(suffix, ctx.Arch().ArchType.String())
Colin Cross67a5c132017-05-09 13:45:28 -07002004 }
Colin Crossff694a82023-12-13 15:54:49 -08002005 if apexInfo, _ := ModuleProvider(ctx, ApexInfoProvider); !apexInfo.IsForPlatform() {
Colin Cross56a83212020-09-15 18:30:11 -07002006 suffix = append(suffix, apexInfo.ApexVariationName)
Dan Willemsenb13a9482020-02-14 11:25:54 -08002007 }
Colin Cross67a5c132017-05-09 13:45:28 -07002008
2009 ctx.Variable(pctx, "moduleDesc", desc)
2010
2011 s := ""
2012 if len(suffix) > 0 {
2013 s = " [" + strings.Join(suffix, " ") + "]"
2014 }
2015 ctx.Variable(pctx, "moduleDescSuffix", s)
2016
Dan Willemsen569edc52018-11-19 09:33:29 -08002017 // Some common property checks for properties that will be used later in androidmk.go
Paul Duffin89968e32020-11-23 18:17:03 +00002018 checkDistProperties(ctx, "dist", &m.distProperties.Dist)
Sasha Smundake198eaf2022-08-04 13:07:02 -07002019 for i := range m.distProperties.Dists {
Paul Duffin89968e32020-11-23 18:17:03 +00002020 checkDistProperties(ctx, fmt.Sprintf("dists[%d]", i), &m.distProperties.Dists[i])
Dan Willemsen569edc52018-11-19 09:33:29 -08002021 }
2022
Yu Liubad1eef2024-08-21 22:37:35 +00002023 var installFiles InstallFilesInfo
2024
Cole Fausta963b942024-04-11 17:43:00 -07002025 if m.Enabled(ctx) {
Jooyung Hand48f3c32019-08-23 11:18:57 +09002026 // ensure all direct android.Module deps are enabled
Yu Liu4552aeb2024-11-13 00:59:49 +00002027 ctx.VisitDirectDepsProxy(func(m ModuleProxy) {})
Jooyung Hand48f3c32019-08-23 11:18:57 +09002028
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002029 if m.Device() {
2030 // Handle any init.rc and vintf fragment files requested by the module. All files installed by this
2031 // module will automatically have a dependency on the installed init.rc or vintf fragment file.
2032 // The same init.rc or vintf fragment file may be requested by multiple modules or variants,
2033 // so instead of installing them now just compute the install path and store it for later.
2034 // The full list of all init.rc and vintf fragment install rules will be deduplicated later
2035 // so only a single rule is created for each init.rc or vintf fragment file.
2036
2037 if !m.InVendorRamdisk() {
Inseob Kim713b87d2024-09-13 11:29:54 +09002038 ctx.initRcPaths = PathsForModuleSrc(ctx, m.commonProperties.Init_rc.GetOrDefault(ctx, nil))
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002039 rcDir := PathForModuleInstall(ctx, "etc", "init")
Yu Liu82a6d142024-08-27 19:02:29 +00002040 for _, src := range ctx.initRcPaths {
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002041 installedInitRc := rcDir.Join(ctx, src.Base())
Yu Liu82a6d142024-08-27 19:02:29 +00002042 ctx.katiInitRcInstalls = append(ctx.katiInitRcInstalls, katiInstall{
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002043 from: src,
2044 to: installedInitRc,
2045 })
2046 ctx.PackageFile(rcDir, src.Base(), src)
Yu Liu82a6d142024-08-27 19:02:29 +00002047 ctx.installedInitRcPaths = append(ctx.installedInitRcPaths, installedInitRc)
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002048 }
Yu Liu82a6d142024-08-27 19:02:29 +00002049 installFiles.InitRcPaths = ctx.initRcPaths
2050 installFiles.KatiInitRcInstalls = ctx.katiInitRcInstalls
2051 installFiles.InstalledInitRcPaths = ctx.installedInitRcPaths
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002052 }
2053
Yu Liu82a6d142024-08-27 19:02:29 +00002054 ctx.vintfFragmentsPaths = PathsForModuleSrc(ctx, m.commonProperties.Vintf_fragments.GetOrDefault(ctx, nil))
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002055 vintfDir := PathForModuleInstall(ctx, "etc", "vintf", "manifest")
Yu Liu82a6d142024-08-27 19:02:29 +00002056 for _, src := range ctx.vintfFragmentsPaths {
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002057 installedVintfFragment := vintfDir.Join(ctx, src.Base())
Yu Liu82a6d142024-08-27 19:02:29 +00002058 ctx.katiVintfInstalls = append(ctx.katiVintfInstalls, katiInstall{
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002059 from: src,
2060 to: installedVintfFragment,
2061 })
2062 ctx.PackageFile(vintfDir, src.Base(), src)
Yu Liu82a6d142024-08-27 19:02:29 +00002063 ctx.installedVintfFragmentsPaths = append(ctx.installedVintfFragmentsPaths, installedVintfFragment)
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002064 }
Yu Liu82a6d142024-08-27 19:02:29 +00002065 installFiles.VintfFragmentsPaths = ctx.vintfFragmentsPaths
2066 installFiles.KatiVintfInstalls = ctx.katiVintfInstalls
2067 installFiles.InstalledVintfFragmentsPaths = ctx.installedVintfFragmentsPaths
Colin Crossd9bbf4b2023-11-17 16:23:48 -08002068 }
2069
Bob Badour37af0462021-01-07 03:34:31 +00002070 licensesPropertyFlattener(ctx)
2071 if ctx.Failed() {
2072 return
2073 }
2074
Joe Onorato349ae8d2024-02-05 22:46:00 +00002075 if jarJarPrefixHandler != nil {
2076 jarJarPrefixHandler(ctx)
2077 if ctx.Failed() {
2078 return
2079 }
2080 }
2081
Justin Yun40182b62024-05-07 10:22:19 +09002082 // Call aconfigUpdateAndroidBuildActions to collect merged aconfig files before being used
2083 // in m.module.GenerateAndroidBuildActions
2084 aconfigUpdateAndroidBuildActions(ctx)
Jaewoong Jung5b425e22019-06-17 17:40:56 -07002085 if ctx.Failed() {
2086 return
2087 }
2088
Yu Liu26a716d2024-08-30 23:40:32 +00002089 m.module.GenerateAndroidBuildActions(ctx)
2090 if ctx.Failed() {
2091 return
Yu Liufa297642024-06-11 00:13:02 +00002092 }
2093
Yu Liu26a716d2024-08-30 23:40:32 +00002094 if x, ok := m.module.(IDEInfo); ok {
2095 var result IdeInfo
2096 x.IDEInfo(ctx, &result)
2097 result.BaseModuleName = x.BaseModuleName()
2098 SetProvider(ctx, IdeInfoProviderKey, result)
LaMont Jonesb5099382024-01-10 23:42:36 +00002099 }
2100
Paul Duffinaf970a22020-11-23 23:32:56 +00002101 // Create the set of tagged dist files after calling GenerateAndroidBuildActions
2102 // as GenerateTaggedDistFiles() calls OutputFiles(tag) and so relies on the
2103 // output paths being set which must be done before or during
2104 // GenerateAndroidBuildActions.
Yu Liuec810542024-08-26 18:09:15 +00002105 installFiles.DistFiles = m.GenerateTaggedDistFiles(ctx)
Paul Duffinaf970a22020-11-23 23:32:56 +00002106 if ctx.Failed() {
2107 return
2108 }
2109
Colin Crossa6182ab2024-08-21 10:47:44 -07002110 m.generateVariantTarget(ctx)
2111
Yu Liuec810542024-08-26 18:09:15 +00002112 installFiles.LicenseMetadataFile = ctx.licenseMetadataFile
Yu Liubad1eef2024-08-21 22:37:35 +00002113 installFiles.InstallFiles = ctx.installFiles
2114 installFiles.CheckbuildFiles = ctx.checkbuildFiles
Colin Crossa6182ab2024-08-21 10:47:44 -07002115 installFiles.CheckbuildTarget = ctx.checkbuildTarget
2116 installFiles.UncheckedModule = ctx.uncheckedModule
Yu Liubad1eef2024-08-21 22:37:35 +00002117 installFiles.PackagingSpecs = ctx.packagingSpecs
2118 installFiles.KatiInstalls = ctx.katiInstalls
2119 installFiles.KatiSymlinks = ctx.katiSymlinks
2120 installFiles.TestData = ctx.testData
Colin Crossdc35e212019-06-06 16:13:11 -07002121 } else if ctx.Config().AllowMissingDependencies() {
2122 // If the module is not enabled it will not create any build rules, nothing will call
2123 // ctx.GetMissingDependencies(), and blueprint will consider the missing dependencies to be unhandled
2124 // and report them as an error even when AllowMissingDependencies = true. Call
2125 // ctx.GetMissingDependencies() here to tell blueprint not to handle them.
2126 ctx.GetMissingDependencies()
Colin Cross3f40fa42015-01-30 17:27:36 -08002127 }
2128
Yu Liud3228ac2024-11-08 23:11:47 +00002129 if sourceFileProducer, ok := m.module.(SourceFileProducer); ok {
Yu Liuc41eae52025-01-14 01:03:08 +00002130 SetProvider(ctx, SourceFilesInfoProvider, SourceFilesInfo{Srcs: sourceFileProducer.Srcs()})
Yu Liud3228ac2024-11-08 23:11:47 +00002131 }
2132
Yu Liu88ea9ff2024-11-07 19:19:42 +00002133 if ctx.IsFinalModule(m.module) {
Colin Cross4157e882019-06-06 16:57:04 -07002134 m.generateModuleTarget(ctx)
Colin Cross9b1d13d2016-09-19 15:18:11 -07002135 if ctx.Failed() {
2136 return
2137 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002138 }
Colin Crosscec81712017-07-13 14:43:27 -07002139
Colin Crossa14fb6a2024-10-23 16:57:06 -07002140 ctx.TransitiveInstallFiles = depset.New[InstallPath](depset.TOPOLOGICAL, ctx.installFiles, dependencyInstallFiles)
Yu Liubad1eef2024-08-21 22:37:35 +00002141 installFiles.TransitiveInstallFiles = ctx.TransitiveInstallFiles
Colin Crossa14fb6a2024-10-23 16:57:06 -07002142 installFiles.TransitivePackagingSpecs = depset.New[PackagingSpec](depset.TOPOLOGICAL, ctx.packagingSpecs, dependencyPackagingSpecs)
Colin Cross5d583952020-11-24 16:21:24 -08002143
Yu Liubad1eef2024-08-21 22:37:35 +00002144 SetProvider(ctx, InstallFilesProvider, installFiles)
Yu Liuec810542024-08-26 18:09:15 +00002145 buildLicenseMetadata(ctx, ctx.licenseMetadataFile)
Colin Cross4acaea92021-12-10 23:05:02 +00002146
Jihoon Kangd4063812025-01-24 00:25:30 +00002147 if len(ctx.moduleInfoJSON) > 0 {
2148 for _, moduleInfoJSON := range ctx.moduleInfoJSON {
2149 if moduleInfoJSON.Disabled {
2150 continue
2151 }
2152 var installed InstallPaths
2153 installed = append(installed, ctx.katiInstalls.InstallPaths()...)
2154 installed = append(installed, ctx.katiSymlinks.InstallPaths()...)
2155 installed = append(installed, ctx.katiInitRcInstalls.InstallPaths()...)
2156 installed = append(installed, ctx.katiVintfInstalls.InstallPaths()...)
2157 installedStrings := installed.Strings()
Colin Crossd6fd0132023-11-06 13:54:06 -08002158
Jihoon Kangd4063812025-01-24 00:25:30 +00002159 var targetRequired, hostRequired []string
2160 if ctx.Host() {
2161 targetRequired = m.baseProperties.Target_required
2162 } else {
2163 hostRequired = m.baseProperties.Host_required
2164 }
Colin Crossd6fd0132023-11-06 13:54:06 -08002165
Jihoon Kangd4063812025-01-24 00:25:30 +00002166 var data []string
2167 for _, d := range ctx.testData {
2168 data = append(data, d.ToRelativeInstallPath())
2169 }
Colin Crossd6fd0132023-11-06 13:54:06 -08002170
Jihoon Kangd4063812025-01-24 00:25:30 +00002171 if moduleInfoJSON.Uninstallable {
2172 installedStrings = nil
2173 if len(moduleInfoJSON.CompatibilitySuites) == 1 && moduleInfoJSON.CompatibilitySuites[0] == "null-suite" {
2174 moduleInfoJSON.CompatibilitySuites = nil
2175 moduleInfoJSON.TestConfig = nil
2176 moduleInfoJSON.AutoTestConfig = nil
2177 data = nil
2178 }
2179 }
2180
2181 // M(C)TS supports a full test suite and partial per-module MTS test suites, with naming mts-${MODULE}.
2182 // To reduce repetition, if we find a partial M(C)TS test suite without an full M(C)TS test suite,
2183 // we add the full test suite to our list. This was inherited from
2184 // AndroidMkEntries.AddCompatibilityTestSuites.
2185 suites := moduleInfoJSON.CompatibilitySuites
2186 if PrefixInList(suites, "mts-") && !InList("mts", suites) {
2187 suites = append(suites, "mts")
2188 }
2189 if PrefixInList(suites, "mcts-") && !InList("mcts", suites) {
2190 suites = append(suites, "mcts")
2191 }
2192 moduleInfoJSON.CompatibilitySuites = suites
2193
2194 required := append(m.RequiredModuleNames(ctx), m.VintfFragmentModuleNames(ctx)...)
2195 required = append(required, moduleInfoJSON.ExtraRequired...)
2196
2197 registerName := moduleInfoJSON.RegisterNameOverride
2198 if len(registerName) == 0 {
2199 registerName = m.moduleInfoRegisterName(ctx, moduleInfoJSON.SubName)
2200 }
2201
2202 moduleName := moduleInfoJSON.ModuleNameOverride
2203 if len(moduleName) == 0 {
2204 moduleName = m.BaseModuleName() + moduleInfoJSON.SubName
2205 }
2206
2207 supportedVariants := moduleInfoJSON.SupportedVariantsOverride
2208 if moduleInfoJSON.SupportedVariantsOverride == nil {
2209 supportedVariants = []string{m.moduleInfoVariant(ctx)}
2210 }
2211
2212 moduleInfoJSON.core = CoreModuleInfoJSON{
2213 RegisterName: registerName,
2214 Path: []string{ctx.ModuleDir()},
2215 Installed: installedStrings,
2216 ModuleName: moduleName,
2217 SupportedVariants: supportedVariants,
2218 TargetDependencies: targetRequired,
2219 HostDependencies: hostRequired,
2220 Data: data,
2221 Required: required,
Colin Crossd6fd0132023-11-06 13:54:06 -08002222 }
2223 }
2224
Yu Liu4297ad92024-08-27 19:50:13 +00002225 SetProvider(ctx, ModuleInfoJSONProvider, ctx.moduleInfoJSON)
Colin Crossd6fd0132023-11-06 13:54:06 -08002226 }
2227
Colin Cross4157e882019-06-06 16:57:04 -07002228 m.buildParams = ctx.buildParams
2229 m.ruleParams = ctx.ruleParams
2230 m.variables = ctx.variables
mrziwange6c85812024-05-22 14:36:09 -07002231
Yu Liu876b7ce2024-08-21 18:20:13 +00002232 outputFiles := ctx.GetOutputFiles()
2233 if outputFiles.DefaultOutputFiles != nil || outputFiles.TaggedOutputFiles != nil {
2234 SetProvider(ctx, OutputFilesProvider, outputFiles)
mrziwange6c85812024-05-22 14:36:09 -07002235 }
Wei Lia1aa2972024-06-21 13:08:51 -07002236
Yu Liu54513622024-08-19 20:00:32 +00002237 if len(ctx.phonies) > 0 {
2238 SetProvider(ctx, ModulePhonyProvider, ModulePhonyInfo{
2239 Phonies: ctx.phonies,
2240 })
2241 }
Cole Faustd62a4892025-02-07 16:55:11 -08002242
2243 if len(ctx.dists) > 0 {
2244 SetProvider(ctx, DistProvider, DistInfo{
2245 Dists: ctx.dists,
2246 })
2247 }
2248
Wei Lia1aa2972024-06-21 13:08:51 -07002249 buildComplianceMetadataProvider(ctx, m)
Yu Liudd9ccb42024-10-07 17:07:44 +00002250
Yu Liub5275322024-11-13 18:40:43 +00002251 commonData := CommonModuleInfo{
Yu Liu5697f8f2024-12-13 23:31:08 +00002252 ReplacedByPrebuilt: m.commonProperties.ReplacedByPrebuilt,
Yu Liu8024b922024-12-20 23:31:32 +00002253 Target: m.commonProperties.CompileTarget,
Yu Liu5697f8f2024-12-13 23:31:08 +00002254 SkipAndroidMkProcessing: shouldSkipAndroidMkProcessing(ctx, m),
2255 BaseModuleName: m.BaseModuleName(),
2256 UninstallableApexPlatformVariant: m.commonProperties.UninstallableApexPlatformVariant,
2257 HideFromMake: m.commonProperties.HideFromMake,
2258 SkipInstall: m.commonProperties.SkipInstall,
Yu Liu68a70b72025-01-08 22:54:44 +00002259 Host: m.Host(),
Yu Liudd9ccb42024-10-07 17:07:44 +00002260 }
Yu Liu8f2c5c02024-12-06 00:40:39 +00002261 if mm, ok := m.module.(interface {
2262 MinSdkVersion(ctx EarlyModuleContext) ApiLevel
2263 }); ok {
2264 ver := mm.MinSdkVersion(ctx)
Yu Liu5d3a2cf2025-02-06 00:25:22 +00002265 commonData.MinSdkVersion.ApiLevel = &ver
Yu Liu8f2c5c02024-12-06 00:40:39 +00002266 } else if mm, ok := m.module.(interface{ MinSdkVersion() string }); ok {
Yu Liu5d3a2cf2025-02-06 00:25:22 +00002267 ver := mm.MinSdkVersion()
2268 // Compile against the current platform
2269 if ver == "" {
2270 commonData.MinSdkVersion.IsPlatform = true
2271 } else {
2272 api := ApiLevelFrom(ctx, ver)
2273 commonData.MinSdkVersion.ApiLevel = &api
2274 }
Yu Liu8f2c5c02024-12-06 00:40:39 +00002275 }
2276
Yu Liuf6f85492025-01-13 21:02:36 +00002277 if mm, ok := m.module.(interface {
2278 SdkVersion(ctx EarlyModuleContext) ApiLevel
2279 }); ok {
2280 ver := mm.SdkVersion(ctx)
2281 if !ver.IsNone() {
2282 commonData.SdkVersion = ver.String()
2283 }
2284 } else if mm, ok := m.module.(interface{ SdkVersion() string }); ok {
2285 commonData.SdkVersion = mm.SdkVersion()
2286 }
2287
Yu Liudd9ccb42024-10-07 17:07:44 +00002288 if m.commonProperties.ForcedDisabled {
2289 commonData.Enabled = false
2290 } else {
2291 commonData.Enabled = m.commonProperties.Enabled.GetOrDefault(m.ConfigurableEvaluator(ctx), !m.Os().DefaultDisabled)
2292 }
Yu Liu8f2c5c02024-12-06 00:40:39 +00002293 if am, ok := m.module.(ApexModule); ok {
2294 commonData.CanHaveApexVariants = am.CanHaveApexVariants()
2295 commonData.NotAvailableForPlatform = am.NotAvailableForPlatform()
Yu Liu8024b922024-12-20 23:31:32 +00002296 commonData.NotInPlatform = am.NotInPlatform()
Yu Liudf0b8392025-02-12 18:27:03 +00002297 commonData.MinSdkVersionSupported = am.MinSdkVersionSupported(ctx)
Yu Liu8f2c5c02024-12-06 00:40:39 +00002298 }
Yu Liudf0b8392025-02-12 18:27:03 +00002299
2300 if _, ok := m.module.(ModuleWithMinSdkVersionCheck); ok {
2301 commonData.ModuleWithMinSdkVersionCheck = true
2302 }
2303
Yu Liu97880e12025-01-07 19:03:34 +00002304 if st, ok := m.module.(StubsAvailableModule); ok {
2305 commonData.IsStubsModule = st.IsStubsModule()
2306 }
Yu Liub5275322024-11-13 18:40:43 +00002307 SetProvider(ctx, CommonModuleInfoKey, commonData)
Yu Liudd9ccb42024-10-07 17:07:44 +00002308 if p, ok := m.module.(PrebuiltInterface); ok && p.Prebuilt() != nil {
Yu Liu8a8d5b42025-01-07 00:48:08 +00002309 SetProvider(ctx, PrebuiltModuleInfoProvider, PrebuiltModuleInfo{
2310 SourceExists: p.Prebuilt().SourceExists(),
Yu Liu2da9d9a2025-01-15 00:27:02 +00002311 UsePrebuilt: p.Prebuilt().UsePrebuilt(),
Yu Liu8a8d5b42025-01-07 00:48:08 +00002312 })
Yu Liudd9ccb42024-10-07 17:07:44 +00002313 }
2314 if h, ok := m.module.(HostToolProvider); ok {
Yu Liu2da9d9a2025-01-15 00:27:02 +00002315 SetProvider(ctx, HostToolProviderInfoProvider, HostToolProviderInfo{
Yu Liudd9ccb42024-10-07 17:07:44 +00002316 HostToolPath: h.HostToolPath()})
2317 }
Yu Liue70976d2024-10-15 20:45:35 +00002318
Yu Liub5275322024-11-13 18:40:43 +00002319 if p, ok := m.module.(AndroidMkProviderInfoProducer); ok && !commonData.SkipAndroidMkProcessing {
Yu Liue70976d2024-10-15 20:45:35 +00002320 SetProvider(ctx, AndroidMkInfoProvider, p.PrepareAndroidMKProviderInfo(ctx.Config()))
2321 }
Yu Liu8024b922024-12-20 23:31:32 +00002322
2323 if s, ok := m.module.(SourceFileGenerator); ok {
2324 SetProvider(ctx, GeneratedSourceInfoProvider, GeneratedSourceInfo{
2325 GeneratedSourceFiles: s.GeneratedSourceFiles(),
2326 GeneratedHeaderDirs: s.GeneratedHeaderDirs(),
2327 GeneratedDeps: s.GeneratedDeps(),
2328 })
2329 }
Colin Cross3f40fa42015-01-30 17:27:36 -08002330}
2331
Joe Onorato349ae8d2024-02-05 22:46:00 +00002332func SetJarJarPrefixHandler(handler func(ModuleContext)) {
2333 if jarJarPrefixHandler != nil {
2334 panic("jarJarPrefixHandler already set")
2335 }
2336 jarJarPrefixHandler = handler
2337}
2338
Colin Crossd6fd0132023-11-06 13:54:06 -08002339func (m *ModuleBase) moduleInfoRegisterName(ctx ModuleContext, subName string) string {
2340 name := m.BaseModuleName()
2341
2342 prefix := ""
2343 if ctx.Host() {
2344 if ctx.Os() != ctx.Config().BuildOS {
2345 prefix = "host_cross_"
2346 }
2347 }
2348 suffix := ""
2349 arches := slices.Clone(ctx.Config().Targets[ctx.Os()])
2350 arches = slices.DeleteFunc(arches, func(target Target) bool {
2351 return target.NativeBridge != ctx.Target().NativeBridge
2352 })
Cole Faust866ab392025-01-23 12:56:20 -08002353 if len(arches) > 0 && ctx.Arch().ArchType != arches[0].Arch.ArchType && ctx.Arch().ArchType != Common {
Colin Crossd6fd0132023-11-06 13:54:06 -08002354 if ctx.Arch().ArchType.Multilib == "lib32" {
2355 suffix = "_32"
2356 } else {
2357 suffix = "_64"
2358 }
2359 }
2360 return prefix + name + subName + suffix
2361}
2362
2363func (m *ModuleBase) moduleInfoVariant(ctx ModuleContext) string {
2364 variant := "DEVICE"
2365 if ctx.Host() {
2366 if ctx.Os() != ctx.Config().BuildOS {
2367 variant = "HOST_CROSS"
2368 } else {
2369 variant = "HOST"
2370 }
2371 }
2372 return variant
2373}
2374
Paul Duffin89968e32020-11-23 18:17:03 +00002375// Check the supplied dist structure to make sure that it is valid.
2376//
2377// property - the base property, e.g. dist or dists[1], which is combined with the
2378// name of the nested property to produce the full property, e.g. dist.dest or
2379// dists[1].dir.
2380func checkDistProperties(ctx *moduleContext, property string, dist *Dist) {
2381 if dist.Dest != nil {
2382 _, err := validateSafePath(*dist.Dest)
2383 if err != nil {
2384 ctx.PropertyErrorf(property+".dest", "%s", err.Error())
2385 }
2386 }
2387 if dist.Dir != nil {
2388 _, err := validateSafePath(*dist.Dir)
2389 if err != nil {
2390 ctx.PropertyErrorf(property+".dir", "%s", err.Error())
2391 }
2392 }
2393 if dist.Suffix != nil {
2394 if strings.Contains(*dist.Suffix, "/") {
2395 ctx.PropertyErrorf(property+".suffix", "Suffix may not contain a '/' character.")
2396 }
2397 }
2398
2399}
2400
Colin Cross6301c3c2021-09-28 17:40:21 -07002401// katiInstall stores a request from Soong to Make to create an install rule.
2402type katiInstall struct {
2403 from Path
2404 to InstallPath
2405 implicitDeps Paths
2406 orderOnlyDeps Paths
2407 executable bool
Colin Cross50ed1f92021-11-12 17:41:02 -08002408 extraFiles *extraFilesZip
Yu Liu467d7c52024-09-18 21:54:44 +00002409 absFrom string
Colin Cross6301c3c2021-09-28 17:40:21 -07002410}
2411
Yu Liu467d7c52024-09-18 21:54:44 +00002412type katiInstallGob struct {
2413 From Path
2414 To InstallPath
2415 ImplicitDeps Paths
2416 OrderOnlyDeps Paths
2417 Executable bool
2418 ExtraFiles *extraFilesZip
2419 AbsFrom string
Yu Liu26a716d2024-08-30 23:40:32 +00002420}
2421
Yu Liu467d7c52024-09-18 21:54:44 +00002422func (k *katiInstall) ToGob() *katiInstallGob {
2423 return &katiInstallGob{
2424 From: k.from,
2425 To: k.to,
2426 ImplicitDeps: k.implicitDeps,
2427 OrderOnlyDeps: k.orderOnlyDeps,
2428 Executable: k.executable,
2429 ExtraFiles: k.extraFiles,
2430 AbsFrom: k.absFrom,
Yu Liu26a716d2024-08-30 23:40:32 +00002431 }
Yu Liu467d7c52024-09-18 21:54:44 +00002432}
Yu Liu26a716d2024-08-30 23:40:32 +00002433
Yu Liu467d7c52024-09-18 21:54:44 +00002434func (k *katiInstall) FromGob(data *katiInstallGob) {
2435 k.from = data.From
2436 k.to = data.To
2437 k.implicitDeps = data.ImplicitDeps
2438 k.orderOnlyDeps = data.OrderOnlyDeps
2439 k.executable = data.Executable
2440 k.extraFiles = data.ExtraFiles
2441 k.absFrom = data.AbsFrom
2442}
2443
2444func (k *katiInstall) GobEncode() ([]byte, error) {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002445 return gobtools.CustomGobEncode[katiInstallGob](k)
Yu Liu467d7c52024-09-18 21:54:44 +00002446}
2447
2448func (k *katiInstall) GobDecode(data []byte) error {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002449 return gobtools.CustomGobDecode[katiInstallGob](data, k)
Yu Liu26a716d2024-08-30 23:40:32 +00002450}
2451
Colin Cross50ed1f92021-11-12 17:41:02 -08002452type extraFilesZip struct {
2453 zip Path
2454 dir InstallPath
2455}
2456
Yu Liu467d7c52024-09-18 21:54:44 +00002457type extraFilesZipGob struct {
2458 Zip Path
2459 Dir InstallPath
Yu Liu26a716d2024-08-30 23:40:32 +00002460}
2461
Yu Liu467d7c52024-09-18 21:54:44 +00002462func (e *extraFilesZip) ToGob() *extraFilesZipGob {
2463 return &extraFilesZipGob{
2464 Zip: e.zip,
2465 Dir: e.dir,
Yu Liu26a716d2024-08-30 23:40:32 +00002466 }
Yu Liu467d7c52024-09-18 21:54:44 +00002467}
Yu Liu26a716d2024-08-30 23:40:32 +00002468
Yu Liu467d7c52024-09-18 21:54:44 +00002469func (e *extraFilesZip) FromGob(data *extraFilesZipGob) {
2470 e.zip = data.Zip
2471 e.dir = data.Dir
2472}
2473
2474func (e *extraFilesZip) GobEncode() ([]byte, error) {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002475 return gobtools.CustomGobEncode[extraFilesZipGob](e)
Yu Liu467d7c52024-09-18 21:54:44 +00002476}
2477
2478func (e *extraFilesZip) GobDecode(data []byte) error {
Yu Liu3cadf7d2024-10-24 18:47:06 +00002479 return gobtools.CustomGobDecode[extraFilesZipGob](data, e)
Yu Liu26a716d2024-08-30 23:40:32 +00002480}
2481
Colin Cross6301c3c2021-09-28 17:40:21 -07002482type katiInstalls []katiInstall
2483
2484// BuiltInstalled returns the katiInstalls in the form used by $(call copy-many-files) in Make, a
2485// space separated list of from:to tuples.
2486func (installs katiInstalls) BuiltInstalled() string {
2487 sb := strings.Builder{}
2488 for i, install := range installs {
2489 if i != 0 {
2490 sb.WriteRune(' ')
2491 }
2492 sb.WriteString(install.from.String())
2493 sb.WriteRune(':')
2494 sb.WriteString(install.to.String())
2495 }
2496 return sb.String()
2497}
2498
2499// InstallPaths returns the install path of each entry.
2500func (installs katiInstalls) InstallPaths() InstallPaths {
2501 paths := make(InstallPaths, 0, len(installs))
2502 for _, install := range installs {
2503 paths = append(paths, install.to)
2504 }
2505 return paths
2506}
2507
Jiyong Park5baac542018-08-28 09:55:37 +09002508// Makes this module a platform module, i.e. not specific to soc, device,
Justin Yund5f6c822019-06-25 16:47:17 +09002509// product, or system_ext.
Colin Cross4157e882019-06-06 16:57:04 -07002510func (m *ModuleBase) MakeAsPlatform() {
2511 m.commonProperties.Vendor = boolPtr(false)
2512 m.commonProperties.Proprietary = boolPtr(false)
2513 m.commonProperties.Soc_specific = boolPtr(false)
2514 m.commonProperties.Product_specific = boolPtr(false)
Justin Yund5f6c822019-06-25 16:47:17 +09002515 m.commonProperties.System_ext_specific = boolPtr(false)
Jiyong Park5baac542018-08-28 09:55:37 +09002516}
2517
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002518func (m *ModuleBase) MakeAsSystemExt() {
Jooyung Han91df2082019-11-20 01:49:42 +09002519 m.commonProperties.Vendor = boolPtr(false)
2520 m.commonProperties.Proprietary = boolPtr(false)
2521 m.commonProperties.Soc_specific = boolPtr(false)
2522 m.commonProperties.Product_specific = boolPtr(false)
2523 m.commonProperties.System_ext_specific = boolPtr(true)
Sundong Ahnd95aa2d2019-10-08 19:34:03 +09002524}
2525
Jooyung Han344d5432019-08-23 11:17:39 +09002526// IsNativeBridgeSupported returns true if "native_bridge_supported" is explicitly set as "true"
2527func (m *ModuleBase) IsNativeBridgeSupported() bool {
2528 return proptools.Bool(m.commonProperties.Native_bridge_supported)
2529}
2530
Jihoon Kang0d545b82024-10-11 00:21:57 +00002531func (m *ModuleBase) DecodeMultilib(ctx ConfigContext) (string, string) {
2532 return decodeMultilib(ctx, m)
2533}
2534
Spandan Dase1860e42024-10-24 22:29:50 +00002535func (m *ModuleBase) Overrides() []string {
2536 return m.commonProperties.Overrides
2537}
2538
Colin Cross8bbc3d52024-09-11 15:33:54 -07002539type ConfigContext interface {
2540 Config() Config
2541}
2542
Cole Fauste8a87832024-09-11 11:35:46 -07002543type ConfigurableEvaluatorContext interface {
Cole Faust55b56fe2024-08-23 12:06:11 -07002544 OtherModuleProviderContext
Cole Faust02987bd2024-03-21 17:58:43 -07002545 Config() Config
2546 OtherModulePropertyErrorf(module Module, property string, fmt string, args ...interface{})
Cole Faustd7067092024-09-13 13:37:59 -07002547 HasMutatorFinished(mutatorName string) bool
Cole Faust02987bd2024-03-21 17:58:43 -07002548}
2549
2550type configurationEvalutor struct {
Cole Fauste8a87832024-09-11 11:35:46 -07002551 ctx ConfigurableEvaluatorContext
Cole Faust02987bd2024-03-21 17:58:43 -07002552 m Module
2553}
2554
Cole Fauste8a87832024-09-11 11:35:46 -07002555func (m *ModuleBase) ConfigurableEvaluator(ctx ConfigurableEvaluatorContext) proptools.ConfigurableEvaluator {
Cole Faust02987bd2024-03-21 17:58:43 -07002556 return configurationEvalutor{
2557 ctx: ctx,
2558 m: m.module,
2559 }
2560}
2561
2562func (e configurationEvalutor) PropertyErrorf(property string, fmt string, args ...interface{}) {
Cole Fausta963b942024-04-11 17:43:00 -07002563 e.ctx.OtherModulePropertyErrorf(e.m, property, fmt, args...)
Cole Faust02987bd2024-03-21 17:58:43 -07002564}
2565
Cole Faustfdbf5d42024-04-10 15:01:23 -07002566func (e configurationEvalutor) EvaluateConfiguration(condition proptools.ConfigurableCondition, property string) proptools.ConfigurableValue {
Cole Faust02987bd2024-03-21 17:58:43 -07002567 ctx := e.ctx
2568 m := e.m
Cole Faustd7067092024-09-13 13:37:59 -07002569
2570 if !ctx.HasMutatorFinished("defaults") {
2571 ctx.OtherModulePropertyErrorf(m, property, "Cannot evaluate configurable property before the defaults mutator has run")
2572 return proptools.ConfigurableValueUndefined()
2573 }
2574
Cole Faust8afc5142024-04-26 16:30:19 -07002575 switch condition.FunctionName() {
Cole Fauste19f7412024-05-09 15:14:04 -07002576 case "release_flag":
Cole Faust8afc5142024-04-26 16:30:19 -07002577 if condition.NumArgs() != 1 {
Cole Fauste19f7412024-05-09 15:14:04 -07002578 ctx.OtherModulePropertyErrorf(m, property, "release_flag requires 1 argument, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002579 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002580 }
Cole Faust751a4a52024-05-21 16:51:59 -07002581 if ty, ok := ctx.Config().productVariables.BuildFlagTypes[condition.Arg(0)]; ok {
2582 v := ctx.Config().productVariables.BuildFlags[condition.Arg(0)]
2583 switch ty {
2584 case "unspecified", "obsolete":
2585 return proptools.ConfigurableValueUndefined()
2586 case "string":
2587 return proptools.ConfigurableValueString(v)
2588 case "bool":
2589 return proptools.ConfigurableValueBool(v == "true")
2590 default:
2591 panic("unhandled release flag type: " + ty)
2592 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002593 }
2594 return proptools.ConfigurableValueUndefined()
2595 case "product_variable":
Jiyong Parke3250752024-05-17 14:56:10 +09002596 if condition.NumArgs() != 1 {
2597 ctx.OtherModulePropertyErrorf(m, property, "product_variable requires 1 argument, found %d", condition.NumArgs())
2598 return proptools.ConfigurableValueUndefined()
2599 }
2600 variable := condition.Arg(0)
2601 switch variable {
Jihoon Kang82bea762024-09-30 18:50:54 +00002602 case "build_from_text_stub":
2603 return proptools.ConfigurableValueBool(ctx.Config().BuildFromTextStub())
Jiyong Parke3250752024-05-17 14:56:10 +09002604 case "debuggable":
2605 return proptools.ConfigurableValueBool(ctx.Config().Debuggable())
kellyhungf833fba2025-01-14 10:05:46 +00002606 case "eng":
2607 return proptools.ConfigurableValueBool(ctx.Config().Eng())
Kiyoung Kim881e4652024-07-08 11:02:23 +09002608 case "use_debug_art":
2609 // TODO(b/234351700): Remove once ART does not have separated debug APEX
2610 return proptools.ConfigurableValueBool(ctx.Config().UseDebugArt())
kellyhung1e613d22024-07-29 12:56:51 +00002611 case "selinux_ignore_neverallows":
2612 return proptools.ConfigurableValueBool(ctx.Config().SelinuxIgnoreNeverallows())
Jiyong Parke3250752024-05-17 14:56:10 +09002613 default:
2614 // TODO(b/323382414): Might add these on a case-by-case basis
2615 ctx.OtherModulePropertyErrorf(m, property, fmt.Sprintf("TODO(b/323382414): Product variable %q is not yet supported in selects", variable))
2616 return proptools.ConfigurableValueUndefined()
2617 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002618 case "soong_config_variable":
Cole Faust8afc5142024-04-26 16:30:19 -07002619 if condition.NumArgs() != 2 {
2620 ctx.OtherModulePropertyErrorf(m, property, "soong_config_variable requires 2 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002621 return proptools.ConfigurableValueUndefined()
2622 }
Cole Faust8afc5142024-04-26 16:30:19 -07002623 namespace := condition.Arg(0)
2624 variable := condition.Arg(1)
Cole Faust02987bd2024-03-21 17:58:43 -07002625 if n, ok := ctx.Config().productVariables.VendorVars[namespace]; ok {
2626 if v, ok := n[variable]; ok {
Cole Faust46f6e2f2024-06-20 12:57:43 -07002627 ty := ""
2628 if namespaces, ok := ctx.Config().productVariables.VendorVarTypes[namespace]; ok {
2629 ty = namespaces[variable]
2630 }
2631 switch ty {
2632 case "":
2633 // strings are the default, we don't bother writing them to the soong variables json file
2634 return proptools.ConfigurableValueString(v)
2635 case "bool":
2636 return proptools.ConfigurableValueBool(v == "true")
Cole Faust4143ee82024-11-21 11:20:06 -08002637 case "string_list":
2638 return proptools.ConfigurableValueStringList(strings.Split(v, " "))
Cole Faust46f6e2f2024-06-20 12:57:43 -07002639 default:
2640 panic("unhandled soong config variable type: " + ty)
2641 }
2642
Cole Faust02987bd2024-03-21 17:58:43 -07002643 }
2644 }
Cole Faustfdbf5d42024-04-10 15:01:23 -07002645 return proptools.ConfigurableValueUndefined()
Cole Faustfc57d402024-04-11 12:09:44 -07002646 case "arch":
Cole Faust8afc5142024-04-26 16:30:19 -07002647 if condition.NumArgs() != 0 {
2648 ctx.OtherModulePropertyErrorf(m, property, "arch requires no arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002649 return proptools.ConfigurableValueUndefined()
2650 }
Cole Faustfc57d402024-04-11 12:09:44 -07002651 if !m.base().ArchReady() {
2652 ctx.OtherModulePropertyErrorf(m, property, "A select on arch was attempted before the arch mutator ran")
2653 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002654 }
Cole Faustfc57d402024-04-11 12:09:44 -07002655 return proptools.ConfigurableValueString(m.base().Arch().ArchType.Name)
2656 case "os":
Cole Faust8afc5142024-04-26 16:30:19 -07002657 if condition.NumArgs() != 0 {
2658 ctx.OtherModulePropertyErrorf(m, property, "os requires no arguments, found %d", condition.NumArgs())
Cole Faustfc57d402024-04-11 12:09:44 -07002659 return proptools.ConfigurableValueUndefined()
2660 }
2661 // the arch mutator runs after the os mutator, we can just use this to enforce that os is ready.
2662 if !m.base().ArchReady() {
2663 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)")
2664 return proptools.ConfigurableValueUndefined()
2665 }
2666 return proptools.ConfigurableValueString(m.base().Os().Name)
Cole Faustfdbf5d42024-04-10 15:01:23 -07002667 case "boolean_var_for_testing":
2668 // We currently don't have any other boolean variables (we should add support for typing
2669 // the soong config variables), so add this fake one for testing the boolean select
2670 // functionality.
Cole Faust8afc5142024-04-26 16:30:19 -07002671 if condition.NumArgs() != 0 {
2672 ctx.OtherModulePropertyErrorf(m, property, "boolean_var_for_testing requires 0 arguments, found %d", condition.NumArgs())
Cole Faustfdbf5d42024-04-10 15:01:23 -07002673 return proptools.ConfigurableValueUndefined()
2674 }
2675
2676 if n, ok := ctx.Config().productVariables.VendorVars["boolean_var"]; ok {
2677 if v, ok := n["for_testing"]; ok {
2678 switch v {
2679 case "true":
2680 return proptools.ConfigurableValueBool(true)
2681 case "false":
2682 return proptools.ConfigurableValueBool(false)
2683 default:
2684 ctx.OtherModulePropertyErrorf(m, property, "testing:my_boolean_var can only be true or false, found %q", v)
2685 }
2686 }
2687 }
2688 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002689 default:
Cole Faustfdbf5d42024-04-10 15:01:23 -07002690 ctx.OtherModulePropertyErrorf(m, property, "Unknown select condition %s", condition.FunctionName)
2691 return proptools.ConfigurableValueUndefined()
Cole Faust02987bd2024-03-21 17:58:43 -07002692 }
2693}
2694
Colin Crossb63d7b32023-12-07 16:54:51 -08002695// ModuleNameWithPossibleOverride returns the name of the OverrideModule that overrides the current
2696// variant of this OverridableModule, or ctx.ModuleName() if this module is not an OverridableModule
2697// or if this variant is not overridden.
2698func ModuleNameWithPossibleOverride(ctx BaseModuleContext) string {
2699 if overridable, ok := ctx.Module().(OverridableModule); ok {
2700 if o := overridable.GetOverriddenBy(); o != "" {
2701 return o
2702 }
2703 }
2704 return ctx.ModuleName()
2705}
2706
Paul Duffine6ba0722021-07-12 20:12:12 +01002707// SrcIsModule decodes module references in the format ":unqualified-name" or "//namespace:name"
2708// into the module name, or empty string if the input was not a module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002709func SrcIsModule(s string) (module string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002710 if len(s) > 1 {
2711 if s[0] == ':' {
2712 module = s[1:]
2713 if !isUnqualifiedModuleName(module) {
2714 // The module name should be unqualified but is not so do not treat it as a module.
2715 module = ""
2716 }
2717 } else if s[0] == '/' && s[1] == '/' {
2718 module = s
2719 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002720 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002721 return module
Colin Cross068e0fe2016-12-13 15:23:47 -08002722}
2723
Yi-Yo Chiangba9ea322021-07-15 17:18:21 +08002724// SrcIsModuleWithTag decodes module references in the format ":unqualified-name{.tag}" or
2725// "//namespace:name{.tag}" into the module name and tag, ":unqualified-name" or "//namespace:name"
2726// into the module name and an empty string for the tag, or empty strings if the input was not a
2727// module reference.
Colin Cross41955e82019-05-29 14:40:35 -07002728func SrcIsModuleWithTag(s string) (module, tag string) {
Paul Duffine6ba0722021-07-12 20:12:12 +01002729 if len(s) > 1 {
2730 if s[0] == ':' {
2731 module = s[1:]
2732 } else if s[0] == '/' && s[1] == '/' {
2733 module = s
2734 }
2735
2736 if module != "" {
2737 if tagStart := strings.IndexByte(module, '{'); tagStart > 0 {
2738 if module[len(module)-1] == '}' {
2739 tag = module[tagStart+1 : len(module)-1]
2740 module = module[:tagStart]
2741 }
2742 }
2743
2744 if s[0] == ':' && !isUnqualifiedModuleName(module) {
2745 // The module name should be unqualified but is not so do not treat it as a module.
2746 module = ""
2747 tag = ""
Colin Cross41955e82019-05-29 14:40:35 -07002748 }
2749 }
Colin Cross41955e82019-05-29 14:40:35 -07002750 }
Paul Duffine6ba0722021-07-12 20:12:12 +01002751
2752 return module, tag
2753}
2754
2755// isUnqualifiedModuleName makes sure that the supplied module is an unqualified module name, i.e.
2756// does not contain any /.
2757func isUnqualifiedModuleName(module string) bool {
2758 return strings.IndexByte(module, '/') == -1
Colin Cross068e0fe2016-12-13 15:23:47 -08002759}
2760
Paul Duffin40131a32021-07-09 17:10:35 +01002761// sourceOrOutputDependencyTag is the dependency tag added automatically by pathDepsMutator for any
2762// module reference in a property annotated with `android:"path"` or passed to ExtractSourceDeps
2763// or ExtractSourcesDeps.
2764//
2765// If uniquely identifies the dependency that was added as it contains both the module name used to
2766// add the dependency as well as the tag. That makes it very simple to find the matching dependency
2767// in GetModuleFromPathDep as all it needs to do is find the dependency whose tag matches the tag
2768// used to add it. It does not need to check that the module name as returned by one of
2769// Module.Name(), BaseModuleContext.OtherModuleName() or ModuleBase.BaseModuleName() matches the
2770// name supplied in the tag. That means it does not need to handle differences in module names
2771// caused by prebuilt_ prefix, or fully qualified module names.
Colin Cross41955e82019-05-29 14:40:35 -07002772type sourceOrOutputDependencyTag struct {
2773 blueprint.BaseDependencyTag
Yu Liu67a28422024-03-05 00:36:31 +00002774 AlwaysPropagateAconfigValidationDependencyTag
Paul Duffin40131a32021-07-09 17:10:35 +01002775
2776 // The name of the module.
2777 moduleName string
2778
mrziwangd38e63d2024-07-15 13:43:37 -07002779 // The tag that will be used to get the specific output file(s).
Colin Cross41955e82019-05-29 14:40:35 -07002780 tag string
2781}
2782
Paul Duffin40131a32021-07-09 17:10:35 +01002783func sourceOrOutputDepTag(moduleName, tag string) blueprint.DependencyTag {
2784 return sourceOrOutputDependencyTag{moduleName: moduleName, tag: tag}
Colin Cross41955e82019-05-29 14:40:35 -07002785}
2786
Paul Duffind5cf92e2021-07-09 17:38:55 +01002787// IsSourceDepTagWithOutputTag returns true if the supplied blueprint.DependencyTag is one that was
2788// used to add dependencies by either ExtractSourceDeps, ExtractSourcesDeps or automatically for
2789// properties tagged with `android:"path"` AND it was added using a module reference of
2790// :moduleName{outputTag}.
2791func IsSourceDepTagWithOutputTag(depTag blueprint.DependencyTag, outputTag string) bool {
2792 t, ok := depTag.(sourceOrOutputDependencyTag)
2793 return ok && t.tag == outputTag
2794}
2795
Colin Cross366938f2017-12-11 16:29:02 -08002796// Adds necessary dependencies to satisfy filegroup or generated sources modules listed in srcFiles
2797// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002798//
2799// Deprecated: tag the property with `android:"path"` instead.
Colin Cross068e0fe2016-12-13 15:23:47 -08002800func ExtractSourcesDeps(ctx BottomUpMutatorContext, srcFiles []string) {
Nan Zhang2439eb72017-04-10 11:27:50 -07002801 set := make(map[string]bool)
2802
Colin Cross068e0fe2016-12-13 15:23:47 -08002803 for _, s := range srcFiles {
Colin Cross41955e82019-05-29 14:40:35 -07002804 if m, t := SrcIsModuleWithTag(s); m != "" {
2805 if _, found := set[s]; found {
2806 ctx.ModuleErrorf("found source dependency duplicate: %q!", s)
Nan Zhang2439eb72017-04-10 11:27:50 -07002807 } else {
Colin Cross41955e82019-05-29 14:40:35 -07002808 set[s] = true
Paul Duffin40131a32021-07-09 17:10:35 +01002809 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Nan Zhang2439eb72017-04-10 11:27:50 -07002810 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002811 }
2812 }
Colin Cross068e0fe2016-12-13 15:23:47 -08002813}
2814
Colin Cross366938f2017-12-11 16:29:02 -08002815// Adds necessary dependencies to satisfy filegroup or generated sources modules specified in s
2816// using ":module" syntax, if any.
Colin Cross27b922f2019-03-04 22:35:41 -08002817//
2818// Deprecated: tag the property with `android:"path"` instead.
Colin Cross366938f2017-12-11 16:29:02 -08002819func ExtractSourceDeps(ctx BottomUpMutatorContext, s *string) {
2820 if s != nil {
Colin Cross41955e82019-05-29 14:40:35 -07002821 if m, t := SrcIsModuleWithTag(*s); m != "" {
Paul Duffin40131a32021-07-09 17:10:35 +01002822 ctx.AddDependency(ctx.Module(), sourceOrOutputDepTag(m, t), m)
Colin Cross366938f2017-12-11 16:29:02 -08002823 }
2824 }
2825}
2826
Colin Cross41955e82019-05-29 14:40:35 -07002827// A module that implements SourceFileProducer can be referenced from any property that is tagged with `android:"path"`
2828// 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 -08002829type SourceFileProducer interface {
2830 Srcs() Paths
2831}
2832
mrziwangd38e63d2024-07-15 13:43:37 -07002833// OutputFilesForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002834// module produced zero paths, it reports errors to the ctx and returns nil.
Yu Liud3228ac2024-11-08 23:11:47 +00002835func OutputFilesForModule(ctx PathContext, module Module, tag string) Paths {
Colin Cross5e708052019-08-06 13:59:50 -07002836 paths, err := outputFilesForModule(ctx, module, tag)
2837 if err != nil {
2838 reportPathError(ctx, err)
2839 return nil
2840 }
2841 return paths
2842}
2843
mrziwangd38e63d2024-07-15 13:43:37 -07002844// OutputFileForModule returns the output file paths with the given tag. On error, including if the
Colin Cross5e708052019-08-06 13:59:50 -07002845// module produced zero or multiple paths, it reports errors to the ctx and returns nil.
Yu Liud3228ac2024-11-08 23:11:47 +00002846func OutputFileForModule(ctx PathContext, module Module, tag string) Path {
Colin Cross5e708052019-08-06 13:59:50 -07002847 paths, err := outputFilesForModule(ctx, module, tag)
2848 if err != nil {
2849 reportPathError(ctx, err)
2850 return nil
2851 }
Colin Cross14ec66c2022-10-03 21:02:27 -07002852 if len(paths) == 0 {
2853 type addMissingDependenciesIntf interface {
2854 AddMissingDependencies([]string)
2855 OtherModuleName(blueprint.Module) string
2856 }
2857 if mctx, ok := ctx.(addMissingDependenciesIntf); ok && ctx.Config().AllowMissingDependencies() {
2858 mctx.AddMissingDependencies([]string{mctx.OtherModuleName(module)})
2859 } else {
2860 ReportPathErrorf(ctx, "failed to get output files from module %q", pathContextName(ctx, module))
2861 }
2862 // Return a fake output file to avoid nil dereferences of Path objects later.
2863 // This should never get used for an actual build as the error or missing
2864 // dependency has already been reported.
2865 p, err := pathForSource(ctx, filepath.Join("missing_output_file", pathContextName(ctx, module)))
2866 if err != nil {
2867 reportPathError(ctx, err)
2868 return nil
2869 }
2870 return p
2871 }
Colin Cross5e708052019-08-06 13:59:50 -07002872 if len(paths) > 1 {
Ulya Trafimovich5ab276a2020-08-25 12:45:15 +01002873 ReportPathErrorf(ctx, "got multiple output files from module %q, expected exactly one",
Colin Cross5e708052019-08-06 13:59:50 -07002874 pathContextName(ctx, module))
Colin Cross5e708052019-08-06 13:59:50 -07002875 }
2876 return paths[0]
2877}
2878
Yu Liud3228ac2024-11-08 23:11:47 +00002879type OutputFilesProviderModuleContext interface {
2880 OtherModuleProviderContext
2881 Module() Module
2882 GetOutputFiles() OutputFilesInfo
2883 EqualModules(m1, m2 Module) bool
2884}
2885
2886func outputFilesForModule(ctx PathContext, module Module, tag string) (Paths, error) {
mrziwange6c85812024-05-22 14:36:09 -07002887 outputFilesFromProvider, err := outputFilesForModuleFromProvider(ctx, module, tag)
mrziwangabdb2932024-06-18 12:43:41 -07002888 if outputFilesFromProvider != nil || err != OutputFilesProviderNotSet {
mrziwange6c85812024-05-22 14:36:09 -07002889 return outputFilesFromProvider, err
2890 }
Yu Liud3228ac2024-11-08 23:11:47 +00002891
2892 if octx, ok := ctx.(OutputFilesProviderModuleContext); ok {
2893 if octx.EqualModules(octx.Module(), module) {
Yu Liu5697f8f2024-12-13 23:31:08 +00002894 // It is the current module, we can access the srcs through interface
Yu Liud3228ac2024-11-08 23:11:47 +00002895 if sourceFileProducer, ok := module.(SourceFileProducer); ok {
2896 return sourceFileProducer.Srcs(), nil
2897 }
Yu Liuc41eae52025-01-14 01:03:08 +00002898 } else if sourceFiles, ok := OtherModuleProvider(octx, module, SourceFilesInfoProvider); ok {
Yu Liud3228ac2024-11-08 23:11:47 +00002899 if tag != "" {
2900 return nil, fmt.Errorf("module %q is a SourceFileProducer, which does not support tag %q", pathContextName(ctx, module), tag)
2901 }
2902 paths := sourceFiles.Srcs
2903 return paths, nil
Colin Cross74b1e2b2020-11-22 20:23:02 -08002904 }
Colin Cross5e708052019-08-06 13:59:50 -07002905 }
Yu Liud3228ac2024-11-08 23:11:47 +00002906
2907 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 -07002908}
2909
mrziwange6c85812024-05-22 14:36:09 -07002910// This method uses OutputFilesProvider for output files
2911// *inter-module-communication*.
2912// If mctx module is the same as the param module the output files are obtained
2913// from outputFiles property of module base, to avoid both setting and
mrziwang42953592024-06-20 09:53:33 -07002914// reading OutputFilesProvider before GenerateBuildActions is finished.
mrziwange6c85812024-05-22 14:36:09 -07002915// If a module doesn't have the OutputFilesProvider, nil is returned.
Yu Liud3228ac2024-11-08 23:11:47 +00002916func outputFilesForModuleFromProvider(ctx PathContext, module Module, tag string) (Paths, error) {
mrziwangabdb2932024-06-18 12:43:41 -07002917 var outputFiles OutputFilesInfo
2918 fromProperty := false
mrziwang0cbd3b02024-06-20 16:39:25 -07002919
mrziwang1ea01e32024-07-12 12:26:34 -07002920 if mctx, isMctx := ctx.(OutputFilesProviderModuleContext); isMctx {
Yu Liud3228ac2024-11-08 23:11:47 +00002921 if !mctx.EqualModules(mctx.Module(), module) {
mrziwangabdb2932024-06-18 12:43:41 -07002922 outputFiles, _ = OtherModuleProvider(mctx, module, OutputFilesProvider)
mrziwang0cbd3b02024-06-20 16:39:25 -07002923 } else {
Yu Liu876b7ce2024-08-21 18:20:13 +00002924 outputFiles = mctx.GetOutputFiles()
mrziwangabdb2932024-06-18 12:43:41 -07002925 fromProperty = true
mrziwange6c85812024-05-22 14:36:09 -07002926 }
mrziwang0cbd3b02024-06-20 16:39:25 -07002927 } else if cta, isCta := ctx.(*singletonContextAdaptor); isCta {
Yu Liud3228ac2024-11-08 23:11:47 +00002928 outputFiles, _ = OtherModuleProvider(cta, module, OutputFilesProvider)
mrziwang7a47bd32024-07-17 11:11:05 -07002929 } else {
2930 return nil, fmt.Errorf("unsupported context %q in method outputFilesForModuleFromProvider", reflect.TypeOf(ctx))
mrziwang0cbd3b02024-06-20 16:39:25 -07002931 }
mrziwang0cbd3b02024-06-20 16:39:25 -07002932
mrziwangabdb2932024-06-18 12:43:41 -07002933 if outputFiles.isEmpty() {
mrziwangabdb2932024-06-18 12:43:41 -07002934 return nil, OutputFilesProviderNotSet
2935 }
2936
2937 if tag == "" {
2938 return outputFiles.DefaultOutputFiles, nil
2939 } else if taggedOutputFiles, hasTag := outputFiles.TaggedOutputFiles[tag]; hasTag {
2940 return taggedOutputFiles, nil
2941 } else {
2942 if fromProperty {
2943 return nil, fmt.Errorf("unsupported tag %q for module getting its own output files", tag)
mrziwange6c85812024-05-22 14:36:09 -07002944 } else {
mrziwang0cbd3b02024-06-20 16:39:25 -07002945 return nil, fmt.Errorf("unsupported module reference tag %q", tag)
mrziwange6c85812024-05-22 14:36:09 -07002946 }
2947 }
mrziwange6c85812024-05-22 14:36:09 -07002948}
2949
mrziwang0cbd3b02024-06-20 16:39:25 -07002950func (o OutputFilesInfo) isEmpty() bool {
2951 return o.DefaultOutputFiles == nil && o.TaggedOutputFiles == nil
2952}
2953
mrziwange6c85812024-05-22 14:36:09 -07002954type OutputFilesInfo struct {
2955 // default output files when tag is an empty string ""
2956 DefaultOutputFiles Paths
2957
2958 // the corresponding output files for given tags
2959 TaggedOutputFiles map[string]Paths
2960}
2961
2962var OutputFilesProvider = blueprint.NewProvider[OutputFilesInfo]()
2963
mrziwangabdb2932024-06-18 12:43:41 -07002964// This is used to mark the case where OutputFilesProvider is not set on some modules.
2965var OutputFilesProviderNotSet = fmt.Errorf("No output files from provider")
2966
Colin Cross41589502020-12-01 14:00:21 -08002967// Modules can implement HostToolProvider and return a valid OptionalPath from HostToolPath() to
2968// specify that they can be used as a tool by a genrule module.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002969type HostToolProvider interface {
Colin Crossba9e4032020-11-24 16:32:22 -08002970 Module
Colin Cross41589502020-12-01 14:00:21 -08002971 // HostToolPath returns the path to the host tool for the module if it is one, or an invalid
2972 // OptionalPath.
Colin Crossfe17f6f2019-03-28 19:30:56 -07002973 HostToolPath() OptionalPath
2974}
2975
Colin Cross463a90e2015-06-17 14:20:06 -07002976func init() {
LaMont Jones0c10e4d2023-05-16 00:58:37 +00002977 RegisterParallelSingletonType("buildtarget", BuildTargetSingleton)
Colin Cross463a90e2015-06-17 14:20:06 -07002978}
2979
Colin Cross0875c522017-11-28 17:34:01 -08002980func BuildTargetSingleton() Singleton {
Colin Cross1f8c52b2015-06-16 16:38:17 -07002981 return &buildTargetSingleton{}
2982}
2983
Colin Cross87d8b562017-04-25 10:01:55 -07002984func parentDir(dir string) string {
2985 dir, _ = filepath.Split(dir)
2986 return filepath.Clean(dir)
2987}
2988
Colin Cross1f8c52b2015-06-16 16:38:17 -07002989type buildTargetSingleton struct{}
2990
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002991func AddAncestors(ctx SingletonContext, dirMap map[string]Paths, mmName func(string) string) ([]string, []string) {
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002992 // Ensure ancestor directories are in dirMap
2993 // Make directories build their direct subdirectories
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07002994 // Returns a slice of all directories and a slice of top-level directories.
Cole Faust18994c72023-02-28 16:02:16 -08002995 dirs := SortedKeys(dirMap)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07002996 for _, dir := range dirs {
2997 dir := parentDir(dir)
2998 for dir != "." && dir != "/" {
2999 if _, exists := dirMap[dir]; exists {
3000 break
3001 }
3002 dirMap[dir] = nil
3003 dir = parentDir(dir)
3004 }
3005 }
Cole Faust18994c72023-02-28 16:02:16 -08003006 dirs = SortedKeys(dirMap)
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07003007 var topDirs []string
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07003008 for _, dir := range dirs {
3009 p := parentDir(dir)
3010 if p != "." && p != "/" {
3011 dirMap[p] = append(dirMap[p], PathForPhony(ctx, mmName(dir)))
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07003012 } else if dir != "." && dir != "/" && dir != "" {
3013 topDirs = append(topDirs, dir)
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07003014 }
3015 }
Cole Faust18994c72023-02-28 16:02:16 -08003016 return SortedKeys(dirMap), topDirs
Chih-Hung Hsiehd0f82fe2021-09-05 20:15:38 -07003017}
3018
Colin Cross0875c522017-11-28 17:34:01 -08003019func (c *buildTargetSingleton) GenerateBuildActions(ctx SingletonContext) {
3020 var checkbuildDeps Paths
Colin Cross1f8c52b2015-06-16 16:38:17 -07003021
LaMont Jones825f8ff2025-02-12 11:52:00 -08003022 // Create a top level partialcompileclean target for modules to add dependencies to.
3023 ctx.Phony("partialcompileclean")
3024
Colin Crossc3d87d32020-06-04 13:25:17 -07003025 mmTarget := func(dir string) string {
3026 return "MODULES-IN-" + strings.Replace(filepath.Clean(dir), "/", "-", -1)
Colin Cross87d8b562017-04-25 10:01:55 -07003027 }
3028
Colin Cross0875c522017-11-28 17:34:01 -08003029 modulesInDir := make(map[string]Paths)
Colin Cross1f8c52b2015-06-16 16:38:17 -07003030
Colin Cross0875c522017-11-28 17:34:01 -08003031 ctx.VisitAllModules(func(module Module) {
Yu Liuddc2e1a2024-08-20 21:31:22 +00003032 info := OtherModuleProviderOrDefault(ctx, module, FinalModuleBuildTargetsProvider)
Colin Cross1f8c52b2015-06-16 16:38:17 -07003033
Yu Liuddc2e1a2024-08-20 21:31:22 +00003034 if info.CheckbuildTarget != nil {
3035 checkbuildDeps = append(checkbuildDeps, info.CheckbuildTarget)
3036 modulesInDir[info.BlueprintDir] = append(modulesInDir[info.BlueprintDir], info.CheckbuildTarget)
Colin Cross0875c522017-11-28 17:34:01 -08003037 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07003038
Yu Liuddc2e1a2024-08-20 21:31:22 +00003039 if info.InstallTarget != nil {
3040 modulesInDir[info.BlueprintDir] = append(modulesInDir[info.BlueprintDir], info.InstallTarget)
Colin Cross1f8c52b2015-06-16 16:38:17 -07003041 }
3042 })
3043
Dan Willemsen5ba07e82015-12-11 13:51:06 -08003044 suffix := ""
Jingwen Chencda22c92020-11-23 00:22:30 -05003045 if ctx.Config().KatiEnabled() {
Dan Willemsen5ba07e82015-12-11 13:51:06 -08003046 suffix = "-soong"
3047 }
3048
Colin Cross1f8c52b2015-06-16 16:38:17 -07003049 // Create a top-level checkbuild target that depends on all modules
Colin Crossc3d87d32020-06-04 13:25:17 -07003050 ctx.Phony("checkbuild"+suffix, checkbuildDeps...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07003051
Dan Willemsend2e95fb2017-09-20 14:30:50 -07003052 // Make will generate the MODULES-IN-* targets
Jingwen Chencda22c92020-11-23 00:22:30 -05003053 if ctx.Config().KatiEnabled() {
Dan Willemsend2e95fb2017-09-20 14:30:50 -07003054 return
3055 }
3056
Chih-Hung Hsieh80783772021-10-11 16:46:56 -07003057 dirs, _ := AddAncestors(ctx, modulesInDir, mmTarget)
Colin Cross87d8b562017-04-25 10:01:55 -07003058
Dan Willemsend2e95fb2017-09-20 14:30:50 -07003059 // Create a MODULES-IN-<directory> target that depends on all modules in a directory, and
3060 // depends on the MODULES-IN-* targets of all of its subdirectories that contain Android.bp
3061 // files.
Colin Cross1f8c52b2015-06-16 16:38:17 -07003062 for _, dir := range dirs {
Colin Crossc3d87d32020-06-04 13:25:17 -07003063 ctx.Phony(mmTarget(dir), modulesInDir[dir]...)
Colin Cross1f8c52b2015-06-16 16:38:17 -07003064 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07003065
3066 // Create (host|host-cross|target)-<OS> phony rules to build a reduced checkbuild.
Jiyong Park1613e552020-09-14 19:43:17 +09003067 type osAndCross struct {
3068 os OsType
3069 hostCross bool
3070 }
3071 osDeps := map[osAndCross]Paths{}
Colin Cross0875c522017-11-28 17:34:01 -08003072 ctx.VisitAllModules(func(module Module) {
Cole Fausta963b942024-04-11 17:43:00 -07003073 if module.Enabled(ctx) {
Jiyong Park1613e552020-09-14 19:43:17 +09003074 key := osAndCross{os: module.Target().Os, hostCross: module.Target().HostCross}
Yu Liud46e5ae2024-08-15 18:46:17 +00003075 osDeps[key] = append(osDeps[key], OtherModuleProviderOrDefault(ctx, module, InstallFilesProvider).CheckbuildFiles...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07003076 }
3077 })
3078
Colin Cross0875c522017-11-28 17:34:01 -08003079 osClass := make(map[string]Paths)
Jiyong Park1613e552020-09-14 19:43:17 +09003080 for key, deps := range osDeps {
Dan Willemsen61d88b82017-09-20 17:29:08 -07003081 var className string
3082
Jiyong Park1613e552020-09-14 19:43:17 +09003083 switch key.os.Class {
Dan Willemsen61d88b82017-09-20 17:29:08 -07003084 case Host:
Jiyong Park1613e552020-09-14 19:43:17 +09003085 if key.hostCross {
3086 className = "host-cross"
3087 } else {
3088 className = "host"
3089 }
Dan Willemsen61d88b82017-09-20 17:29:08 -07003090 case Device:
3091 className = "target"
3092 default:
3093 continue
3094 }
3095
Jiyong Park1613e552020-09-14 19:43:17 +09003096 name := className + "-" + key.os.Name
Colin Crossc3d87d32020-06-04 13:25:17 -07003097 osClass[className] = append(osClass[className], PathForPhony(ctx, name))
Dan Willemsen61d88b82017-09-20 17:29:08 -07003098
Colin Crossc3d87d32020-06-04 13:25:17 -07003099 ctx.Phony(name, deps...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07003100 }
3101
3102 // Wrap those into host|host-cross|target phony rules
Cole Faust18994c72023-02-28 16:02:16 -08003103 for _, class := range SortedKeys(osClass) {
Colin Crossc3d87d32020-06-04 13:25:17 -07003104 ctx.Phony(class, osClass[class]...)
Dan Willemsen61d88b82017-09-20 17:29:08 -07003105 }
Colin Cross1f8c52b2015-06-16 16:38:17 -07003106}
Colin Crossd779da42015-12-17 18:00:23 -08003107
Brandon Lee5d45c6f2018-08-15 15:35:38 -07003108// Collect information for opening IDE project files in java/jdeps.go.
3109type IDEInfo interface {
Cole Faustb36d31d2024-08-27 16:04:28 -07003110 IDEInfo(ctx BaseModuleContext, ideInfo *IdeInfo)
Brandon Lee5d45c6f2018-08-15 15:35:38 -07003111 BaseModuleName() string
3112}
3113
3114// Extract the base module name from the Import name.
3115// Often the Import name has a prefix "prebuilt_".
3116// Remove the prefix explicitly if needed
3117// until we find a better solution to get the Import name.
3118type IDECustomizedModuleName interface {
3119 IDECustomizedModuleName() string
3120}
3121
Cole Faust08c7f862024-08-27 15:03:59 -07003122// Collect information for opening IDE project files in java/jdeps.go.
Brandon Lee5d45c6f2018-08-15 15:35:38 -07003123type IdeInfo struct {
Cole Faust08c7f862024-08-27 15:03:59 -07003124 BaseModuleName string `json:"-"`
Brandon Lee5d45c6f2018-08-15 15:35:38 -07003125 Deps []string `json:"dependencies,omitempty"`
3126 Srcs []string `json:"srcs,omitempty"`
3127 Aidl_include_dirs []string `json:"aidl_include_dirs,omitempty"`
3128 Jarjar_rules []string `json:"jarjar_rules,omitempty"`
3129 Jars []string `json:"jars,omitempty"`
3130 Classes []string `json:"class,omitempty"`
3131 Installed_paths []string `json:"installed,omitempty"`
patricktu18c82ff2019-05-10 15:48:50 +08003132 SrcJars []string `json:"srcjars,omitempty"`
bralee1fbf4402020-05-21 10:11:59 +08003133 Paths []string `json:"path,omitempty"`
Yikef6282022022-04-13 20:41:01 +08003134 Static_libs []string `json:"static_libs,omitempty"`
3135 Libs []string `json:"libs,omitempty"`
Brandon Lee5d45c6f2018-08-15 15:35:38 -07003136}
Paul Duffinf88d8e02020-05-07 20:21:34 +01003137
Cole Faust08c7f862024-08-27 15:03:59 -07003138// Merge merges two IdeInfos and produces a new one, leaving the origional unchanged
3139func (i IdeInfo) Merge(other IdeInfo) IdeInfo {
3140 return IdeInfo{
3141 Deps: mergeStringLists(i.Deps, other.Deps),
3142 Srcs: mergeStringLists(i.Srcs, other.Srcs),
3143 Aidl_include_dirs: mergeStringLists(i.Aidl_include_dirs, other.Aidl_include_dirs),
3144 Jarjar_rules: mergeStringLists(i.Jarjar_rules, other.Jarjar_rules),
3145 Jars: mergeStringLists(i.Jars, other.Jars),
3146 Classes: mergeStringLists(i.Classes, other.Classes),
3147 Installed_paths: mergeStringLists(i.Installed_paths, other.Installed_paths),
3148 SrcJars: mergeStringLists(i.SrcJars, other.SrcJars),
3149 Paths: mergeStringLists(i.Paths, other.Paths),
3150 Static_libs: mergeStringLists(i.Static_libs, other.Static_libs),
3151 Libs: mergeStringLists(i.Libs, other.Libs),
3152 }
3153}
3154
3155// mergeStringLists appends the two string lists together and returns a new string list,
3156// leaving the originals unchanged. Duplicate strings will be deduplicated.
3157func mergeStringLists(a, b []string) []string {
3158 return FirstUniqueStrings(Concat(a, b))
3159}
3160
3161var IdeInfoProviderKey = blueprint.NewProvider[IdeInfo]()
3162
Paul Duffinf88d8e02020-05-07 20:21:34 +01003163func CheckBlueprintSyntax(ctx BaseModuleContext, filename string, contents string) []error {
3164 bpctx := ctx.blueprintBaseModuleContext()
3165 return blueprint.CheckBlueprintSyntax(bpctx.ModuleFactories(), filename, contents)
3166}