tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Revert "Limit System SDK to 34 for Java modules in the vendor pa..."

Browse source 
Revert submission 2894701-limit_systemsdk

Reason for revert: might be breaking builds at 318695834

Bug: 318695834

Reverted changes: /q/submissionid:2894701-limit_systemsdk

Change-Id: I71a87d0a026a444ea9d26f889b3421162e13fea9
This commit is contained in:
Sebastian Pickl 2024-01-04 17:25:03 +00:00
parent 13c52b9963
commit 1f1662217a
5 changed files with 14 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

85
android/sdk_version.go
View file

@ -16,7 +16,6 @@ package android
import (
"fmt"
"reflect"
"strconv"
"strings"
)
@ -163,17 +162,6 @@ func (s SdkSpec) ForVendorPartition(ctx EarlyModuleContext) SdkSpec {
// If BOARD_CURRENT_API_LEVEL_FOR_VENDOR_MODULES has a numeric value,
// use it instead of "current" for the vendor partition.
currentSdkVersion := ctx.DeviceConfig().CurrentApiLevelForVendorModules()
// b/314011075: special case for Java modules in vendor partition. They can no longer use
// SDK 35 or later. Their maximum API level is limited to 34 (Android U). This is to
// discourage the use of Java APIs in the vendor partition which hasn't been officially
// supported since the Project Treble back in Android 10. We would like to eventually
// evacuate all Java modules from the partition, but that shall be done progressively.
// Note that the check for the availability of SDK 34 is to not break existing tests where
// any of the frozen SDK version is unavailable.
if isJava(ctx.Module()) && isSdkVersion34AvailableIn(ctx.Config()) {
currentSdkVersion = "34"
}
if currentSdkVersion == "current" {
return s
}
@ -302,79 +290,28 @@ func SdkSpecFromWithConfig(config Config, str string) SdkSpec {
}
}
// Checks if the use of this SDK `s` is valid for the given module context `ctx`.
func (s SdkSpec) ValidateSystemSdk(ctx EarlyModuleContext) bool {
// Do some early checks. This check is currently only for Java modules. And our only concern
// is the use of "system" SDKs.
if !isJava(ctx.Module()) || s.Kind != SdkSystem {
// Ensures that the specified system SDK version is one of BOARD_SYSTEMSDK_VERSIONS (for vendor/product Java module)
// Assuming that BOARD_SYSTEMSDK_VERSIONS := 28 29,
// sdk_version of the modules in vendor/product that use system sdk must be either system_28, system_29 or system_current
if s.Kind != SdkSystem || s.ApiLevel.IsPreview() {
return true
}
inVendor := ctx.DeviceSpecific() || ctx.SocSpecific()
inProduct := ctx.ProductSpecific()
isProductUnbundled := ctx.Config().EnforceProductPartitionInterface()
inApex := false
if am, ok := ctx.Module().(ApexModule); ok {
inApex = am.InAnyApex()
}
isUnbundled := inVendor || (inProduct && isProductUnbundled) || inApex
// Bundled modules can use any SDK
if !isUnbundled {
return true
}
// Unbundled modules are allowed to use BOARD_SYSTEMSDK_VERSIONS
supportedVersions := ctx.DeviceConfig().SystemSdkVersions()
// b/314011075: special case for vendor modules. Java modules in the vendor partition can
// not use SDK 35 or later. This is to discourage the use of Java APIs in the vendor
// partition which hasn't been officially supported since the Project Treble back in Android
// 10. We would like to eventually evacuate all Java modules from the partition, but that
// shall be done progressively.
if inVendor {
// 28 was the API when BOARD_SYSTEMSDK_VERSIONS was introduced, so that's the oldest
// we should allow.
supportedVersions = []string{}
for v := 28; v <= 34; v++ {
supportedVersions = append(supportedVersions, strconv.Itoa(v))
allowedVersions := ctx.DeviceConfig().PlatformSystemSdkVersions()
if ctx.DeviceSpecific() || ctx.SocSpecific() || (ctx.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
systemSdkVersions := ctx.DeviceConfig().SystemSdkVersions()
if len(systemSdkVersions) > 0 {
allowedVersions = systemSdkVersions
}
}
// APEXes in the system partition are still considered as part of the platform, thus can use
// more SDKs from PLATFORM_SYSTEMSDK_VERSIONS
if inApex && !inVendor {
supportedVersions = ctx.DeviceConfig().PlatformSystemSdkVersions()
}
thisVer, err := s.EffectiveVersion(ctx)
if err != nil {
ctx.PropertyErrorf("sdk_version", "invalid sdk version %q", s.Raw)
return false
}
thisVerString := strconv.Itoa(thisVer.FinalOrPreviewInt())
if thisVer.IsPreview() {
thisVerString = *ctx.Config().productVariables.Platform_sdk_version_or_codename
}
if !InList(thisVerString, supportedVersions) {
if len(allowedVersions) > 0 && !InList(s.ApiLevel.String(), allowedVersions) {
ctx.PropertyErrorf("sdk_version", "incompatible sdk version %q. System SDK version should be one of %q",
s.Raw, supportedVersions)
s.Raw, allowedVersions)
return false
}
return true
}
func isJava(m Module) bool {
moduleType := reflect.TypeOf(m).String()
return strings.HasPrefix(moduleType, "*java.")
}
func isSdkVersion34AvailableIn(c Config) bool {
return c.PlatformSdkVersion().FinalInt() >= 34
}
func init() {
RegisterMakeVarsProvider(pctx, javaSdkMakeVars)
}

5
android/test_config.go
View file

@ -39,12 +39,11 @@ func TestConfig(buildDir string, env map[string]string, bp string, fs map[string
DeviceName: stringPtr("test_device"),
DeviceProduct: stringPtr("test_product"),
Platform_sdk_version: intPtr(30),
Platform_sdk_version_or_codename: stringPtr("S"),
Platform_sdk_codename: stringPtr("S"),
Platform_base_sdk_extension_version: intPtr(1),
Platform_version_active_codenames: []string{"S", "Tiramisu"},
DeviceSystemSdkVersions: []string{"29", "30", "S"},
Platform_systemsdk_versions: []string{"29", "30", "S", "Tiramisu"},
DeviceSystemSdkVersions: []string{"14", "15"},
Platform_systemsdk_versions: []string{"29", "30"},
AAPTConfig: []string{"normal", "large", "xlarge", "hdpi", "xhdpi", "xxhdpi"},
AAPTPreferredConfig: stringPtr("xhdpi"),
AAPTCharacteristics: stringPtr("nosdcard"),

3
java/Android.bp
View file

@ -108,9 +108,8 @@ bootstrap_go_package {
"prebuilt_apis_test.go",
"proto_test.go",
"rro_test.go",
"sdk_library_test.go",
"sdk_test.go",
"sdk_version_test.go",
"sdk_library_test.go",
"system_modules_test.go",
"systemserver_classpath_fragment_test.go",
"test_spec_test.go",

66
java/sdk_version_test.go
View file

@ -1,66 +0,0 @@
// Copyright 2024 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 (
"testing"
"android/soong/android"
)
func stringPtr(v string) *string {
return &v
}
func TestSystemSdkFromVendor(t *testing.T) {
fixtures := android.GroupFixturePreparers(
PrepareForTestWithJavaDefaultModules,
android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
variables.Platform_sdk_version = intPtr(34)
variables.Platform_sdk_codename = stringPtr("VanillaIceCream")
variables.Platform_version_active_codenames = []string{"VanillaIceCream"}
variables.Platform_systemsdk_versions = []string{"33", "34", "VanillaIceCream"}
variables.DeviceSystemSdkVersions = []string{"VanillaIceCream"}
}),
FixtureWithPrebuiltApis(map[string][]string{
"33": {},
"34": {},
"35": {},
}),
)
fixtures.ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern("incompatible sdk version")).
RunTestWithBp(t, `
android_app {
name: "foo",
srcs: ["a.java"],
vendor: true,
sdk_version: "system_35",
}`)
result := fixtures.RunTestWithBp(t, `
android_app {
name: "foo",
srcs: ["a.java"],
vendor: true,
sdk_version: "system_current",
}`)
fooModule := result.ModuleForTests("foo", "android_common")
fooClasspath := fooModule.Rule("javac").Args["classpath"]
android.AssertStringDoesContain(t, "foo classpath", fooClasspath, "prebuilts/sdk/34/system/android.jar")
android.AssertStringDoesNotContain(t, "foo classpath", fooClasspath, "prebuilts/sdk/35/system/android.jar")
android.AssertStringDoesNotContain(t, "foo classpath", fooClasspath, "prebuilts/sdk/current/system/android.jar")
}

6
sysprop/sysprop_test.go
View file

@ -125,12 +125,6 @@ func test(t *testing.T, bp string) *android.TestResult {
variables.DeviceSystemSdkVersions = []string{"28"}
variables.DeviceVndkVersion = proptools.StringPtr("current")
variables.Platform_vndk_version = proptools.StringPtr("29")
variables.DeviceCurrentApiLevelForVendorModules = proptools.StringPtr("28")
}),
java.FixtureWithPrebuiltApis(map[string][]string{
"28": {},
"29": {},
"30": {},
}),
mockFS.AddToFixture(),
android.FixtureWithRootAndroidBp(bp),