Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
// Copyright (C) 2019 The Android Open Source Project
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
|
|
|
package sdk
|
|
|
|
|
|
|
|
import (
|
2019-10-11 07:59:13 +02:00
|
|
|
"fmt"
|
2019-11-22 15:52:29 +01:00
|
|
|
"io"
|
2019-10-11 07:59:13 +02:00
|
|
|
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
"github.com/google/blueprint"
|
2019-11-06 08:03:32 +01:00
|
|
|
"github.com/google/blueprint/proptools"
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
|
|
|
|
"android/soong/android"
|
|
|
|
// This package doesn't depend on the apex package, but import it to make its mutators to be
|
|
|
|
// registered before mutators in this package. See RegisterPostDepsMutators for more details.
|
|
|
|
_ "android/soong/apex"
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
2019-11-04 04:23:40 +01:00
|
|
|
pctx.Import("android/soong/android")
|
2019-11-29 21:17:53 +01:00
|
|
|
pctx.Import("android/soong/java/config")
|
|
|
|
|
2021-03-09 23:59:28 +01:00
|
|
|
registerSdkBuildComponents(android.InitRegistrationContext)
|
|
|
|
}
|
|
|
|
|
|
|
|
func registerSdkBuildComponents(ctx android.RegistrationContext) {
|
|
|
|
ctx.RegisterModuleType("sdk", SdkModuleFactory)
|
|
|
|
ctx.RegisterModuleType("sdk_snapshot", SnapshotModuleFactory)
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type sdk struct {
|
|
|
|
android.ModuleBase
|
|
|
|
android.DefaultableModuleBase
|
|
|
|
|
2019-12-13 12:22:16 +01:00
|
|
|
// The dynamically generated information about the registered SdkMemberType
|
|
|
|
dynamicSdkMemberTypes *dynamicSdkMemberTypes
|
|
|
|
|
2021-07-14 13:05:16 +02:00
|
|
|
// The dynamically created instance of the properties struct containing the sdk member type
|
2019-12-13 12:22:16 +01:00
|
|
|
// list properties, e.g. java_libs.
|
|
|
|
dynamicMemberTypeListProperties interface{}
|
|
|
|
|
2021-07-14 13:08:37 +02:00
|
|
|
// The dynamically generated information about the registered SdkMemberTrait
|
|
|
|
dynamicSdkMemberTraits *dynamicSdkMemberTraits
|
|
|
|
|
|
|
|
// The dynamically created instance of the properties struct containing the sdk member trait
|
|
|
|
// list properties.
|
|
|
|
dynamicMemberTraitListProperties interface{}
|
|
|
|
|
2021-04-24 13:16:36 +02:00
|
|
|
// Information about the OsType specific member variants depended upon by this variant.
|
2020-02-25 20:26:33 +01:00
|
|
|
//
|
2020-03-20 18:50:07 +01:00
|
|
|
// Set by OsType specific variants in the collectMembers() method and used by the
|
|
|
|
// CommonOS variant when building the snapshot. That work is all done on separate
|
|
|
|
// calls to the sdk.GenerateAndroidBuildActions method which is guaranteed to be
|
|
|
|
// called for the OsType specific variants before the CommonOS variant (because
|
|
|
|
// the latter depends on the former).
|
2021-04-24 13:16:36 +02:00
|
|
|
memberVariantDeps []sdkMemberVariantDep
|
2020-02-25 20:26:33 +01:00
|
|
|
|
2020-03-20 18:50:07 +01:00
|
|
|
// The multilib variants that are used by this sdk variant.
|
|
|
|
multilibUsages multilibUsage
|
|
|
|
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
properties sdkProperties
|
2019-10-11 07:59:13 +02:00
|
|
|
|
2019-11-04 04:23:40 +01:00
|
|
|
snapshotFile android.OptionalPath
|
2019-11-26 19:02:20 +01:00
|
|
|
|
2022-05-06 11:38:02 +02:00
|
|
|
infoFile android.OptionalPath
|
|
|
|
|
2019-11-26 19:02:20 +01:00
|
|
|
// The builder, preserved for testing.
|
|
|
|
builderForTests *snapshotBuilder
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
type sdkProperties struct {
|
2019-10-11 07:59:13 +02:00
|
|
|
Snapshot bool `blueprint:"mutated"`
|
2019-12-16 18:21:27 +01:00
|
|
|
|
|
|
|
// True if this is a module_exports (or module_exports_snapshot) module type.
|
|
|
|
Module_exports bool `blueprint:"mutated"`
|
2020-09-29 17:01:08 +02:00
|
|
|
|
|
|
|
// The additional visibility to add to the prebuilt modules to allow them to
|
|
|
|
// reference each other.
|
|
|
|
//
|
|
|
|
// This can only be used to widen the visibility of the members:
|
|
|
|
//
|
|
|
|
// * Specifying //visibility:public here will make all members visible and
|
|
|
|
// essentially ignore their own visibility.
|
|
|
|
// * Specifying //visibility:private here is an error.
|
|
|
|
// * Specifying any other rule here will add it to the members visibility and
|
|
|
|
// be output to the member prebuilt in the snapshot. Duplicates will be
|
|
|
|
// dropped. Adding a rule to members that have //visibility:private will
|
|
|
|
// cause the //visibility:private to be discarded.
|
|
|
|
Prebuilt_visibility []string
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// sdk defines an SDK which is a logical group of modules (e.g. native libs, headers, java libs, etc.)
|
|
|
|
// which Mainline modules like APEX can choose to build with.
|
2019-12-16 18:21:27 +01:00
|
|
|
func SdkModuleFactory() android.Module {
|
2019-12-16 18:43:48 +01:00
|
|
|
return newSdkModule(false)
|
2019-12-16 18:21:27 +01:00
|
|
|
}
|
2019-12-13 12:22:16 +01:00
|
|
|
|
2019-12-16 18:43:48 +01:00
|
|
|
func newSdkModule(moduleExports bool) *sdk {
|
2019-12-16 18:21:27 +01:00
|
|
|
s := &sdk{}
|
2019-12-16 18:43:48 +01:00
|
|
|
s.properties.Module_exports = moduleExports
|
2019-12-13 12:22:16 +01:00
|
|
|
// Get the dynamic sdk member type data for the currently registered sdk member types.
|
2021-09-22 12:49:47 +02:00
|
|
|
sdkMemberTypeKey, sdkMemberTypes := android.RegisteredSdkMemberTypes(moduleExports)
|
|
|
|
s.dynamicSdkMemberTypes = getDynamicSdkMemberTypes(sdkMemberTypeKey, sdkMemberTypes)
|
2019-12-13 12:22:16 +01:00
|
|
|
// Create an instance of the dynamically created struct that contains all the
|
|
|
|
// properties for the member type specific list properties.
|
2021-07-14 13:05:16 +02:00
|
|
|
s.dynamicMemberTypeListProperties = s.dynamicSdkMemberTypes.createMemberTypeListProperties()
|
2021-07-14 13:08:37 +02:00
|
|
|
|
2021-09-22 12:49:47 +02:00
|
|
|
sdkMemberTraitsKey, sdkMemberTraits := android.RegisteredSdkMemberTraits()
|
|
|
|
s.dynamicSdkMemberTraits = getDynamicSdkMemberTraits(sdkMemberTraitsKey, sdkMemberTraits)
|
2021-07-14 13:08:37 +02:00
|
|
|
// Create an instance of the dynamically created struct that contains all the properties for the
|
|
|
|
// member trait specific list properties.
|
|
|
|
s.dynamicMemberTraitListProperties = s.dynamicSdkMemberTraits.createMemberTraitListProperties()
|
|
|
|
|
|
|
|
// Create a wrapper around the dynamic trait specific properties so that they have to be
|
|
|
|
// specified within a traits:{} section in the .bp file.
|
|
|
|
traitsWrapper := struct {
|
|
|
|
Traits interface{}
|
|
|
|
}{s.dynamicMemberTraitListProperties}
|
|
|
|
|
|
|
|
s.AddProperties(&s.properties, s.dynamicMemberTypeListProperties, &traitsWrapper)
|
2020-09-29 17:01:08 +02:00
|
|
|
|
|
|
|
// Make sure that the prebuilt visibility property is verified for errors.
|
|
|
|
android.AddVisibilityProperty(s, "prebuilt_visibility", &s.properties.Prebuilt_visibility)
|
2020-02-25 20:26:33 +01:00
|
|
|
android.InitCommonOSAndroidMultiTargetsArchModule(s, android.HostAndDeviceSupported, android.MultilibCommon)
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
android.InitDefaultableModule(s)
|
2019-11-06 08:03:32 +01:00
|
|
|
android.AddLoadHook(s, func(ctx android.LoadHookContext) {
|
|
|
|
type props struct {
|
|
|
|
Compile_multilib *string
|
|
|
|
}
|
|
|
|
p := &props{Compile_multilib: proptools.StringPtr("both")}
|
2020-06-30 21:34:00 +02:00
|
|
|
ctx.PrependProperties(p)
|
2019-11-06 08:03:32 +01:00
|
|
|
})
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2022-05-24 22:10:05 +02:00
|
|
|
// sdk_snapshot is a snapshot of an SDK. This is an auto-generated module.
|
2019-10-11 07:59:13 +02:00
|
|
|
func SnapshotModuleFactory() android.Module {
|
2019-12-16 18:43:48 +01:00
|
|
|
s := newSdkModule(false)
|
2019-12-16 18:21:27 +01:00
|
|
|
s.properties.Snapshot = true
|
2019-10-11 07:59:13 +02:00
|
|
|
return s
|
|
|
|
}
|
|
|
|
|
2021-07-14 13:05:16 +02:00
|
|
|
func (s *sdk) memberTypeListProperties() []*sdkMemberTypeListProperty {
|
|
|
|
return s.dynamicSdkMemberTypes.memberTypeListProperties
|
2020-01-20 19:16:30 +01:00
|
|
|
}
|
|
|
|
|
2021-07-14 13:05:16 +02:00
|
|
|
func (s *sdk) memberTypeListProperty(memberType android.SdkMemberType) *sdkMemberTypeListProperty {
|
2021-04-24 01:47:29 +02:00
|
|
|
return s.dynamicSdkMemberTypes.memberTypeToProperty[memberType]
|
|
|
|
}
|
|
|
|
|
2021-07-14 13:08:37 +02:00
|
|
|
// memberTraitListProperties returns the list of *sdkMemberTraitListProperty instances for this sdk.
|
|
|
|
func (s *sdk) memberTraitListProperties() []*sdkMemberTraitListProperty {
|
|
|
|
return s.dynamicSdkMemberTraits.memberTraitListProperties
|
|
|
|
}
|
|
|
|
|
2019-10-11 07:59:13 +02:00
|
|
|
func (s *sdk) snapshot() bool {
|
|
|
|
return s.properties.Snapshot
|
|
|
|
}
|
|
|
|
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
func (s *sdk) GenerateAndroidBuildActions(ctx android.ModuleContext) {
|
2020-02-25 20:26:33 +01:00
|
|
|
if s.snapshot() {
|
2019-11-04 04:23:40 +01:00
|
|
|
// We don't need to create a snapshot out of sdk_snapshot.
|
|
|
|
// That doesn't make sense. We need a snapshot to create sdk_snapshot.
|
2020-02-25 20:26:33 +01:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// This method is guaranteed to be called on OsType specific variants before it is called
|
|
|
|
// on their corresponding CommonOS variant.
|
|
|
|
if !s.IsCommonOSVariant() {
|
2020-03-20 18:50:07 +01:00
|
|
|
// Update the OsType specific sdk variant with information about its members.
|
|
|
|
s.collectMembers(ctx)
|
2020-02-25 20:26:33 +01:00
|
|
|
} else {
|
|
|
|
// Get the OsType specific variants on which the CommonOS depends.
|
|
|
|
osSpecificVariants := android.GetOsSpecificVariantsOfCommonOSVariant(ctx)
|
|
|
|
var sdkVariants []*sdk
|
|
|
|
for _, m := range osSpecificVariants {
|
|
|
|
if sdkVariant, ok := m.(*sdk); ok {
|
|
|
|
sdkVariants = append(sdkVariants, sdkVariant)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Generate the snapshot from the member info.
|
2022-05-06 11:38:02 +02:00
|
|
|
s.buildSnapshot(ctx, sdkVariants)
|
2019-11-04 04:23:40 +01:00
|
|
|
}
|
2019-10-11 07:59:13 +02:00
|
|
|
}
|
|
|
|
|
2019-12-03 05:24:29 +01:00
|
|
|
func (s *sdk) AndroidMkEntries() []android.AndroidMkEntries {
|
2022-05-06 11:38:02 +02:00
|
|
|
if !s.snapshotFile.Valid() != !s.infoFile.Valid() {
|
|
|
|
panic("Snapshot (%q) and info file (%q) should both be set or neither should be set.")
|
|
|
|
} else if !s.snapshotFile.Valid() {
|
2019-12-03 05:24:29 +01:00
|
|
|
return []android.AndroidMkEntries{}
|
2019-11-04 04:23:40 +01:00
|
|
|
}
|
|
|
|
|
2019-12-03 05:24:29 +01:00
|
|
|
return []android.AndroidMkEntries{android.AndroidMkEntries{
|
2019-11-04 04:23:40 +01:00
|
|
|
Class: "FAKE",
|
|
|
|
OutputFile: s.snapshotFile,
|
2022-05-06 11:38:02 +02:00
|
|
|
DistFiles: android.MakeDefaultDistFiles(s.snapshotFile.Path(), s.infoFile.Path()),
|
2019-11-04 04:23:40 +01:00
|
|
|
Include: "$(BUILD_PHONY_PACKAGE)",
|
2019-11-22 15:52:29 +01:00
|
|
|
ExtraFooters: []android.AndroidMkExtraFootersFunc{
|
2020-12-07 19:23:54 +01:00
|
|
|
func(w io.Writer, name, prefix, moduleDir string) {
|
2019-11-22 15:52:29 +01:00
|
|
|
// Allow the sdk to be built by simply passing its name on the command line.
|
|
|
|
fmt.Fprintln(w, ".PHONY:", s.Name())
|
|
|
|
fmt.Fprintln(w, s.Name()+":", s.snapshotFile.String())
|
2022-05-06 11:38:02 +02:00
|
|
|
|
|
|
|
// Allow the sdk info to be built by simply passing its name on the command line.
|
|
|
|
infoTarget := s.Name() + ".info"
|
|
|
|
fmt.Fprintln(w, ".PHONY:", infoTarget)
|
|
|
|
fmt.Fprintln(w, infoTarget+":", s.infoFile.String())
|
2019-11-22 15:52:29 +01:00
|
|
|
},
|
|
|
|
},
|
2019-12-03 05:24:29 +01:00
|
|
|
}}
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
}
|
|
|
|
|
2021-07-14 13:08:37 +02:00
|
|
|
// gatherTraits gathers the traits from the dynamically generated trait specific properties.
|
|
|
|
//
|
|
|
|
// Returns a map from member name to the set of required traits.
|
|
|
|
func (s *sdk) gatherTraits() map[string]android.SdkMemberTraitSet {
|
|
|
|
traitListByMember := map[string][]android.SdkMemberTrait{}
|
|
|
|
for _, memberListProperty := range s.memberTraitListProperties() {
|
|
|
|
names := memberListProperty.getter(s.dynamicMemberTraitListProperties)
|
|
|
|
for _, name := range names {
|
|
|
|
traitListByMember[name] = append(traitListByMember[name], memberListProperty.memberTrait)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
traitSetByMember := map[string]android.SdkMemberTraitSet{}
|
|
|
|
for name, list := range traitListByMember {
|
|
|
|
traitSetByMember[name] = android.NewSdkMemberTraitSet(list)
|
|
|
|
}
|
|
|
|
|
|
|
|
return traitSetByMember
|
|
|
|
}
|
|
|
|
|
2021-07-14 11:29:36 +02:00
|
|
|
// newDependencyContext creates a new SdkDependencyContext for this sdk.
|
|
|
|
func (s *sdk) newDependencyContext(mctx android.BottomUpMutatorContext) android.SdkDependencyContext {
|
2021-07-14 13:08:37 +02:00
|
|
|
traits := s.gatherTraits()
|
|
|
|
|
2021-07-14 11:29:36 +02:00
|
|
|
return &dependencyContext{
|
|
|
|
BottomUpMutatorContext: mctx,
|
2021-07-14 13:08:37 +02:00
|
|
|
requiredTraits: traits,
|
2021-07-14 11:29:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type dependencyContext struct {
|
|
|
|
android.BottomUpMutatorContext
|
2021-07-14 13:08:37 +02:00
|
|
|
|
|
|
|
// Map from member name to the set of traits that the sdk requires the member provides.
|
|
|
|
requiredTraits map[string]android.SdkMemberTraitSet
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *dependencyContext) RequiredTraits(name string) android.SdkMemberTraitSet {
|
|
|
|
if s, ok := d.requiredTraits[name]; ok {
|
|
|
|
return s
|
|
|
|
} else {
|
|
|
|
return android.EmptySdkMemberTraitSet()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *dependencyContext) RequiresTrait(name string, trait android.SdkMemberTrait) bool {
|
|
|
|
return d.RequiredTraits(name).Contains(trait)
|
2021-07-14 11:29:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
var _ android.SdkDependencyContext = (*dependencyContext)(nil)
|
|
|
|
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
type dependencyTag struct {
|
|
|
|
blueprint.BaseDependencyTag
|
|
|
|
}
|
|
|
|
|
2020-07-07 04:22:21 +02:00
|
|
|
// Mark this tag so dependencies that use it are excluded from APEX contents.
|
|
|
|
func (t dependencyTag) ExcludeFromApexContents() {}
|
|
|
|
|
|
|
|
var _ android.ExcludeFromApexContentsTag = dependencyTag{}
|
|
|
|
|
2022-11-23 18:59:00 +01:00
|
|
|
func (s *sdk) DepsMutator(mctx android.BottomUpMutatorContext) {
|
|
|
|
// Add dependencies from non CommonOS variants to the sdk member variants.
|
|
|
|
if s.IsCommonOSVariant() {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
ctx := s.newDependencyContext(mctx)
|
|
|
|
for _, memberListProperty := range s.memberTypeListProperties() {
|
|
|
|
if memberListProperty.getter == nil {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
names := memberListProperty.getter(s.dynamicMemberTypeListProperties)
|
|
|
|
if len(names) > 0 {
|
|
|
|
memberType := memberListProperty.memberType
|
|
|
|
|
|
|
|
// Verify that the member type supports the specified traits.
|
|
|
|
supportedTraits := memberType.SupportedTraits()
|
|
|
|
for _, name := range names {
|
|
|
|
requiredTraits := ctx.RequiredTraits(name)
|
|
|
|
unsupportedTraits := requiredTraits.Subtract(supportedTraits)
|
|
|
|
if !unsupportedTraits.Empty() {
|
|
|
|
ctx.ModuleErrorf("sdk member %q has traits %s that are unsupported by its member type %q",
|
|
|
|
name, unsupportedTraits, memberType.SdkPropertyName())
|
2020-02-27 14:29:56 +01:00
|
|
|
}
|
2020-02-20 14:39:41 +01:00
|
|
|
}
|
2022-11-23 18:59:00 +01:00
|
|
|
|
|
|
|
// Add dependencies using the appropriate tag.
|
|
|
|
tag := memberListProperty.dependencyTag
|
|
|
|
memberType.AddDependencies(ctx, tag, names)
|
Introduce module type 'sdk'
This change introduces a new module type named 'sdk'. It is a logical
group of prebuilt modules that together provide a context (e.g. APIs)
in which Mainline modules (such as APEXes) are built.
A prebuilt module (e.g. java_import) can join an sdk by adding it to the
sdk module as shown below:
sdk {
name: "mysdk#20",
java_libs: ["myjavalib_mysdk_20"],
}
java_import {
name: "myjavalib_mysdk_20",
srcs: ["myjavalib-v20.jar"],
sdk_member_name: "myjavalib",
}
sdk {
name: "mysdk#21",
java_libs: ["myjavalib_mysdk_21"],
}
java_import {
name: "myjavalib_mysdk_21",
srcs: ["myjavalib-v21.jar"],
sdk_member_name: "myjavalib",
}
java_library {
name: "myjavalib",
srcs: ["**/*/*.java"],
}
An APEX can specify the SDK(s) that it wants to build with via the new
'uses_sdks' property.
apex {
name: "myapex",
java_libs: ["libX", "libY"],
uses_sdks: ["mysdk#20"],
}
With this, libX, libY, and their transitive dependencies are all built
with the version 20 of myjavalib (the first java_import module) instead
of the other one (which is for version 21) and java_library having the
same name (which is for ToT).
Bug: 138182343
Test: m (sdk_test.go added)
Change-Id: I7e14c524a7d6a0d9f575fb20822080f39818c01e
2019-07-17 13:08:41 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|