Abstract sdk_version string using sdkSpec type
The value format that sdk_version (and min_sdk_version, etc.) can have
has consistently evolved and is quite complicated. Furthermore, with the
Mainline module effort, we are expected to have more sdk_versions like
'module-app-current', 'module-lib-current', etc.
The goal of this change is to abstract the various sdk versions, which
are currently represented in string and is parsed in various places,
into a type called sdkSpec, so that adding new sdk veresions becomes
easier than before.
The sdk_version string is now parsed in only one place 'SdkSpecFrom', in
which it is converted into the sdkSpec struct. The struct type provides
several methods that again converts sdkSpec into context-specific
information such as the effective version number, etc.
Bug: 146757305
Bug: 147879031
Test: m
Change-Id: I252f3706544f00ea71c61c23460f07561dd28ab0
diff --git a/java/sdk.go b/java/sdk.go
index 2dbcf4a..f388358 100644
--- a/java/sdk.go
+++ b/java/sdk.go
@@ -38,14 +38,16 @@
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
+ // sdkVersion returns sdkSpec that corresponds to the sdk_version property of the current module
+ sdkVersion() sdkSpec
// 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
+ // minSdkVersion returns sdkSpec that corresponds to the min_sdk_version property of the current module,
+ // or from sdk_version if it is not set.
+ minSdkVersion() sdkSpec
+ // targetSdkVersion returns the sdkSpec that corresponds to the target_sdk_version property of the current module,
+ // or from sdk_version if it is not set.
+ targetSdkVersion() sdkSpec
}
func UseApiFingerprint(ctx android.BaseModuleContext, v string) bool {
@@ -58,79 +60,236 @@
return false
}
-func sdkVersionOrDefault(ctx android.BaseModuleContext, v string) string {
- var sdkVersion string
- switch v {
- case "", "none", "current", "test_current", "system_current", "core_current", "core_platform":
- sdkVersion = ctx.Config().DefaultAppTargetSdk()
+// sdkKind represents a particular category of an SDK spec like public, system, test, etc.
+type sdkKind int
+
+const (
+ sdkInvalid sdkKind = iota
+ sdkNone
+ sdkCore
+ sdkCorePlatform
+ sdkPublic
+ sdkSystem
+ sdkTest
+ sdkPrivate
+)
+
+// String returns the string representation of this sdkKind
+func (k sdkKind) String() string {
+ switch k {
+ case sdkPrivate:
+ return "private"
+ case sdkNone:
+ return "none"
+ case sdkPublic:
+ return "public"
+ case sdkSystem:
+ return "system"
+ case sdkTest:
+ return "test"
+ case sdkCore:
+ return "core"
+ case sdkCorePlatform:
+ return "core_platform"
default:
- sdkVersion = v
+ return "invalid"
}
- if UseApiFingerprint(ctx, sdkVersion) {
- apiFingerprint := ApiFingerprintPath(ctx)
- sdkVersion += fmt.Sprintf(".$$(cat %s)", apiFingerprint.String())
- }
- return sdkVersion
}
-// 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
+// sdkVersion represents a specific version number of an SDK spec of a particular kind
+type sdkVersion int
+
+const (
+ // special version number for a not-yet-frozen SDK
+ sdkVersionCurrent sdkVersion = sdkVersion(android.FutureApiLevel)
+ // special version number to be used for SDK specs where version number doesn't
+ // make sense, e.g. "none", "", etc.
+ sdkVersionNone sdkVersion = sdkVersion(0)
+)
+
+// isCurrent checks if the sdkVersion refers to the not-yet-published version of an sdkKind
+func (v sdkVersion) isCurrent() bool {
+ return v == sdkVersionCurrent
+}
+
+// isNumbered checks if the sdkVersion refers to the published (a.k.a numbered) version of an sdkKind
+func (v sdkVersion) isNumbered() bool {
+ return !v.isCurrent() && v != sdkVersionNone
+}
+
+// String returns the string representation of this sdkVersion.
+func (v sdkVersion) String() string {
+ if v.isCurrent() {
+ return "current"
+ } else if v.isNumbered() {
+ return strconv.Itoa(int(v))
+ }
+ return "(no version)"
+}
+
+// asNumberString directly converts the numeric value of this sdk version as a string.
+// When isNumbered() is true, this method is the same as String(). However, for sdkVersionCurrent
+// and sdkVersionNone, this returns 10000 and 0 while String() returns "current" and "(no version"),
+// respectively.
+func (v sdkVersion) asNumberString() string {
+ return strconv.Itoa(int(v))
+}
+
+// sdkSpec represents the kind and the version of an SDK for a module to build against
+type sdkSpec struct {
+ kind sdkKind
+ version sdkVersion
+ raw string
+}
+
+// valid checks if this sdkSpec is well-formed. Note however that true doesn't mean that the
+// specified SDK actually exists.
+func (s sdkSpec) valid() bool {
+ return s.kind != sdkInvalid
+}
+
+// specified checks if this sdkSpec is well-formed and is not "".
+func (s sdkSpec) specified() bool {
+ return s.valid() && s.kind != sdkPrivate
+}
+
+// prebuiltSdkAvailableForUnbundledBuilt tells whether this sdkSpec can have a prebuilt SDK
+// that can be used for unbundled builds.
+func (s sdkSpec) prebuiltSdkAvailableForUnbundledBuild() bool {
+ // "", "none", and "core_platform" are not available for unbundled build
+ // as we don't/can't have prebuilt stub for the versions
+ return s.kind != sdkPrivate && s.kind != sdkNone && s.kind != sdkCorePlatform
+}
+
+// forPdkBuild converts this sdkSpec into another sdkSpec that is for the PDK builds.
+func (s sdkSpec) forPdkBuild(ctx android.EarlyModuleContext) sdkSpec {
+ // For PDK builds, use the latest SDK version instead of "current" or ""
+ if s.kind == sdkPrivate || s.kind == sdkPublic {
+ kind := s.kind
+ if kind == sdkPrivate {
+ // We don't have prebuilt SDK for private APIs, so use the public SDK
+ // instead. This looks odd, but that's how it has been done.
+ // TODO(b/148271073): investigate the need for this.
+ kind = sdkPublic
}
+ version := sdkVersion(LatestSdkVersionInt(ctx))
+ return sdkSpec{kind, version, s.raw}
}
+ return s
}
-func sdkVersionToNumberAsString(ctx android.EarlyModuleContext, v string) (string, error) {
- n, err := sdkVersionToNumber(ctx, v)
- if err != nil {
- return "", err
+// usePrebuilt determines whether prebuilt SDK should be used for this sdkSpec with the given context.
+func (s sdkSpec) usePrebuilt(ctx android.EarlyModuleContext) bool {
+ if s.version.isCurrent() {
+ // "current" can be built from source and be from prebuilt SDK
+ return ctx.Config().UnbundledBuildUsePrebuiltSdks()
+ } else if s.version.isNumbered() {
+ // sanity check
+ if s.kind != sdkPublic && s.kind != sdkSystem && s.kind != sdkTest {
+ panic(fmt.Errorf("prebuilt SDK is not not available for sdkKind=%q", s.kind))
+ return false
+ }
+ // numbered SDKs are always from prebuilt
+ return true
}
- return strconv.Itoa(n), nil
+ // "", "none", "core_platform" fall here
+ return false
+}
+
+// effectiveVersion converts an sdkSpec into the concrete sdkVersion that the module
+// should use. For modules targeting an unreleased SDK (meaning it does not yet have a number)
+// it returns android.FutureApiLevel(10000).
+func (s sdkSpec) effectiveVersion(ctx android.EarlyModuleContext) (sdkVersion, error) {
+ if !s.valid() {
+ return s.version, fmt.Errorf("invalid sdk version %q", s.raw)
+ }
+ if ctx.Config().IsPdkBuild() {
+ s = s.forPdkBuild(ctx)
+ }
+ if s.version.isNumbered() {
+ return s.version, nil
+ }
+ return sdkVersion(ctx.Config().DefaultAppTargetSdkInt()), nil
+}
+
+// effectiveVersionString converts an sdkSpec into the concrete version string that the module
+// should use. For modules targeting an unreleased SDK (meaning it does not yet have a number)
+// it returns the codename (P, Q, R, etc.)
+func (s sdkSpec) effectiveVersionString(ctx android.EarlyModuleContext) (string, error) {
+ ver, err := s.effectiveVersion(ctx)
+ if err == nil && int(ver) == ctx.Config().DefaultAppTargetSdkInt() {
+ return ctx.Config().DefaultAppTargetSdk(), nil
+ }
+ return ver.String(), err
+}
+
+func sdkSpecFrom(str string) sdkSpec {
+ switch str {
+ // special cases first
+ case "":
+ return sdkSpec{sdkPrivate, sdkVersionNone, str}
+ case "none":
+ return sdkSpec{sdkNone, sdkVersionNone, str}
+ case "core_platform":
+ return sdkSpec{sdkCorePlatform, sdkVersionNone, str}
+ default:
+ // the syntax is [kind_]version
+ sep := strings.LastIndex(str, "_")
+
+ var kindString string
+ if sep == 0 {
+ return sdkSpec{sdkInvalid, sdkVersionNone, str}
+ } else if sep == -1 {
+ kindString = ""
+ } else {
+ kindString = str[0:sep]
+ }
+ versionString := str[sep+1 : len(str)]
+
+ var kind sdkKind
+ switch kindString {
+ case "":
+ kind = sdkPublic
+ case "core":
+ kind = sdkCore
+ case "system":
+ kind = sdkSystem
+ case "test":
+ kind = sdkTest
+ default:
+ return sdkSpec{sdkInvalid, sdkVersionNone, str}
+ }
+
+ var version sdkVersion
+ if versionString == "current" {
+ version = sdkVersionCurrent
+ } else if i, err := strconv.Atoi(versionString); err == nil {
+ version = sdkVersion(i)
+ } else {
+ return sdkSpec{sdkInvalid, sdkVersionNone, str}
+ }
+
+ return sdkSpec{kind, version, str}
+ }
}
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)
+ sdkVersion := sdkContext.sdkVersion()
+ if !sdkVersion.valid() {
+ ctx.PropertyErrorf("sdk_version", "invalid version %q", sdkVersion.raw)
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)
+ if ctx.Config().IsPdkBuild() {
+ sdkVersion = sdkVersion.forPdkBuild(ctx)
+ }
+
+ if sdkVersion.usePrebuilt(ctx) {
+ dir := filepath.Join("prebuilts", "sdk", sdkVersion.version.String(), sdkVersion.kind.String())
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")
+ public_dir := filepath.Join("prebuilts", "sdk", sdkVersion.version.String(), "public")
aidl := filepath.Join(public_dir, "framework.aidl")
jarPath := android.ExistentPathForSource(ctx, jar)
aidlPath := android.ExistentPathForSource(ctx, aidl)
@@ -139,17 +298,17 @@
if (!jarPath.Valid() || !aidlPath.Valid()) && ctx.Config().AllowMissingDependencies() {
return sdkDep{
invalidVersion: true,
- bootclasspath: []string{fmt.Sprintf("sdk_%s_%s_android", api, v)},
+ bootclasspath: []string{fmt.Sprintf("sdk_%s_%s_android", sdkVersion.kind, sdkVersion.version.String())},
}
}
if !jarPath.Valid() {
- ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdk, jar)
+ ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdkVersion.raw, jar)
return sdkDep{}
}
if !aidlPath.Valid() {
- ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdk, aidl)
+ ctx.PropertyErrorf("sdk_version", "invalid sdk version %q, %q does not exist", sdkVersion.raw, aidl)
return sdkDep{}
}
@@ -173,31 +332,26 @@
// 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 {
+ if sdkVersion.kind == sdkSystem && sdkVersion.version.isNumbered() {
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) {
+ if len(allowed_versions) > 0 && !android.InList(sdkVersion.version.String(), allowed_versions) {
ctx.PropertyErrorf("sdk_version", "incompatible sdk version %q. System SDK version should be one of %q",
- v, allowed_versions)
+ sdkVersion.raw, allowed_versions)
}
}
- if ctx.Config().UnbundledBuildUsePrebuiltSdks() &&
- v != "" && v != "none" && v != "core_platform" {
- return toPrebuilt(v)
- }
-
- switch v {
- case "":
+ switch sdkVersion.kind {
+ case sdkPrivate:
return sdkDep{
useDefaultLibs: true,
frameworkResModule: "framework-res",
}
- case "none":
+ case sdkNone:
systemModules := sdkContext.systemModules()
if systemModules == "" {
ctx.PropertyErrorf("sdk_version",
@@ -214,22 +368,22 @@
systemModules: systemModules,
bootclasspath: []string{systemModules},
}
- case "core_platform":
+ case sdkCorePlatform:
return sdkDep{
useDefaultLibs: true,
frameworkResModule: "framework-res",
noFrameworksLibs: true,
}
- case "current":
+ case sdkPublic:
return toModule("android_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
- case "system_current":
+ case sdkSystem:
return toModule("android_system_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
- case "test_current":
+ case sdkTest:
return toModule("android_test_stubs_current", "framework-res", sdkFrameworkAidlPath(ctx))
- case "core_current":
+ case sdkCore:
return toModule("core.current.stubs", "", nil)
default:
- return toPrebuilt(v)
+ panic(fmt.Errorf("invalid sdk %q", sdkVersion.raw))
}
}
@@ -262,6 +416,15 @@
ctx.Config().Once(sdkVersionsKey, func() interface{} { return sdkVersions })
}
+func LatestSdkVersionInt(ctx android.EarlyModuleContext) int {
+ sdkVersions := ctx.Config().Get(sdkVersionsKey).([]int)
+ latestSdkVersion := 0
+ if len(sdkVersions) > 0 {
+ latestSdkVersion = sdkVersions[len(sdkVersions)-1]
+ }
+ return latestSdkVersion
+}
+
func sdkSingletonFactory() android.Singleton {
return sdkSingleton{}
}