07c8856904
Unbundled builds set AllowMissingDependencies and attempt to use prebuilts for some jars. Delay the errors for missing jars for modules with invalid sdk_version values in unbundled builds so that they only block the build if those modules are built. Also fix some error messages to show the original sdk_version value. Bug: 146513037 Test: m TARGET_BUILD_APPS=Camera2 Change-Id: I1812ef6dc80895f7a2162a8bdbf2c5067755e9a0
387 lines
12 KiB
Go
387 lines
12 KiB
Go
// Copyright 2019 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"
|
|
"android/soong/java/config"
|
|
"fmt"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/google/blueprint/pathtools"
|
|
)
|
|
|
|
func init() {
|
|
android.RegisterPreSingletonType("sdk_versions", sdkPreSingletonFactory)
|
|
android.RegisterSingletonType("sdk", sdkSingletonFactory)
|
|
android.RegisterMakeVarsProvider(pctx, sdkMakeVars)
|
|
}
|
|
|
|
var sdkVersionsKey = android.NewOnceKey("sdkVersionsKey")
|
|
var sdkFrameworkAidlPathKey = android.NewOnceKey("sdkFrameworkAidlPathKey")
|
|
var apiFingerprintPathKey = android.NewOnceKey("apiFingerprintPathKey")
|
|
|
|
type sdkContext interface {
|
|
// sdkVersion returns the sdk_version property of the current module, or an empty string if it is not set.
|
|
sdkVersion() string
|
|
// systemModules returns the system_modules property of the current module, or an empty string if it is not set.
|
|
systemModules() string
|
|
// minSdkVersion returns the min_sdk_version property of the current module, or sdkVersion() if it is not set.
|
|
minSdkVersion() string
|
|
// targetSdkVersion returns the target_sdk_version property of the current module, or sdkVersion() if it is not set.
|
|
targetSdkVersion() string
|
|
}
|
|
|
|
func sdkVersionOrDefault(ctx android.BaseModuleContext, v string) string {
|
|
switch v {
|
|
case "", "none", "current", "test_current", "system_current", "core_current", "core_platform":
|
|
return ctx.Config().DefaultAppTargetSdk()
|
|
default:
|
|
return v
|
|
}
|
|
}
|
|
|
|
// Returns a sdk version as a number. For modules targeting an unreleased SDK (meaning it does not yet have a number)
|
|
// it returns android.FutureApiLevel (10000).
|
|
func sdkVersionToNumber(ctx android.EarlyModuleContext, v string) (int, error) {
|
|
switch v {
|
|
case "", "none", "current", "test_current", "system_current", "core_current", "core_platform":
|
|
return ctx.Config().DefaultAppTargetSdkInt(), nil
|
|
default:
|
|
n := android.GetNumericSdkVersion(v)
|
|
if i, err := strconv.Atoi(n); err != nil {
|
|
return -1, fmt.Errorf("invalid sdk version %q", n)
|
|
} else {
|
|
return i, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func sdkVersionToNumberAsString(ctx android.EarlyModuleContext, v string) (string, error) {
|
|
n, err := sdkVersionToNumber(ctx, v)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return strconv.Itoa(n), nil
|
|
}
|
|
|
|
func decodeSdkDep(ctx android.EarlyModuleContext, sdkContext sdkContext) sdkDep {
|
|
v := sdkContext.sdkVersion()
|
|
|
|
// For PDK builds, use the latest SDK version instead of "current"
|
|
if ctx.Config().IsPdkBuild() && (v == "" || v == "current") {
|
|
sdkVersions := ctx.Config().Get(sdkVersionsKey).([]int)
|
|
latestSdkVersion := 0
|
|
if len(sdkVersions) > 0 {
|
|
latestSdkVersion = sdkVersions[len(sdkVersions)-1]
|
|
}
|
|
v = strconv.Itoa(latestSdkVersion)
|
|
}
|
|
|
|
numericSdkVersion, err := sdkVersionToNumber(ctx, v)
|
|
if err != nil {
|
|
ctx.PropertyErrorf("sdk_version", "%s", err)
|
|
return sdkDep{}
|
|
}
|
|
|
|
toPrebuilt := func(sdk string) sdkDep {
|
|
var api, v string
|
|
if strings.Contains(sdk, "_") {
|
|
t := strings.Split(sdk, "_")
|
|
api = t[0]
|
|
v = t[1]
|
|
} else {
|
|
api = "public"
|
|
v = sdk
|
|
}
|
|
dir := filepath.Join("prebuilts", "sdk", v, api)
|
|
jar := filepath.Join(dir, "android.jar")
|
|
// There's no aidl for other SDKs yet.
|
|
// TODO(77525052): Add aidl files for other SDKs too.
|
|
public_dir := filepath.Join("prebuilts", "sdk", v, "public")
|
|
aidl := filepath.Join(public_dir, "framework.aidl")
|
|
jarPath := android.ExistentPathForSource(ctx, jar)
|
|
aidlPath := android.ExistentPathForSource(ctx, aidl)
|
|
lambdaStubsPath := android.PathForSource(ctx, config.SdkLambdaStubsPath)
|
|
|
|
if (!jarPath.Valid() || !aidlPath.Valid()) && ctx.Config().AllowMissingDependencies() {
|
|
return sdkDep{
|
|
invalidVersion: true,
|
|
bootclasspath: []string{fmt.Sprintf("sdk_%s_%s_android", api, v)},
|
|
}
|
|
}
|
|
|
|
if !jarPath.Valid() {
|
|
ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdk, jar)
|
|
return sdkDep{}
|
|
}
|
|
|
|
if !aidlPath.Valid() {
|
|
ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdk, aidl)
|
|
return sdkDep{}
|
|
}
|
|
|
|
return sdkDep{
|
|
useFiles: true,
|
|
jars: android.Paths{jarPath.Path(), lambdaStubsPath},
|
|
aidl: android.OptionalPathForPath(aidlPath.Path()),
|
|
}
|
|
}
|
|
|
|
toModule := func(m, r string, aidl android.Path) sdkDep {
|
|
return sdkDep{
|
|
useModule: true,
|
|
bootclasspath: []string{m, config.DefaultLambdaStubsLibrary},
|
|
systemModules: "core-current-stubs-system-modules",
|
|
java9Classpath: []string{m},
|
|
frameworkResModule: r,
|
|
aidl: android.OptionalPathForPath(aidl),
|
|
}
|
|
}
|
|
|
|
// Ensures that the specificed system SDK version is one of BOARD_SYSTEMSDK_VERSIONS (for vendor apks)
|
|
// or PRODUCT_SYSTEMSDK_VERSIONS (for other apks or when BOARD_SYSTEMSDK_VERSIONS is not set)
|
|
if strings.HasPrefix(v, "system_") && numericSdkVersion != android.FutureApiLevel {
|
|
allowed_versions := ctx.DeviceConfig().PlatformSystemSdkVersions()
|
|
if ctx.DeviceSpecific() || ctx.SocSpecific() {
|
|
if len(ctx.DeviceConfig().SystemSdkVersions()) > 0 {
|
|
allowed_versions = ctx.DeviceConfig().SystemSdkVersions()
|
|
}
|
|
}
|
|
if len(allowed_versions) > 0 && !android.InList(strconv.Itoa(numericSdkVersion), allowed_versions) {
|
|
ctx.PropertyErrorf("sdk_version", "incompatible sdk version %q. System SDK version should be one of %q",
|
|
v, allowed_versions)
|
|
}
|
|
}
|
|
|
|
if ctx.Config().UnbundledBuildUsePrebuiltSdks() &&
|
|
v != "" && v != "none" && v != "core_platform" {
|
|
return toPrebuilt(v)
|
|
}
|
|
|
|
switch v {
|
|
case "":
|
|
return sdkDep{
|
|
useDefaultLibs: true,
|
|
frameworkResModule: "framework-res",
|
|
}
|
|
case "none":
|
|
systemModules := sdkContext.systemModules()
|
|
if systemModules == "" {
|
|
ctx.PropertyErrorf("sdk_version",
|
|
`system_modules is required to be set to a non-empty value when sdk_version is "none", did you mean sdk_version: "core_platform"?`)
|
|
} else if systemModules == "none" {
|
|
return sdkDep{
|
|
noStandardLibs: true,
|
|
}
|
|
}
|
|
|
|
return sdkDep{
|
|
useModule: true,
|
|
noStandardLibs: true,
|
|
systemModules: systemModules,
|
|
bootclasspath: []string{systemModules},
|
|
}
|
|
case "core_platform":
|
|
return sdkDep{
|
|
useDefaultLibs: true,
|
|
frameworkResModule: "framework-res",
|
|
noFrameworksLibs: true,
|
|
}
|
|
case "current":
|
|
return toModule("android_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
|
|
case "system_current":
|
|
return toModule("android_system_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
|
|
case "test_current":
|
|
return toModule("android_test_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
|
|
case "core_current":
|
|
return toModule("core.current.stubs", "", nil)
|
|
default:
|
|
return toPrebuilt(v)
|
|
}
|
|
}
|
|
|
|
func sdkPreSingletonFactory() android.Singleton {
|
|
return sdkPreSingleton{}
|
|
}
|
|
|
|
type sdkPreSingleton struct{}
|
|
|
|
func (sdkPreSingleton) GenerateBuildActions(ctx android.SingletonContext) {
|
|
sdkJars, err := ctx.GlobWithDeps("prebuilts/sdk/*/public/android.jar", nil)
|
|
if err != nil {
|
|
ctx.Errorf("failed to glob prebuilts/sdk/*/public/android.jar: %s", err.Error())
|
|
}
|
|
|
|
var sdkVersions []int
|
|
for _, sdkJar := range sdkJars {
|
|
dir := filepath.Base(filepath.Dir(filepath.Dir(sdkJar)))
|
|
v, err := strconv.Atoi(dir)
|
|
if scerr, ok := err.(*strconv.NumError); ok && scerr.Err == strconv.ErrSyntax {
|
|
continue
|
|
} else if err != nil {
|
|
ctx.Errorf("invalid sdk jar %q, %s, %v", sdkJar, err.Error())
|
|
}
|
|
sdkVersions = append(sdkVersions, v)
|
|
}
|
|
|
|
sort.Ints(sdkVersions)
|
|
|
|
ctx.Config().Once(sdkVersionsKey, func() interface{} { return sdkVersions })
|
|
}
|
|
|
|
func sdkSingletonFactory() android.Singleton {
|
|
return sdkSingleton{}
|
|
}
|
|
|
|
type sdkSingleton struct{}
|
|
|
|
func (sdkSingleton) GenerateBuildActions(ctx android.SingletonContext) {
|
|
if ctx.Config().UnbundledBuildUsePrebuiltSdks() || ctx.Config().IsPdkBuild() {
|
|
return
|
|
}
|
|
|
|
createSdkFrameworkAidl(ctx)
|
|
createAPIFingerprint(ctx)
|
|
}
|
|
|
|
// Create framework.aidl by extracting anything that implements android.os.Parcelable from the SDK stubs modules.
|
|
func createSdkFrameworkAidl(ctx android.SingletonContext) {
|
|
stubsModules := []string{
|
|
"android_stubs_current",
|
|
"android_test_stubs_current",
|
|
"android_system_stubs_current",
|
|
}
|
|
|
|
stubsJars := make([]android.Paths, len(stubsModules))
|
|
|
|
ctx.VisitAllModules(func(module android.Module) {
|
|
// Collect dex jar paths for the modules listed above.
|
|
if j, ok := module.(Dependency); ok {
|
|
name := ctx.ModuleName(module)
|
|
if i := android.IndexList(name, stubsModules); i != -1 {
|
|
stubsJars[i] = j.HeaderJars()
|
|
}
|
|
}
|
|
})
|
|
|
|
var missingDeps []string
|
|
|
|
for i := range stubsJars {
|
|
if stubsJars[i] == nil {
|
|
if ctx.Config().AllowMissingDependencies() {
|
|
missingDeps = append(missingDeps, stubsModules[i])
|
|
} else {
|
|
ctx.Errorf("failed to find dex jar path for module %q",
|
|
stubsModules[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
rule := android.NewRuleBuilder()
|
|
rule.MissingDeps(missingDeps)
|
|
|
|
var aidls android.Paths
|
|
for _, jars := range stubsJars {
|
|
for _, jar := range jars {
|
|
aidl := android.PathForOutput(ctx, "aidl", pathtools.ReplaceExtension(jar.Base(), "aidl"))
|
|
|
|
rule.Command().
|
|
Text("rm -f").Output(aidl)
|
|
rule.Command().
|
|
BuiltTool(ctx, "sdkparcelables").
|
|
Input(jar).
|
|
Output(aidl)
|
|
|
|
aidls = append(aidls, aidl)
|
|
}
|
|
}
|
|
|
|
combinedAidl := sdkFrameworkAidlPath(ctx)
|
|
tempPath := combinedAidl.ReplaceExtension(ctx, "aidl.tmp")
|
|
|
|
rule.Command().
|
|
Text("rm -f").Output(tempPath)
|
|
rule.Command().
|
|
Text("cat").
|
|
Inputs(aidls).
|
|
Text("| sort -u >").
|
|
Output(tempPath)
|
|
|
|
commitChangeForRestat(rule, tempPath, combinedAidl)
|
|
|
|
rule.Build(pctx, ctx, "framework_aidl", "generate framework.aidl")
|
|
}
|
|
|
|
func sdkFrameworkAidlPath(ctx android.PathContext) android.OutputPath {
|
|
return ctx.Config().Once(sdkFrameworkAidlPathKey, func() interface{} {
|
|
return android.PathForOutput(ctx, "framework.aidl")
|
|
}).(android.OutputPath)
|
|
}
|
|
|
|
// Create api_fingerprint.txt
|
|
func createAPIFingerprint(ctx android.SingletonContext) {
|
|
out := ApiFingerprintPath(ctx)
|
|
|
|
rule := android.NewRuleBuilder()
|
|
|
|
rule.Command().
|
|
Text("rm -f").Output(out)
|
|
cmd := rule.Command()
|
|
|
|
if ctx.Config().PlatformSdkCodename() == "REL" {
|
|
cmd.Text("echo REL >").Output(out)
|
|
} else if ctx.Config().IsPdkBuild() {
|
|
// TODO: get this from the PDK artifacts?
|
|
cmd.Text("echo PDK >").Output(out)
|
|
} else if !ctx.Config().UnbundledBuildUsePrebuiltSdks() {
|
|
in, err := ctx.GlobWithDeps("frameworks/base/api/*current.txt", nil)
|
|
if err != nil {
|
|
ctx.Errorf("error globbing API files: %s", err)
|
|
}
|
|
|
|
cmd.Text("cat").
|
|
Inputs(android.PathsForSource(ctx, in)).
|
|
Text("| md5sum | cut -d' ' -f1 >").
|
|
Output(out)
|
|
} else {
|
|
// Unbundled build
|
|
// TODO: use a prebuilt api_fingerprint.txt from prebuilts/sdk/current.txt once we have one
|
|
cmd.Text("echo").
|
|
Flag(ctx.Config().PlatformPreviewSdkVersion()).
|
|
Text(">").
|
|
Output(out)
|
|
}
|
|
|
|
rule.Build(pctx, ctx, "api_fingerprint", "generate api_fingerprint.txt")
|
|
}
|
|
|
|
func ApiFingerprintPath(ctx android.PathContext) android.OutputPath {
|
|
return ctx.Config().Once(apiFingerprintPathKey, func() interface{} {
|
|
return android.PathForOutput(ctx, "api_fingerprint.txt")
|
|
}).(android.OutputPath)
|
|
}
|
|
|
|
func sdkMakeVars(ctx android.MakeVarsContext) {
|
|
if ctx.Config().UnbundledBuildUsePrebuiltSdks() || ctx.Config().IsPdkBuild() {
|
|
return
|
|
}
|
|
|
|
ctx.Strict("FRAMEWORK_AIDL", sdkFrameworkAidlPath(ctx).String())
|
|
ctx.Strict("API_FINGERPRINT", ApiFingerprintPath(ctx).String())
|
|
}
|