blob: f4cef7fa6fc7bfa6f26eeaf86b1407268ad5ca9e [file] [log] [blame]
// Copyright 2021 Google Inc. All rights reserved.
//
// 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 java
import (
"android/soong/android"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
)
// Contains code that is common to both platform_bootclasspath and bootclasspath_fragment.
func init() {
registerBootclasspathBuildComponents(android.InitRegistrationContext)
}
func registerBootclasspathBuildComponents(ctx android.RegistrationContext) {
ctx.FinalDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.BottomUp("bootclasspath_deps", bootclasspathDepsMutator).Parallel()
})
}
// BootclasspathDepsMutator is the interface that a module must implement if it wants to add
// dependencies onto APEX specific variants of bootclasspath fragments or bootclasspath contents.
type BootclasspathDepsMutator interface {
// BootclasspathDepsMutator implementations should add dependencies using
// addDependencyOntoApexModulePair and addDependencyOntoApexVariants.
BootclasspathDepsMutator(ctx android.BottomUpMutatorContext)
}
// bootclasspathDepsMutator is called during the final deps phase after all APEX variants have
// been created so can add dependencies onto specific APEX variants of modules.
func bootclasspathDepsMutator(ctx android.BottomUpMutatorContext) {
m := ctx.Module()
if p, ok := m.(BootclasspathDepsMutator); ok {
p.BootclasspathDepsMutator(ctx)
}
}
// addDependencyOntoApexVariants adds dependencies onto the appropriate apex specific variants of
// the module as specified in the ApexVariantReference list.
func addDependencyOntoApexVariants(ctx android.BottomUpMutatorContext, propertyName string, refs []ApexVariantReference, tag blueprint.DependencyTag) {
for i, ref := range refs {
apex := proptools.StringDefault(ref.Apex, "platform")
if ref.Module == nil {
ctx.PropertyErrorf(propertyName, "missing module name at position %d", i)
continue
}
name := proptools.String(ref.Module)
addDependencyOntoApexModulePair(ctx, apex, name, tag)
}
}
// addDependencyOntoApexModulePair adds a dependency onto the specified APEX specific variant or the
// specified module.
//
// If apex="platform" or "system_ext" then this adds a dependency onto the platform variant of the
// module. This adds dependencies onto the prebuilt and source modules with the specified name,
// depending on which ones are available. Visiting must use isActiveModule to select the preferred
// module when both source and prebuilt modules are available.
//
// Use gatherApexModulePairDepsWithTag to retrieve the dependencies.
func addDependencyOntoApexModulePair(ctx android.BottomUpMutatorContext, apex string, name string, tag blueprint.DependencyTag) {
var variations []blueprint.Variation
if apex != "platform" && apex != "system_ext" {
// Pick the correct apex variant.
variations = []blueprint.Variation{
{Mutator: "apex", Variation: apex},
}
}
target := ctx.Module().Target()
variations = append(variations, target.Variations()...)
addedDep := false
if ctx.OtherModuleDependencyVariantExists(variations, name) {
ctx.AddFarVariationDependencies(variations, tag, name)
addedDep = true
}
// Add a dependency on the prebuilt module if it exists.
prebuiltName := android.PrebuiltNameFromSource(name)
if ctx.OtherModuleDependencyVariantExists(variations, prebuiltName) {
ctx.AddVariationDependencies(variations, tag, prebuiltName)
addedDep = true
}
// If no appropriate variant existing for this, so no dependency could be added, then it is an
// error, unless missing dependencies are allowed. The simplest way to handle that is to add a
// dependency that will not be satisfied and the default behavior will handle it.
if !addedDep {
// Add dependency on the unprefixed (i.e. source or renamed prebuilt) module which we know does
// not exist. The resulting error message will contain useful information about the available
// variants.
reportMissingVariationDependency(ctx, variations, name)
// Add dependency on the missing prefixed prebuilt variant too if a module with that name exists
// so that information about its available variants will be reported too.
if ctx.OtherModuleExists(prebuiltName) {
reportMissingVariationDependency(ctx, variations, prebuiltName)
}
}
}
// reportMissingVariationDependency intentionally adds a dependency on a missing variation in order
// to generate an appropriate error message with information about the available variations.
func reportMissingVariationDependency(ctx android.BottomUpMutatorContext, variations []blueprint.Variation, name string) {
ctx.AddFarVariationDependencies(variations, nil, name)
}
// gatherApexModulePairDepsWithTag returns the list of dependencies with the supplied tag that was
// added by addDependencyOntoApexModulePair.
func gatherApexModulePairDepsWithTag(ctx android.BaseModuleContext, tag blueprint.DependencyTag) []android.Module {
var modules []android.Module
ctx.VisitDirectDepsIf(isActiveModule, func(module android.Module) {
t := ctx.OtherModuleDependencyTag(module)
if t == tag {
modules = append(modules, module)
}
})
return modules
}
// ApexVariantReference specifies a particular apex variant of a module.
type ApexVariantReference struct {
android.BpPrintableBase
// The name of the module apex variant, i.e. the apex containing the module variant.
//
// If this is not specified then it defaults to "platform" which will cause a dependency to be
// added to the module's platform variant.
//
// A value of system_ext should be used for any module that will be part of the system_ext
// partition.
Apex *string
// The name of the module.
Module *string
}
// BootclasspathFragmentsDepsProperties contains properties related to dependencies onto fragments.
type BootclasspathFragmentsDepsProperties struct {
// The names of the bootclasspath_fragment modules that form part of this module.
Fragments []ApexVariantReference
}
// addDependenciesOntoFragments adds dependencies to the fragments specified in this properties
// structure.
func (p *BootclasspathFragmentsDepsProperties) addDependenciesOntoFragments(ctx android.BottomUpMutatorContext) {
addDependencyOntoApexVariants(ctx, "fragments", p.Fragments, bootclasspathFragmentDepTag)
}
// bootclasspathDependencyTag defines dependencies from/to bootclasspath_fragment,
// prebuilt_bootclasspath_fragment and platform_bootclasspath onto either source or prebuilt
// modules.
type bootclasspathDependencyTag struct {
blueprint.BaseDependencyTag
name string
}
func (t bootclasspathDependencyTag) ExcludeFromVisibilityEnforcement() {
}
// Dependencies that use the bootclasspathDependencyTag instances are only added after all the
// visibility checking has been done so this has no functional effect. However, it does make it
// clear that visibility is not being enforced on these tags.
var _ android.ExcludeFromVisibilityEnforcementTag = bootclasspathDependencyTag{}
// The tag used for dependencies onto bootclasspath_fragments.
var bootclasspathFragmentDepTag = bootclasspathDependencyTag{name: "fragment"}
// BootclasspathNestedAPIProperties defines properties related to the API provided by parts of the
// bootclasspath that are nested within the main BootclasspathAPIProperties.
type BootclasspathNestedAPIProperties struct {
// java_library or preferably, java_sdk_library modules providing stub classes that define the
// APIs provided by this bootclasspath_fragment.
Stub_libs []string
}
// BootclasspathAPIProperties defines properties for defining the API provided by parts of the
// bootclasspath.
type BootclasspathAPIProperties struct {
// Api properties provide information about the APIs provided by the bootclasspath_fragment.
// Properties in this section apply to public, system and test api scopes. They DO NOT apply to
// core_platform as that is a special, ART specific scope, that does not follow the pattern and so
// has its own section. It is in the process of being deprecated and replaced by the system scope
// but this will remain for the foreseeable future to maintain backwards compatibility.
//
// Every bootclasspath_fragment must specify at least one stubs_lib in this section and must
// specify stubs for all the APIs provided by its contents. Failure to do so will lead to those
// methods being inaccessible to other parts of Android, including but not limited to
// applications.
Api BootclasspathNestedAPIProperties
// Properties related to the core platform API surface.
//
// This must only be used by the following modules:
// * ART
// * Conscrypt
// * I18N
//
// The bootclasspath_fragments for each of the above modules must specify at least one stubs_lib
// and must specify stubs for all the APIs provided by its contents. Failure to do so will lead to
// those methods being inaccessible to the other modules in the list.
Core_platform_api BootclasspathNestedAPIProperties
}
// apiScopeToStubLibs calculates the stub library modules for each relevant *HiddenAPIScope from the
// Stub_libs properties.
func (p BootclasspathAPIProperties) apiScopeToStubLibs() map[*HiddenAPIScope][]string {
m := map[*HiddenAPIScope][]string{}
for _, apiScope := range hiddenAPISdkLibrarySupportedScopes {
m[apiScope] = p.Api.Stub_libs
}
m[CorePlatformHiddenAPIScope] = p.Core_platform_api.Stub_libs
return m
}