openkylin
/
platform_build_soong
mirror of https://gitee.com/openkylin/platform_build_soong.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Add HiddenAPIScope to replace use of SdkKind 

Previously, the hidden API processing used SdkKind to identify the API
scopes, e.g. public, system, etc. that are of interest for hidden API
processing. Unfortunately, there is a mismatch between the SdkKind and
what hidden API processing needs. e.g. SdkKind includes values that are
not used by hidden API processing and hidden API processing needs
additional API scope specific information not provided by SdkKind. The
apiScope struct used in sdk_library.go is also not a suitable
representation for similar reasons.

This change adds the HiddenAPIScope (following a similar approach as
apiScope) that rectifies that and uses it as a replacement for SdkKind
in most parts of the hidden API processing. The SdkKind is still used
for retrieving information from java_sdk_library[_import] modules.

Follow up changes will extend the HiddenAPIScope with more information.

Bug: 179354495
Test: m out/soong/hiddenapi/hiddenapi-flags.csv
      - make sure that this change has no effect on the generated flags.
Merged-In: I97968f58535121652852b8d25217aa288afd2bfd
Change-Id: I97968f58535121652852b8d25217aa288afd2bfd
(cherry picked from commit 31fad800a7a44ef2edda5d4051335f28d514139a)
This commit is contained in:
Paul Duffin 2021-06-18 18:14:25 +01:00
parent 2f7ccd56a8
commit 05bbff90bd
6 changed files with 182 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
apex/bootclasspath_fragment_test.go
View File

