1// Copyright 2015 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package android
16
17import (
18	"reflect"
19
20	"github.com/google/blueprint"
21	"github.com/google/blueprint/proptools"
22)
23
24type defaultsDependencyTag struct {
25	blueprint.BaseDependencyTag
26}
27
28var DefaultsDepTag defaultsDependencyTag
29
30type defaultsProperties struct {
31	Defaults []string
32}
33
34type DefaultableModuleBase struct {
35	defaultsProperties            defaultsProperties
36	defaultableProperties         []interface{}
37	defaultableVariableProperties interface{}
38
39	// The optional hook to call after any defaults have been applied.
40	hook DefaultableHook
41}
42
43func (d *DefaultableModuleBase) defaults() *defaultsProperties {
44	return &d.defaultsProperties
45}
46
47func (d *DefaultableModuleBase) setProperties(props []interface{}, variableProperties interface{}) {
48	d.defaultableProperties = props
49	d.defaultableVariableProperties = variableProperties
50}
51
52func (d *DefaultableModuleBase) SetDefaultableHook(hook DefaultableHook) {
53	d.hook = hook
54}
55
56func (d *DefaultableModuleBase) callHookIfAvailable(ctx DefaultableHookContext) {
57	if d.hook != nil {
58		d.hook(ctx)
59	}
60}
61
62// Interface that must be supported by any module to which defaults can be applied.
63type Defaultable interface {
64	// Get a pointer to the struct containing the Defaults property.
65	defaults() *defaultsProperties
66
67	// Set the property structures into which defaults will be added.
68	setProperties(props []interface{}, variableProperties interface{})
69
70	// Apply defaults from the supplied Defaults to the property structures supplied to
71	// setProperties(...).
72	applyDefaults(TopDownMutatorContext, []Defaults)
73
74	// Set the hook to be called after any defaults have been applied.
75	//
76	// Should be used in preference to a AddLoadHook when the behavior of the load
77	// hook is dependent on properties supplied in the Android.bp file.
78	SetDefaultableHook(hook DefaultableHook)
79
80	// Call the hook if specified.
81	callHookIfAvailable(context DefaultableHookContext)
82}
83
84type DefaultableModule interface {
85	Module
86	Defaultable
87}
88
89var _ Defaultable = (*DefaultableModuleBase)(nil)
90
91func InitDefaultableModule(module DefaultableModule) {
92	if module.(Module).base().module == nil {
93		panic("InitAndroidModule must be called before InitDefaultableModule")
94	}
95	module.setProperties(module.(Module).GetProperties(), module.(Module).base().variableProperties)
96
97	module.AddProperties(module.defaults())
98
99	module.base().customizableProperties = module.GetProperties()
100}
101
102// A restricted subset of context methods, similar to LoadHookContext.
103type DefaultableHookContext interface {
104	EarlyModuleContext
105
106	CreateModule(ModuleFactory, ...interface{}) Module
107}
108
109type DefaultableHook func(ctx DefaultableHookContext)
110
111// The Defaults_visibility property.
112type DefaultsVisibilityProperties struct {
113
114	// Controls the visibility of the defaults module itself.
115	Defaults_visibility []string
116}
117
118type DefaultsModuleBase struct {
119	DefaultableModuleBase
120}
121
122// The common pattern for defaults modules is to register separate instances of
123// the xxxProperties structs in the AddProperties calls, rather than reusing the
124// ones inherited from Module.
125//
126// The effect is that e.g. myDefaultsModuleInstance.base().xxxProperties won't
127// contain the values that have been set for the defaults module. Rather, to
128// retrieve the values it is necessary to iterate over properties(). E.g. to get
129// the commonProperties instance that have the real values:
130//
131//   d := myModule.(Defaults)
132//   for _, props := range d.properties() {
133//     if cp, ok := props.(*commonProperties); ok {
134//       ... access property values in cp ...
135//     }
136//   }
137//
138// The rationale is that the properties on a defaults module apply to the
139// defaultable modules using it, not to the defaults module itself. E.g. setting
140// the "enabled" property false makes inheriting modules disabled by default,
141// rather than disabling the defaults module itself.
142type Defaults interface {
143	Defaultable
144
145	// Although this function is unused it is actually needed to ensure that only modules that embed
146	// DefaultsModuleBase will type-assert to the Defaults interface.
147	isDefaults() bool
148
149	// Get the structures containing the properties for which defaults can be provided.
150	properties() []interface{}
151
152	productVariableProperties() interface{}
153}
154
155func (d *DefaultsModuleBase) isDefaults() bool {
156	return true
157}
158
159type DefaultsModule interface {
160	Module
161	Defaults
162}
163
164func (d *DefaultsModuleBase) properties() []interface{} {
165	return d.defaultableProperties
166}
167
168func (d *DefaultsModuleBase) productVariableProperties() interface{} {
169	return d.defaultableVariableProperties
170}
171
172func (d *DefaultsModuleBase) GenerateAndroidBuildActions(ctx ModuleContext) {
173}
174
175func InitDefaultsModule(module DefaultsModule) {
176	commonProperties := &commonProperties{}
177
178	module.AddProperties(
179		&hostAndDeviceProperties{},
180		commonProperties,
181		&ApexProperties{},
182		&distProperties{})
183
184	initAndroidModuleBase(module)
185	initProductVariableModule(module)
186	initArchModule(module)
187	InitDefaultableModule(module)
188
189	// Add properties that will not have defaults applied to them.
190	base := module.base()
191	defaultsVisibility := &DefaultsVisibilityProperties{}
192	module.AddProperties(&base.nameProperties, defaultsVisibility)
193
194	// Unlike non-defaults modules the visibility property is not stored in m.base().commonProperties.
195	// Instead it is stored in a separate instance of commonProperties created above so clear the
196	// existing list of properties.
197	clearVisibilityProperties(module)
198
199	// The defaults_visibility property controls the visibility of a defaults module so it must be
200	// set as the primary property, which also adds it to the list.
201	setPrimaryVisibilityProperty(module, "defaults_visibility", &defaultsVisibility.Defaults_visibility)
202
203	// The visibility property needs to be checked (but not parsed) by the visibility module during
204	// its checking phase and parsing phase so add it to the list as a normal property.
205	AddVisibilityProperty(module, "visibility", &commonProperties.Visibility)
206
207	// The applicable licenses property for defaults is 'licenses'.
208	setPrimaryLicensesProperty(module, "licenses", &commonProperties.Licenses)
209
210	base.module = module
211}
212
213var _ Defaults = (*DefaultsModuleBase)(nil)
214
215func (defaultable *DefaultableModuleBase) applyDefaults(ctx TopDownMutatorContext,
216	defaultsList []Defaults) {
217
218	for _, defaults := range defaultsList {
219		for _, prop := range defaultable.defaultableProperties {
220			if prop == defaultable.defaultableVariableProperties {
221				defaultable.applyDefaultVariableProperties(ctx, defaults, prop)
222			} else {
223				defaultable.applyDefaultProperties(ctx, defaults, prop)
224			}
225		}
226	}
227}
228
229// Product variable properties need special handling, the type of the filtered product variable
230// property struct may not be identical between the defaults module and the defaultable module.
231// Use PrependMatchingProperties to apply whichever properties match.
232func (defaultable *DefaultableModuleBase) applyDefaultVariableProperties(ctx TopDownMutatorContext,
233	defaults Defaults, defaultableProp interface{}) {
234	if defaultableProp == nil {
235		return
236	}
237
238	defaultsProp := defaults.productVariableProperties()
239	if defaultsProp == nil {
240		return
241	}
242
243	dst := []interface{}{
244		defaultableProp,
245		// Put an empty copy of the src properties into dst so that properties in src that are not in dst
246		// don't cause a "failed to find property to extend" error.
247		proptools.CloneEmptyProperties(reflect.ValueOf(defaultsProp)).Interface(),
248	}
249
250	err := proptools.PrependMatchingProperties(dst, defaultsProp, nil)
251	if err != nil {
252		if propertyErr, ok := err.(*proptools.ExtendPropertyError); ok {
253			ctx.PropertyErrorf(propertyErr.Property, "%s", propertyErr.Err.Error())
254		} else {
255			panic(err)
256		}
257	}
258}
259
260func (defaultable *DefaultableModuleBase) applyDefaultProperties(ctx TopDownMutatorContext,
261	defaults Defaults, defaultableProp interface{}) {
262
263	for _, def := range defaults.properties() {
264		if proptools.TypeEqual(defaultableProp, def) {
265			err := proptools.PrependProperties(defaultableProp, def, nil)
266			if err != nil {
267				if propertyErr, ok := err.(*proptools.ExtendPropertyError); ok {
268					ctx.PropertyErrorf(propertyErr.Property, "%s", propertyErr.Err.Error())
269				} else {
270					panic(err)
271				}
272			}
273		}
274	}
275}
276
277func RegisterDefaultsPreArchMutators(ctx RegisterMutatorsContext) {
278	ctx.BottomUp("defaults_deps", defaultsDepsMutator).Parallel()
279	ctx.TopDown("defaults", defaultsMutator).Parallel()
280}
281
282func defaultsDepsMutator(ctx BottomUpMutatorContext) {
283	if defaultable, ok := ctx.Module().(Defaultable); ok {
284		ctx.AddDependency(ctx.Module(), DefaultsDepTag, defaultable.defaults().Defaults...)
285	}
286}
287
288func defaultsMutator(ctx TopDownMutatorContext) {
289	if defaultable, ok := ctx.Module().(Defaultable); ok {
290		if len(defaultable.defaults().Defaults) > 0 {
291			var defaultsList []Defaults
292			seen := make(map[Defaults]bool)
293
294			ctx.WalkDeps(func(module, parent Module) bool {
295				if ctx.OtherModuleDependencyTag(module) == DefaultsDepTag {
296					if defaults, ok := module.(Defaults); ok {
297						if !seen[defaults] {
298							seen[defaults] = true
299							defaultsList = append(defaultsList, defaults)
300							return len(defaults.defaults().Defaults) > 0
301						}
302					} else {
303						ctx.PropertyErrorf("defaults", "module %s is not an defaults module",
304							ctx.OtherModuleName(module))
305					}
306				}
307				return false
308			})
309			defaultable.applyDefaults(ctx, defaultsList)
310		}
311
312		defaultable.callHookIfAvailable(ctx)
313	}
314}
315