Revert "Revert "Limit System SDK to 34 for Java modules in the v..." (7416d67f) · Commits · e / os / android_build_soong

android/sdk_version.go

+74 −11

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@ package android

		import (
		"fmt"
		"reflect"
		"strconv"
		"strings"
		)
		@@ -162,6 +163,17 @@ 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
		}
		@@ -290,28 +302,79 @@ 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 {
		// 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() {
		// 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 {
		return true
		}
		allowedVersions := ctx.DeviceConfig().PlatformSystemSdkVersions()
		if ctx.DeviceSpecific() \|\| ctx.SocSpecific() \|\| (ctx.ProductSpecific() && ctx.Config().EnforceProductPartitionInterface()) {
		systemSdkVersions := ctx.DeviceConfig().SystemSdkVersions()
		if len(systemSdkVersions) > 0 {
		allowedVersions = systemSdkVersions

		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))
		}
		}
		if len(allowedVersions) > 0 && !InList(s.ApiLevel.String(), allowedVersions) {

		// 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) {
		ctx.PropertyErrorf("sdk_version", "incompatible sdk version %q. System SDK version should be one of %q",
		s.Raw, allowedVersions)
		s.Raw, supportedVersions)
		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)
		}

android/test_config.go

+3 −2

Original line number	Diff line number	Diff line
		@@ -39,11 +39,12 @@ 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{"14", "15"},
		Platform_systemsdk_versions: []string{"29", "30"},
		DeviceSystemSdkVersions: []string{"29", "30", "S"},
		Platform_systemsdk_versions: []string{"29", "30", "S", "Tiramisu"},
		AAPTConfig: []string{"normal", "large", "xlarge", "hdpi", "xhdpi", "xxhdpi"},
		AAPTPreferredConfig: stringPtr("xhdpi"),
		AAPTCharacteristics: stringPtr("nosdcard"),

java/Android.bp

+2 −1

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

java/sdk_version_test.go

0 → 100644

+66 −0

Original line number	Diff line number	Diff line
		// 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")
		}

sysprop/sysprop_test.go

+6 −0

Original line number	Diff line number	Diff line
		@@ -125,6 +125,12 @@ 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),