@ -216,9 +216,9 @@ func TestBootclasspathFragments_FragmentDependency(t *testing.T) {
`,
)
checkSdkKindStubs := func(message string, info java.HiddenAPIInfo, kind android.SdkKind, expectedPaths ...string) {
checkAPIScopeStubs := func(message string, info java.HiddenAPIInfo, apiScope *java.HiddenAPIScope, expectedPaths ...string) {
t.Helper()
android.AssertPathsRelativeToTopEquals(t, fmt.Sprintf("%s %s", message, kind), expectedPaths, info.TransitiveStubDexJarsByKind[kind])
android.AssertPathsRelativeToTopEquals(t, fmt.Sprintf("%s %s", message, apiScope), expectedPaths, info.TransitiveStubDexJarsByScope[apiScope])
}
// Check stub dex paths exported by art.
@ -229,10 +229,10 @@ func TestBootclasspathFragments_FragmentDependency(t *testing.T) {
bazSystemStubs := "out/soong/.intermediates/baz.stubs.system/android_common/dex/baz.stubs.system.jar"
bazTestStubs := "out/soong/.intermediates/baz.stubs.test/android_common/dex/baz.stubs.test.jar"
checkSdkKindStubs("art", artInfo, android.SdkPublic, bazPublicStubs)
checkSdkKindStubs("art", artInfo, android.SdkSystem, bazSystemStubs)
checkSdkKindStubs("art", artInfo, android.SdkTest, bazTestStubs)
checkSdkKindStubs("art", artInfo, android.SdkCorePlatform)
checkAPIScopeStubs("art", artInfo, java.PublicHiddenAPIScope, bazPublicStubs)
checkAPIScopeStubs("art", artInfo, java.SystemHiddenAPIScope, bazSystemStubs)
checkAPIScopeStubs("art", artInfo, java.TestHiddenAPIScope, bazTestStubs)
checkAPIScopeStubs("art", artInfo, java.CorePlatformHiddenAPIScope)
// Check stub dex paths exported by other.
otherFragment := result.Module("other-bootclasspath-fragment", "android_common")
@ -241,10 +241,10 @@ func TestBootclasspathFragments_FragmentDependency(t *testing.T) {
fooPublicStubs := "out/soong/.intermediates/foo.stubs/android_common/dex/foo.stubs.jar"
fooSystemStubs := "out/soong/.intermediates/foo.stubs.system/android_common/dex/foo.stubs.system.jar"
checkSdkKindStubs("other", otherInfo, android.SdkPublic, bazPublicStubs, fooPublicStubs)
checkSdkKindStubs("other", otherInfo, android.SdkSystem, bazSystemStubs, fooSystemStubs)
checkSdkKindStubs("other", otherInfo, android.SdkTest, bazTestStubs, fooSystemStubs)
checkSdkKindStubs("other", otherInfo, android.SdkCorePlatform)
checkAPIScopeStubs("other", otherInfo, java.PublicHiddenAPIScope, bazPublicStubs, fooPublicStubs)
checkAPIScopeStubs("other", otherInfo, java.SystemHiddenAPIScope, bazSystemStubs, fooSystemStubs)
checkAPIScopeStubs("other", otherInfo, java.TestHiddenAPIScope, bazTestStubs, fooSystemStubs)
checkAPIScopeStubs("other", otherInfo, java.CorePlatformHiddenAPIScope)
}
func checkBootclasspathFragment(t *testing.T, result *android.TestResult, moduleName, variantName string, expectedConfiguredModules string, expectedBootclasspathFragmentFiles string) {

12
java/bootclasspath.go
View File

@ -225,13 +225,13 @@ type BootclasspathAPIProperties struct {
Core_platform_api BootclasspathNestedAPIProperties
}
// sdkKindToStubLibs calculates the stub library modules for each relevant android.SdkKind from the
// apiScopeToStubLibs calculates the stub library modules for each relevant *HiddenAPIScope from the
// Stub_libs properties.
func (p BootclasspathAPIProperties) sdkKindToStubLibs() map[android.SdkKind][]string {
m := map[android.SdkKind][]string{}
for _, kind := range []android.SdkKind{android.SdkPublic, android.SdkSystem, android.SdkTest} {
m[kind] = p.Api.Stub_libs
func (p BootclasspathAPIProperties) apiScopeToStubLibs() map[*HiddenAPIScope][]string {
m := map[*HiddenAPIScope][]string{}
for _, apiScope := range hiddenAPISdkLibrarySupportedScopes {
m[apiScope] = p.Api.Stub_libs
}
m[android.SdkCorePlatform] = p.Core_platform_api.Stub_libs
m[CorePlatformHiddenAPIScope] = p.Core_platform_api.Stub_libs
return m
}

7
java/bootclasspath_fragment.go
View File

@ -121,6 +121,7 @@ type bootclasspathFragmentProperties struct {
BootclasspathFragmentCoverageAffectedProperties
Coverage BootclasspathFragmentCoverageAffectedProperties
// Hidden API related properties.
Hidden_api HiddenAPIFlagFileProperties
// Properties that allow a fragment to depend on other fragments. This is needed for hidden API
@ -375,7 +376,7 @@ func (b *BootclasspathFragmentModule) ComponentDepsMutator(ctx android.BottomUpM
func (b *BootclasspathFragmentModule) DepsMutator(ctx android.BottomUpMutatorContext) {
// Add dependencies onto all the modules that provide the API stubs for classes on this
// bootclasspath fragment.
hiddenAPIAddStubLibDependencies(ctx, b.properties.sdkKindToStubLibs())
hiddenAPIAddStubLibDependencies(ctx, b.properties.apiScopeToStubLibs())
if SkipDexpreoptBootJars(ctx) {
return
@ -588,7 +589,7 @@ func (b *BootclasspathFragmentModule) generateHiddenAPIBuildActions(ctx android.
// Other bootclasspath_fragments that depend on this need the transitive set of stub dex jars
// from this to resolve any references from their code to classes provided by this fragment
// and the fragments this depends upon.
TransitiveStubDexJarsByKind: input.transitiveStubDexJarsByKind(),
TransitiveStubDexJarsByScope: input.transitiveStubDexJarsByScope(),
}
// The monolithic hidden API processing also needs access to all the output files produced by
@ -633,7 +634,7 @@ func (b *BootclasspathFragmentModule) createHiddenAPIFlagInput(ctx android.Modul
input.extractFlagFilesFromProperties(ctx, &b.properties.Hidden_api)
// Store the stub dex jars from this module's fragment dependencies.
input.DependencyStubDexJarsByKind = dependencyHiddenApiInfo.TransitiveStubDexJarsByKind
input.DependencyStubDexJarsByScope = dependencyHiddenApiInfo.TransitiveStubDexJarsByScope
return input
}

8
java/bootclasspath_fragment_test.go
View File

@ -245,17 +245,17 @@ func TestBootclasspathFragment_StubLibs(t *testing.T) {
otherPublicStubsJar := "out/soong/.intermediates/myothersdklibrary.stubs/android_common/dex/myothersdklibrary.stubs.jar"
// Check that SdkPublic uses public stubs for all sdk libraries.
android.AssertPathsRelativeToTopEquals(t, "public dex stubs jar", []string{otherPublicStubsJar, publicStubsJar, stubsJar}, info.TransitiveStubDexJarsByKind[android.SdkPublic])
android.AssertPathsRelativeToTopEquals(t, "public dex stubs jar", []string{otherPublicStubsJar, publicStubsJar, stubsJar}, info.TransitiveStubDexJarsByScope[PublicHiddenAPIScope])
// Check that SdkSystem uses system stubs for mysdklibrary and public stubs for myothersdklibrary
// as it does not provide system stubs.
android.AssertPathsRelativeToTopEquals(t, "system dex stubs jar", []string{otherPublicStubsJar, systemStubsJar, stubsJar}, info.TransitiveStubDexJarsByKind[android.SdkSystem])
android.AssertPathsRelativeToTopEquals(t, "system dex stubs jar", []string{otherPublicStubsJar, systemStubsJar, stubsJar}, info.TransitiveStubDexJarsByScope[SystemHiddenAPIScope])
// Check that SdkTest also uses system stubs for mysdklibrary as it does not provide test stubs
// and public stubs for myothersdklibrary as it does not provide test stubs either.
android.AssertPathsRelativeToTopEquals(t, "test dex stubs jar", []string{otherPublicStubsJar, systemStubsJar, stubsJar}, info.TransitiveStubDexJarsByKind[android.SdkTest])
android.AssertPathsRelativeToTopEquals(t, "test dex stubs jar", []string{otherPublicStubsJar, systemStubsJar, stubsJar}, info.TransitiveStubDexJarsByScope[TestHiddenAPIScope])
// Check that SdkCorePlatform uses public stubs from the mycoreplatform library.
corePlatformStubsJar := "out/soong/.intermediates/mycoreplatform.stubs/android_common/dex/mycoreplatform.stubs.jar"
android.AssertPathsRelativeToTopEquals(t, "core platform dex stubs jar", []string{corePlatformStubsJar}, info.TransitiveStubDexJarsByKind[android.SdkCorePlatform])
android.AssertPathsRelativeToTopEquals(t, "core platform dex stubs jar", []string{corePlatformStubsJar}, info.TransitiveStubDexJarsByScope[CorePlatformHiddenAPIScope])
}

244
java/hiddenapi_modular.go
View File

@ -25,9 +25,97 @@ import (
// Contains support for processing hiddenAPI in a modular fashion.
// HiddenAPIScope encapsulates all the information that the hidden API processing needs about API
// scopes, i.e. what is called android.SdkKind and apiScope. It does not just use those as they do
// not provide the information needed by hidden API processing.
type HiddenAPIScope struct {
// The name of the scope, used for debug purposes.
name string
// The corresponding android.SdkKind, used for retrieving paths from java_sdk_library* modules.
sdkKind android.SdkKind
// The option needed to passed to "hiddenapi list".
hiddenAPIListOption string
}
// initHiddenAPIScope initializes the scope.
func initHiddenAPIScope(apiScope *HiddenAPIScope) *HiddenAPIScope {
return apiScope
}
func (l *HiddenAPIScope) String() string {
return fmt.Sprintf("HiddenAPIScope{%s}", l.name)
}
var (
PublicHiddenAPIScope = initHiddenAPIScope(&HiddenAPIScope{
name: "public",
sdkKind: android.SdkPublic,
hiddenAPIListOption: "--public-stub-classpath",
})
SystemHiddenAPIScope = initHiddenAPIScope(&HiddenAPIScope{
name: "system",
sdkKind: android.SdkSystem,
hiddenAPIListOption: "--system-stub-classpath",
})
TestHiddenAPIScope = initHiddenAPIScope(&HiddenAPIScope{
name: "test",
sdkKind: android.SdkTest,
hiddenAPIListOption: "--test-stub-classpath",
})
CorePlatformHiddenAPIScope = initHiddenAPIScope(&HiddenAPIScope{
name: "core-platform",
sdkKind: android.SdkCorePlatform,
hiddenAPIListOption: "--core-platform-stub-classpath",
})
// hiddenAPIRelevantSdkKinds lists all the android.SdkKind instances that are needed by the hidden
// API processing.
//
// These are roughly in order from narrowest API surface to widest. Widest means the API stubs
// with the biggest API surface, e.g. test is wider than system is wider than public.
//
// Core platform is considered wider than system because those modules that provide core platform
// APIs either do not have any system APIs at all, or if they do it is because the core platform
// API is being converted to system APIs. In either case the system API is a subset of core
// platform API.
//
// This is not strictly in order from narrowest to widest as the Test API is wider than system but
// is neither wider or narrower than the core platform API. However, this works well enough at the
// moment.
// TODO(b/191644675): Correctly reflect the sub/superset relationships between APIs.
hiddenAPIScopes = []*HiddenAPIScope{
PublicHiddenAPIScope,
SystemHiddenAPIScope,
TestHiddenAPIScope,
CorePlatformHiddenAPIScope,
}
// The HiddenAPIScope instances that are supported by a java_sdk_library.
//
// CorePlatformHiddenAPIScope is not used as the java_sdk_library does not have special support
// for core_platform API, instead it is implemented as a customized form of PublicHiddenAPIScope.
hiddenAPISdkLibrarySupportedScopes = []*HiddenAPIScope{
PublicHiddenAPIScope,
SystemHiddenAPIScope,
TestHiddenAPIScope,
}
// The HiddenAPIScope instances that are supported by the `hiddenapi list`.
hiddenAPIFlagScopes = []*HiddenAPIScope{
PublicHiddenAPIScope,
SystemHiddenAPIScope,
TestHiddenAPIScope,
CorePlatformHiddenAPIScope,
}
)
type hiddenAPIStubsDependencyTag struct {
blueprint.BaseDependencyTag
sdkKind android.SdkKind
// The api scope for which this dependency was added.
apiScope *HiddenAPIScope
}
func (b hiddenAPIStubsDependencyTag) ExcludeFromApexContents() {
@ -65,24 +153,9 @@ var _ android.ReplaceSourceWithPrebuilt = hiddenAPIStubsDependencyTag{}
var _ android.ExcludeFromApexContentsTag = hiddenAPIStubsDependencyTag{}
var _ android.SdkMemberTypeDependencyTag = hiddenAPIStubsDependencyTag{}
// hiddenAPIRelevantSdkKinds lists all the android.SdkKind instances that are needed by the hidden
// API processing.
//
// These are in order from narrowest API surface to widest. Widest means the API stubs with the
// biggest API surface, e.g. test is wider than system is wider than public. Core platform is
// considered wider than test even though it has no relationship with test because the libraries
// that provide core platform API don't provide test. While the core platform API is being converted
// to a system API the system API is still a subset of core platform.
var hiddenAPIRelevantSdkKinds = []android.SdkKind{
android.SdkPublic,
android.SdkSystem,
android.SdkTest,
android.SdkCorePlatform,
}
// hiddenAPIComputeMonolithicStubLibModules computes the set of module names that provide stubs
// needed to produce the hidden API monolithic stub flags file.
func hiddenAPIComputeMonolithicStubLibModules(config android.Config) map[android.SdkKind][]string {
func hiddenAPIComputeMonolithicStubLibModules(config android.Config) map[*HiddenAPIScope][]string {
var publicStubModules []string
var systemStubModules []string
var testStubModules []string
@ -115,22 +188,22 @@ func hiddenAPIComputeMonolithicStubLibModules(config android.Config) map[android
testStubModules = append(testStubModules, "jacoco-stubs")
}
m := map[android.SdkKind][]string{}
m[android.SdkPublic] = publicStubModules
m[android.SdkSystem] = systemStubModules
m[android.SdkTest] = testStubModules
m[android.SdkCorePlatform] = corePlatformStubModules
m := map[*HiddenAPIScope][]string{}
m[PublicHiddenAPIScope] = publicStubModules
m[SystemHiddenAPIScope] = systemStubModules
m[TestHiddenAPIScope] = testStubModules
m[CorePlatformHiddenAPIScope] = corePlatformStubModules
return m
}
// hiddenAPIAddStubLibDependencies adds dependencies onto the modules specified in
// sdkKindToStubLibModules. It adds them in a well known order and uses an SdkKind specific tag to
// identify the source of the dependency.
func hiddenAPIAddStubLibDependencies(ctx android.BottomUpMutatorContext, sdkKindToStubLibModules map[android.SdkKind][]string) {
// apiScopeToStubLibModules. It adds them in a well known order and uses a HiddenAPIScope specific
// tag to identify the source of the dependency.
func hiddenAPIAddStubLibDependencies(ctx android.BottomUpMutatorContext, apiScopeToStubLibModules map[*HiddenAPIScope][]string) {
module := ctx.Module()
for _, sdkKind := range hiddenAPIRelevantSdkKinds {
modules := sdkKindToStubLibModules[sdkKind]
ctx.AddDependency(module, hiddenAPIStubsDependencyTag{sdkKind: sdkKind}, modules...)
for _, apiScope := range hiddenAPIScopes {
modules := apiScopeToStubLibModules[apiScope]
ctx.AddDependency(module, hiddenAPIStubsDependencyTag{apiScope: apiScope}, modules...)
}
}
@ -153,13 +226,6 @@ func hiddenAPIRetrieveDexJarBuildPath(ctx android.ModuleContext, module android.
return dexJar
}
var sdkKindToHiddenapiListOption = map[android.SdkKind]string{
android.SdkPublic: "public-stub-classpath",
android.SdkSystem: "system-stub-classpath",
android.SdkTest: "test-stub-classpath",
android.SdkCorePlatform: "core-platform-stub-classpath",
}
// ruleToGenerateHiddenAPIStubFlagsFile creates a rule to create a hidden API stub flags file.
//
// The rule is initialized but not built so that the caller can modify it and select an appropriate
@ -172,11 +238,11 @@ func ruleToGenerateHiddenAPIStubFlagsFile(ctx android.BuilderContext, outputPath
// Find the widest API stubs provided by the fragments on which this depends, if any.
var dependencyStubDexJars android.Paths
for i := len(hiddenAPIRelevantSdkKinds) - 1; i >= 0; i-- {
kind := hiddenAPIRelevantSdkKinds[i]
stubsForKind := input.DependencyStubDexJarsByKind[kind]
if len(stubsForKind) != 0 {
dependencyStubDexJars = stubsForKind
for i := len(hiddenAPIScopes) - 1; i >= 0; i-- {
apiScope := hiddenAPIScopes[i]
stubsForAPIScope := input.DependencyStubDexJarsByScope[apiScope]
if len(stubsForAPIScope) != 0 {
dependencyStubDexJars = stubsForAPIScope
break
}
}
@ -187,16 +253,17 @@ func ruleToGenerateHiddenAPIStubFlagsFile(ctx android.BuilderContext, outputPath
FlagForEachInput("--dependency-stub-dex=", dependencyStubDexJars).
FlagForEachInput("--boot-dex=", bootDexJars)
// Iterate over the sdk kinds in a fixed order.
for _, sdkKind := range hiddenAPIRelevantSdkKinds {
// Merge in the stub dex jar paths for this kind from the fragments on which it depends. They
// will be needed to resolve dependencies from this fragment's stubs to classes in the other
// fragment's APIs.
dependencyPaths := input.DependencyStubDexJarsByKind[sdkKind]
paths := append(dependencyPaths, input.StubDexJarsByKind[sdkKind]...)
// Iterate over the api scopes in a fixed order.
for _, apiScope := range hiddenAPIFlagScopes {
// Merge in the stub dex jar paths for this api scope from the fragments on which it depends.
// They will be needed to resolve dependencies from this fragment's stubs to classes in the
// other fragment's APIs.
var paths android.Paths
paths = append(paths, input.DependencyStubDexJarsByScope[apiScope]...)
paths = append(paths, input.StubDexJarsByScope[apiScope]...)
if len(paths) > 0 {
option := sdkKindToHiddenapiListOption[sdkKind]
command.FlagWithInputList("--"+option+"=", paths, ":")
option := apiScope.hiddenAPIListOption
command.FlagWithInputList(option+"=", paths, ":")
}
}
@ -377,8 +444,8 @@ type HiddenAPIInfo struct {
// that category.
FlagFilesByCategory FlagFilesByCategory
// The paths to the stub dex jars for each of the android.SdkKind in hiddenAPIRelevantSdkKinds.
TransitiveStubDexJarsByKind StubDexJarsByKind
// The paths to the stub dex jars for each of the *HiddenAPIScope in hiddenAPIScopes.
TransitiveStubDexJarsByScope StubDexJarsByScope
// The output from the hidden API processing needs to be made available to other modules.
HiddenAPIFlagOutput
@ -386,8 +453,8 @@ type HiddenAPIInfo struct {
func newHiddenAPIInfo() *HiddenAPIInfo {
info := HiddenAPIInfo{
FlagFilesByCategory: FlagFilesByCategory{},
TransitiveStubDexJarsByKind: StubDexJarsByKind{},
FlagFilesByCategory: FlagFilesByCategory{},
TransitiveStubDexJarsByScope: StubDexJarsByScope{},
}
return &info
}
@ -398,33 +465,33 @@ func (i *HiddenAPIInfo) mergeFromFragmentDeps(ctx android.ModuleContext, fragmen
for _, fragment := range fragments {
if ctx.OtherModuleHasProvider(fragment, HiddenAPIInfoProvider) {
info := ctx.OtherModuleProvider(fragment, HiddenAPIInfoProvider).(HiddenAPIInfo)
i.TransitiveStubDexJarsByKind.append(info.TransitiveStubDexJarsByKind)
i.TransitiveStubDexJarsByScope.append(info.TransitiveStubDexJarsByScope)
}
}
// Dedup and sort paths.
i.TransitiveStubDexJarsByKind.dedupAndSort()
i.TransitiveStubDexJarsByScope.dedupAndSort()
}
var HiddenAPIInfoProvider = blueprint.NewProvider(HiddenAPIInfo{})
// StubDexJarsByKind maps an android.SdkKind to the paths to stub dex jars appropriate for that
// level. See hiddenAPIRelevantSdkKinds for a list of the acceptable android.SdkKind values.
type StubDexJarsByKind map[android.SdkKind]android.Paths
// StubDexJarsByScope maps a *HiddenAPIScope to the paths to stub dex jars appropriate for that
// scope. See hiddenAPIScopes for a list of the acceptable *HiddenAPIScope values.
type StubDexJarsByScope map[*HiddenAPIScope]android.Paths
// append appends the supplied kind specific stub dex jar pargs to the corresponding kind in this
// append appends the API scope specific stub dex jar args to the corresponding scope in this
// map.
func (s StubDexJarsByKind) append(other StubDexJarsByKind) {
for _, kind := range hiddenAPIRelevantSdkKinds {
s[kind] = append(s[kind], other[kind]...)
func (s StubDexJarsByScope) append(other StubDexJarsByScope) {
for _, scope := range hiddenAPIScopes {
s[scope] = append(s[scope], other[scope]...)
}
}
// dedupAndSort removes duplicates in the stub dex jar paths and sorts them into a consistent and
// deterministic order.
func (s StubDexJarsByKind) dedupAndSort() {
for kind, paths := range s {
s[kind] = android.SortedUniquePaths(paths)
func (s StubDexJarsByScope) dedupAndSort() {
for apiScope, paths := range s {
s[apiScope] = android.SortedUniquePaths(paths)
}
}
@ -435,14 +502,14 @@ type HiddenAPIFlagInput struct {
// from the stub dex files.
FlagFilesByCategory FlagFilesByCategory
// StubDexJarsByKind contains the stub dex jars for different android.SdkKind and which determine
// StubDexJarsByScope contains the stub dex jars for different *HiddenAPIScope and which determine
// the initial flags for each dex member.
StubDexJarsByKind StubDexJarsByKind
StubDexJarsByScope StubDexJarsByScope
// DependencyStubDexJarsByKind contains the stub dex jars provided by the fragments on which this
// depends. It is the result of merging HiddenAPIInfo.TransitiveStubDexJarsByKind from each
// DependencyStubDexJarsByScope contains the stub dex jars provided by the fragments on which this
// depends. It is the result of merging HiddenAPIInfo.TransitiveStubDexJarsByScope from each
// fragment on which this depends.
DependencyStubDexJarsByKind StubDexJarsByKind
DependencyStubDexJarsByScope StubDexJarsByScope
// RemovedTxtFiles is the list of removed.txt files provided by java_sdk_library modules that are
// specified in the bootclasspath_fragment's stub_libs and contents properties.
@ -452,8 +519,9 @@ type HiddenAPIFlagInput struct {
// newHiddenAPIFlagInput creates a new initialize HiddenAPIFlagInput struct.
func newHiddenAPIFlagInput() HiddenAPIFlagInput {
input := HiddenAPIFlagInput{
FlagFilesByCategory: FlagFilesByCategory{},
StubDexJarsByKind: StubDexJarsByKind{},
FlagFilesByCategory: FlagFilesByCategory{},
StubDexJarsByScope: StubDexJarsByScope{},
DependencyStubDexJarsByScope: StubDexJarsByScope{},
}
return input
@ -469,7 +537,7 @@ func (i *HiddenAPIFlagInput) canPerformHiddenAPIProcessing(ctx android.ModuleCon
// required as the whole point of adding something to the bootclasspath fragment is to add it to
// the bootclasspath in order to be used by something else in the system. Without any stubs it
// cannot do that.
if len(i.StubDexJarsByKind) == 0 {
if len(i.StubDexJarsByScope) == 0 {
return false
}
@ -500,14 +568,15 @@ func (i *HiddenAPIFlagInput) canPerformHiddenAPIProcessing(ctx android.ModuleCon
//
// That includes paths to the stub dex jars as well as paths to the *removed.txt files.
func (i *HiddenAPIFlagInput) gatherStubLibInfo(ctx android.ModuleContext, contents []android.Module) {
addFromModule := func(ctx android.ModuleContext, module android.Module, kind android.SdkKind) {
dexJar := hiddenAPIRetrieveDexJarBuildPath(ctx, module, kind)
addFromModule := func(ctx android.ModuleContext, module android.Module, apiScope *HiddenAPIScope) {
sdkKind := apiScope.sdkKind
dexJar := hiddenAPIRetrieveDexJarBuildPath(ctx, module, sdkKind)
if dexJar != nil {
i.StubDexJarsByKind[kind] = append(i.StubDexJarsByKind[kind], dexJar)
i.StubDexJarsByScope[apiScope] = append(i.StubDexJarsByScope[apiScope], dexJar)
}
if sdkLibrary, ok := module.(SdkLibraryDependency); ok {
removedTxtFile := sdkLibrary.SdkRemovedTxtFile(ctx, kind)
removedTxtFile := sdkLibrary.SdkRemovedTxtFile(ctx, sdkKind)
i.RemovedTxtFiles = append(i.RemovedTxtFiles, removedTxtFile.AsPaths()...)
}
}
@ -515,11 +584,9 @@ func (i *HiddenAPIFlagInput) gatherStubLibInfo(ctx android.ModuleContext, conten
// If the contents includes any java_sdk_library modules then add them to the stubs.
for _, module := range contents {
if _, ok := module.(SdkLibraryDependency); ok {
// Add information for every possible kind needed by hidden API. SdkCorePlatform is not used
// as the java_sdk_library does not have special support for core_platform API, instead it is
// implemented as a customized form of SdkPublic.
for _, kind := range []android.SdkKind{android.SdkPublic, android.SdkSystem, android.SdkTest} {
addFromModule(ctx, module, kind)
// Add information for every possible API scope needed by hidden API.
for _, apiScope := range hiddenAPISdkLibrarySupportedScopes {
addFromModule(ctx, module, apiScope)
}
}
}
@ -527,13 +594,14 @@ func (i *HiddenAPIFlagInput) gatherStubLibInfo(ctx android.ModuleContext, conten
ctx.VisitDirectDeps(func(module android.Module) {
tag := ctx.OtherModuleDependencyTag(module)
if hiddenAPIStubsTag, ok := tag.(hiddenAPIStubsDependencyTag); ok {
kind := hiddenAPIStubsTag.sdkKind
addFromModule(ctx, module, kind)
apiScope := hiddenAPIStubsTag.apiScope
addFromModule(ctx, module, apiScope)
}
})
// Normalize the paths, i.e. remove duplicates and sort.
i.StubDexJarsByKind.dedupAndSort()
i.StubDexJarsByScope.dedupAndSort()
i.DependencyStubDexJarsByScope.dedupAndSort()
i.RemovedTxtFiles = android.SortedUniquePaths(i.RemovedTxtFiles)
}
@ -546,9 +614,9 @@ func (i *HiddenAPIFlagInput) extractFlagFilesFromProperties(ctx android.ModuleCo
}
}
func (i *HiddenAPIFlagInput) transitiveStubDexJarsByKind() StubDexJarsByKind {
transitive := i.DependencyStubDexJarsByKind
transitive.append(i.StubDexJarsByKind)
func (i *HiddenAPIFlagInput) transitiveStubDexJarsByScope() StubDexJarsByScope {
transitive := i.DependencyStubDexJarsByScope
transitive.append(i.StubDexJarsByScope)
return transitive
}

4
java/platform_bootclasspath.go
View File

@ -119,8 +119,8 @@ func (b *platformBootclasspathModule) hiddenAPIDepsMutator(ctx android.BottomUpM
}
// Add dependencies onto the stub lib modules.
sdkKindToStubLibModules := hiddenAPIComputeMonolithicStubLibModules(ctx.Config())
hiddenAPIAddStubLibDependencies(ctx, sdkKindToStubLibModules)
apiLevelToStubLibModules := hiddenAPIComputeMonolithicStubLibModules(ctx.Config())
hiddenAPIAddStubLibDependencies(ctx, apiLevelToStubLibModules)
}
func (b *platformBootclasspathModule) BootclasspathDepsMutator(ctx android.BottomUpMutatorContext) {