blob: 2b5072b1b1019b158cf634130b4e1770a82c3a4f [file] [log] [blame]
Jiyong Park9d452992018-10-03 00:38:19 +09001// Copyright 2018 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
Jiyong Park0ddfcd12018-12-11 01:35:25 +090017import (
Jooyung Han0c4e0162020-02-26 22:45:42 +090018 "fmt"
Colin Crosscefa94bd2019-06-03 15:07:03 -070019 "sort"
Jooyung Han0c4e0162020-02-26 22:45:42 +090020 "strconv"
Jiyong Park0ddfcd12018-12-11 01:35:25 +090021 "sync"
Jiyong Park0ddfcd12018-12-11 01:35:25 +090022)
Jiyong Park25fc6a92018-11-18 18:02:45 +090023
Jooyung Han23b0adf2020-03-12 18:37:20 +090024const (
25 SdkVersion_Android10 = 29
26)
27
Peter Collingbournedc4f9862020-02-12 17:13:25 -080028type ApexInfo struct {
29 // Name of the apex variant that this module is mutated into
30 ApexName string
31
Jooyung Han0c4e0162020-02-26 22:45:42 +090032 MinSdkVersion int
Peter Collingbournedc4f9862020-02-12 17:13:25 -080033}
34
Jiyong Park9d452992018-10-03 00:38:19 +090035// ApexModule is the interface that a module type is expected to implement if
36// the module has to be built differently depending on whether the module
37// is destined for an apex or not (installed to one of the regular partitions).
38//
39// Native shared libraries are one such module type; when it is built for an
40// APEX, it should depend only on stable interfaces such as NDK, stable AIDL,
41// or C APIs from other APEXs.
42//
43// A module implementing this interface will be mutated into multiple
Jiyong Park0ddfcd12018-12-11 01:35:25 +090044// variations by apex.apexMutator if it is directly or indirectly included
Jiyong Park9d452992018-10-03 00:38:19 +090045// in one or more APEXs. Specifically, if a module is included in apex.foo and
46// apex.bar then three apex variants are created: platform, apex.foo and
47// apex.bar. The platform variant is for the regular partitions
48// (e.g., /system or /vendor, etc.) while the other two are for the APEXs,
49// respectively.
50type ApexModule interface {
51 Module
52 apexModuleBase() *ApexModuleBase
53
Peter Collingbournedc4f9862020-02-12 17:13:25 -080054 // Marks that this module should be built for the specified APEXes.
Jiyong Park0ddfcd12018-12-11 01:35:25 +090055 // Call this before apex.apexMutator is run.
Peter Collingbournedc4f9862020-02-12 17:13:25 -080056 BuildForApexes(apexes []ApexInfo)
Jiyong Parkf760cae2020-02-12 07:53:12 +090057
Peter Collingbournedc4f9862020-02-12 17:13:25 -080058 // Returns the APEXes that this module will be built for
59 ApexVariations() []ApexInfo
Jiyong Park9d452992018-10-03 00:38:19 +090060
Jiyong Park9d452992018-10-03 00:38:19 +090061 // Returns the name of APEX that this module will be built for. Empty string
62 // is returned when 'IsForPlatform() == true'. Note that a module can be
Jiyong Park0ddfcd12018-12-11 01:35:25 +090063 // included in multiple APEXes, in which case, the module is mutated into
Jiyong Park9d452992018-10-03 00:38:19 +090064 // multiple modules each of which for an APEX. This method returns the
65 // name of the APEX that a variant module is for.
Jiyong Park0ddfcd12018-12-11 01:35:25 +090066 // Call this after apex.apexMutator is run.
Jiyong Park9d452992018-10-03 00:38:19 +090067 ApexName() string
68
Jiyong Park0ddfcd12018-12-11 01:35:25 +090069 // Tests whether this module will be built for the platform or not.
70 // This is a shortcut for ApexName() == ""
71 IsForPlatform() bool
72
73 // Tests if this module could have APEX variants. APEX variants are
Jiyong Park9d452992018-10-03 00:38:19 +090074 // created only for the modules that returns true here. This is useful
Jiyong Park0ddfcd12018-12-11 01:35:25 +090075 // for not creating APEX variants for certain types of shared libraries
76 // such as NDK stubs.
Jiyong Park9d452992018-10-03 00:38:19 +090077 CanHaveApexVariants() bool
78
79 // Tests if this module can be installed to APEX as a file. For example,
80 // this would return true for shared libs while return false for static
81 // libs.
82 IsInstallableToApex() bool
Jiyong Park0ddfcd12018-12-11 01:35:25 +090083
84 // Mutate this module into one or more variants each of which is built
Jiyong Parkf760cae2020-02-12 07:53:12 +090085 // for an APEX marked via BuildForApexes().
Colin Cross43b92e02019-11-18 15:28:57 -080086 CreateApexVariations(mctx BottomUpMutatorContext) []Module
Jiyong Park0ddfcd12018-12-11 01:35:25 +090087
Jiyong Park127b40b2019-09-30 16:04:35 +090088 // Tests if this module is available for the specified APEX or ":platform"
89 AvailableFor(what string) bool
Jiyong Parka7bc8ad2019-10-15 15:20:07 +090090
91 // DepIsInSameApex tests if the other module 'dep' is installed to the same
92 // APEX as this module
93 DepIsInSameApex(ctx BaseModuleContext, dep Module) bool
Jooyung Han0c4e0162020-02-26 22:45:42 +090094
Jooyung Han74066602020-03-20 04:29:24 +090095 // Returns the highest version which is <= maxSdkVersion.
96 // For example, with maxSdkVersion is 10 and versionList is [9,11]
97 // it returns 9 as string
98 ChooseSdkVersion(versionList []string, maxSdkVersion int) (string, error)
Jiyong Park9d452992018-10-03 00:38:19 +090099}
100
101type ApexProperties struct {
Martin Stjernholm06ca82d2020-01-17 13:02:56 +0000102 // Availability of this module in APEXes. Only the listed APEXes can contain
103 // this module. If the module has stubs then other APEXes and the platform may
104 // access it through them (subject to visibility).
105 //
Jiyong Park127b40b2019-09-30 16:04:35 +0900106 // "//apex_available:anyapex" is a pseudo APEX name that matches to any APEX.
107 // "//apex_available:platform" refers to non-APEX partitions like "system.img".
Jiyong Park9a1e14e2020-02-13 02:30:45 +0900108 // Default is ["//apex_available:platform"].
Jiyong Park127b40b2019-09-30 16:04:35 +0900109 Apex_available []string
110
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800111 Info ApexInfo `blueprint:"mutated"`
Jiyong Park9d452992018-10-03 00:38:19 +0900112}
113
114// Provides default implementation for the ApexModule interface. APEX-aware
115// modules are expected to include this struct and call InitApexModule().
116type ApexModuleBase struct {
117 ApexProperties ApexProperties
118
119 canHaveApexVariants bool
Colin Crosscefa94bd2019-06-03 15:07:03 -0700120
121 apexVariationsLock sync.Mutex // protects apexVariations during parallel apexDepsMutator
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800122 apexVariations []ApexInfo
Jiyong Park9d452992018-10-03 00:38:19 +0900123}
124
125func (m *ApexModuleBase) apexModuleBase() *ApexModuleBase {
126 return m
127}
128
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800129func (m *ApexModuleBase) BuildForApexes(apexes []ApexInfo) {
Colin Crosscefa94bd2019-06-03 15:07:03 -0700130 m.apexVariationsLock.Lock()
131 defer m.apexVariationsLock.Unlock()
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800132nextApex:
133 for _, apex := range apexes {
134 for _, v := range m.apexVariations {
135 if v.ApexName == apex.ApexName {
136 continue nextApex
137 }
Jiyong Parkf760cae2020-02-12 07:53:12 +0900138 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800139 m.apexVariations = append(m.apexVariations, apex)
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900140 }
141}
142
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800143func (m *ApexModuleBase) ApexVariations() []ApexInfo {
Jiyong Parkf760cae2020-02-12 07:53:12 +0900144 return m.apexVariations
145}
146
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900147func (m *ApexModuleBase) ApexName() string {
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800148 return m.ApexProperties.Info.ApexName
Jiyong Park9d452992018-10-03 00:38:19 +0900149}
150
151func (m *ApexModuleBase) IsForPlatform() bool {
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800152 return m.ApexProperties.Info.ApexName == ""
Jiyong Park9d452992018-10-03 00:38:19 +0900153}
154
155func (m *ApexModuleBase) CanHaveApexVariants() bool {
156 return m.canHaveApexVariants
157}
158
159func (m *ApexModuleBase) IsInstallableToApex() bool {
160 // should be overriden if needed
161 return false
162}
163
Jiyong Park127b40b2019-09-30 16:04:35 +0900164const (
Jiyong Parkb02bb402019-12-03 00:43:57 +0900165 AvailableToPlatform = "//apex_available:platform"
Jiyong Park127b40b2019-09-30 16:04:35 +0900166 availableToAnyApex = "//apex_available:anyapex"
167)
168
Jiyong Parka90ca002019-10-07 15:47:24 +0900169func CheckAvailableForApex(what string, apex_available []string) bool {
170 if len(apex_available) == 0 {
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000171 // apex_available defaults to ["//apex_available:platform"],
172 // which means 'available to the platform but no apexes'.
173 return what == AvailableToPlatform
Jiyong Park127b40b2019-09-30 16:04:35 +0900174 }
Jiyong Parka90ca002019-10-07 15:47:24 +0900175 return InList(what, apex_available) ||
Jiyong Parkb02bb402019-12-03 00:43:57 +0900176 (what != AvailableToPlatform && InList(availableToAnyApex, apex_available))
Jiyong Parka90ca002019-10-07 15:47:24 +0900177}
178
179func (m *ApexModuleBase) AvailableFor(what string) bool {
180 return CheckAvailableForApex(what, m.ApexProperties.Apex_available)
Jiyong Park127b40b2019-09-30 16:04:35 +0900181}
182
Jiyong Parka7bc8ad2019-10-15 15:20:07 +0900183func (m *ApexModuleBase) DepIsInSameApex(ctx BaseModuleContext, dep Module) bool {
184 // By default, if there is a dependency from A to B, we try to include both in the same APEX,
185 // unless B is explicitly from outside of the APEX (i.e. a stubs lib). Thus, returning true.
186 // This is overridden by some module types like apex.ApexBundle, cc.Module, java.Module, etc.
187 return true
188}
189
Jooyung Han74066602020-03-20 04:29:24 +0900190func (m *ApexModuleBase) ChooseSdkVersion(versionList []string, maxSdkVersion int) (string, error) {
Jooyung Han0c4e0162020-02-26 22:45:42 +0900191 for i := range versionList {
192 ver, _ := strconv.Atoi(versionList[len(versionList)-i-1])
Jooyung Han74066602020-03-20 04:29:24 +0900193 if ver <= maxSdkVersion {
Jooyung Han0c4e0162020-02-26 22:45:42 +0900194 return versionList[len(versionList)-i-1], nil
195 }
196 }
Jooyung Han74066602020-03-20 04:29:24 +0900197 return "", fmt.Errorf("not found a version(<=%d) in versionList: %v", maxSdkVersion, versionList)
Jooyung Han0c4e0162020-02-26 22:45:42 +0900198}
199
Jiyong Park127b40b2019-09-30 16:04:35 +0900200func (m *ApexModuleBase) checkApexAvailableProperty(mctx BaseModuleContext) {
201 for _, n := range m.ApexProperties.Apex_available {
Jiyong Parkb02bb402019-12-03 00:43:57 +0900202 if n == AvailableToPlatform || n == availableToAnyApex {
Jiyong Park127b40b2019-09-30 16:04:35 +0900203 continue
204 }
Orion Hodson4b5438a2019-10-08 10:40:51 +0100205 if !mctx.OtherModuleExists(n) && !mctx.Config().AllowMissingDependencies() {
Jiyong Park127b40b2019-09-30 16:04:35 +0900206 mctx.PropertyErrorf("apex_available", "%q is not a valid module name", n)
207 }
208 }
209}
210
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800211type byApexName []ApexInfo
212
213func (a byApexName) Len() int { return len(a) }
214func (a byApexName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
215func (a byApexName) Less(i, j int) bool { return a[i].ApexName < a[j].ApexName }
216
Colin Cross43b92e02019-11-18 15:28:57 -0800217func (m *ApexModuleBase) CreateApexVariations(mctx BottomUpMutatorContext) []Module {
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900218 if len(m.apexVariations) > 0 {
Jiyong Park127b40b2019-09-30 16:04:35 +0900219 m.checkApexAvailableProperty(mctx)
Jiyong Park0f80c182020-01-31 02:49:53 +0900220
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800221 sort.Sort(byApexName(m.apexVariations))
Jiyong Park127b40b2019-09-30 16:04:35 +0900222 variations := []string{}
Jiyong Park0f80c182020-01-31 02:49:53 +0900223 variations = append(variations, "") // Original variation for platform
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800224 for _, apex := range m.apexVariations {
225 variations = append(variations, apex.ApexName)
226 }
Logan Chien3aeedc92018-12-26 15:32:21 +0800227
Jiyong Park3ff16992019-12-27 14:11:47 +0900228 defaultVariation := ""
229 mctx.SetDefaultDependencyVariation(&defaultVariation)
Jiyong Park0f80c182020-01-31 02:49:53 +0900230
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900231 modules := mctx.CreateVariations(variations...)
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800232 for i, mod := range modules {
Jiyong Park0f80c182020-01-31 02:49:53 +0900233 platformVariation := i == 0
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800234 if platformVariation && !mctx.Host() && !mod.(ApexModule).AvailableFor(AvailableToPlatform) {
235 mod.SkipInstall()
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900236 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800237 if !platformVariation {
238 mod.(ApexModule).apexModuleBase().ApexProperties.Info = m.apexVariations[i-1]
239 }
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900240 }
241 return modules
242 }
243 return nil
244}
245
246var apexData OncePer
247var apexNamesMapMutex sync.Mutex
Colin Cross571cccf2019-02-04 11:22:08 -0800248var apexNamesKey = NewOnceKey("apexNames")
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900249
250// This structure maintains the global mapping in between modules and APEXes.
251// Examples:
Jiyong Park25fc6a92018-11-18 18:02:45 +0900252//
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900253// apexNamesMap()["foo"]["bar"] == true: module foo is directly depended on by APEX bar
254// apexNamesMap()["foo"]["bar"] == false: module foo is indirectly depended on by APEX bar
255// apexNamesMap()["foo"]["bar"] doesn't exist: foo is not built for APEX bar
256func apexNamesMap() map[string]map[string]bool {
Colin Cross571cccf2019-02-04 11:22:08 -0800257 return apexData.Once(apexNamesKey, func() interface{} {
Jiyong Park25fc6a92018-11-18 18:02:45 +0900258 return make(map[string]map[string]bool)
259 }).(map[string]map[string]bool)
260}
261
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900262// Update the map to mark that a module named moduleName is directly or indirectly
Jiyong Parkf760cae2020-02-12 07:53:12 +0900263// depended on by the specified APEXes. Directly depending means that a module
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900264// is explicitly listed in the build definition of the APEX via properties like
265// native_shared_libs, java_libs, etc.
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800266func UpdateApexDependency(apexes []ApexInfo, moduleName string, directDep bool) {
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900267 apexNamesMapMutex.Lock()
268 defer apexNamesMapMutex.Unlock()
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800269 for _, apex := range apexes {
Jiyong Parkf760cae2020-02-12 07:53:12 +0900270 apexesForModule, ok := apexNamesMap()[moduleName]
271 if !ok {
272 apexesForModule = make(map[string]bool)
273 apexNamesMap()[moduleName] = apexesForModule
274 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -0800275 apexesForModule[apex.ApexName] = apexesForModule[apex.ApexName] || directDep
Jiyong Park25fc6a92018-11-18 18:02:45 +0900276 }
Jiyong Park25fc6a92018-11-18 18:02:45 +0900277}
278
Jooyung Han671f1ce2019-12-17 12:47:13 +0900279// TODO(b/146393795): remove this when b/146393795 is fixed
280func ClearApexDependency() {
281 m := apexNamesMap()
282 for k := range m {
283 delete(m, k)
284 }
285}
286
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900287// Tests whether a module named moduleName is directly depended on by an APEX
288// named apexName.
289func DirectlyInApex(apexName string, moduleName string) bool {
290 apexNamesMapMutex.Lock()
291 defer apexNamesMapMutex.Unlock()
292 if apexNames, ok := apexNamesMap()[moduleName]; ok {
293 return apexNames[apexName]
Jiyong Park25fc6a92018-11-18 18:02:45 +0900294 }
295 return false
296}
297
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +0000298type hostContext interface {
299 Host() bool
300}
301
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900302// Tests whether a module named moduleName is directly depended on by any APEX.
Nicolas Geoffrayc22c1bf2019-01-15 19:53:23 +0000303func DirectlyInAnyApex(ctx hostContext, moduleName string) bool {
304 if ctx.Host() {
305 // Host has no APEX.
306 return false
307 }
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900308 apexNamesMapMutex.Lock()
309 defer apexNamesMapMutex.Unlock()
310 if apexNames, ok := apexNamesMap()[moduleName]; ok {
311 for an := range apexNames {
312 if apexNames[an] {
Jiyong Park25fc6a92018-11-18 18:02:45 +0900313 return true
314 }
315 }
316 }
317 return false
318}
319
Jiyong Park0ddfcd12018-12-11 01:35:25 +0900320// Tests whether a module named module is depended on (including both
321// direct and indirect dependencies) by any APEX.
322func InAnyApex(moduleName string) bool {
323 apexNamesMapMutex.Lock()
324 defer apexNamesMapMutex.Unlock()
325 apexNames, ok := apexNamesMap()[moduleName]
326 return ok && len(apexNames) > 0
327}
328
329func GetApexesForModule(moduleName string) []string {
330 ret := []string{}
331 apexNamesMapMutex.Lock()
332 defer apexNamesMapMutex.Unlock()
333 if apexNames, ok := apexNamesMap()[moduleName]; ok {
334 for an := range apexNames {
335 ret = append(ret, an)
336 }
337 }
338 return ret
Jiyong Parkde866cb2018-12-07 23:08:36 +0900339}
340
Jiyong Park9d452992018-10-03 00:38:19 +0900341func InitApexModule(m ApexModule) {
342 base := m.apexModuleBase()
343 base.canHaveApexVariants = true
344
345 m.AddProperties(&base.ApexProperties)
346}