| // Copyright (C) 2021 The Android Open Source Project |
| // |
| // 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 aidl |
| |
| import ( |
| "android/soong/android" |
| |
| "fmt" |
| "io" |
| "path/filepath" |
| "strconv" |
| "strings" |
| |
| "github.com/google/blueprint" |
| "github.com/google/blueprint/proptools" |
| ) |
| |
| var ( |
| aidlDumpApiRule = pctx.StaticRule("aidlDumpApiRule", blueprint.RuleParams{ |
| Command: `rm -rf "${outDir}" && mkdir -p "${outDir}" && ` + |
| `${aidlCmd} --dumpapi --structured ${imports} ${optionalFlags} --out ${outDir} ${in} && ` + |
| `${aidlHashGen} ${outDir} ${latestVersion} ${hashFile}`, |
| CommandDeps: []string{"${aidlCmd}", "${aidlHashGen}"}, |
| }, "optionalFlags", "imports", "outDir", "hashFile", "latestVersion") |
| |
| aidlCheckApiRule = pctx.StaticRule("aidlCheckApiRule", blueprint.RuleParams{ |
| Command: `(${aidlCmd} ${optionalFlags} --checkapi=${checkApiLevel} ${imports} ${old} ${new} && touch ${out}) || ` + |
| `(cat ${messageFile} && exit 1)`, |
| CommandDeps: []string{"${aidlCmd}"}, |
| Description: "AIDL CHECK API: ${new} against ${old}", |
| }, "optionalFlags", "imports", "old", "new", "messageFile", "checkApiLevel") |
| |
| aidlVerifyHashRule = pctx.StaticRule("aidlVerifyHashRule", blueprint.RuleParams{ |
| Command: `if [ $$(cd '${apiDir}' && { find ./ -name "*.aidl" -print0 | LC_ALL=C sort -z | xargs -0 sha1sum && echo ${version}; } | sha1sum | cut -d " " -f 1) = $$(tail -1 '${hashFile}') ]; then ` + |
| `touch ${out}; else cat '${messageFile}' && exit 1; fi`, |
| Description: "Verify ${apiDir} files have not been modified", |
| }, "apiDir", "version", "messageFile", "hashFile") |
| ) |
| |
| type aidlApiProperties struct { |
| BaseName string |
| Srcs []string `android:"path"` |
| AidlRoot string // base directory for the input aidl file |
| Stability *string |
| Imports []string |
| Versions []string |
| Dumpapi DumpApiProperties |
| } |
| |
| type aidlApi struct { |
| android.ModuleBase |
| |
| properties aidlApiProperties |
| |
| // for triggering api check for version X against version X-1 |
| checkApiTimestamps android.WritablePaths |
| |
| // for triggering updating current API |
| updateApiTimestamp android.WritablePath |
| |
| // for triggering check that files have not been modified |
| checkHashTimestamps android.WritablePaths |
| |
| // for triggering freezing API as the new version |
| freezeApiTimestamp android.WritablePath |
| |
| // for checking for active development on unfrozen version |
| hasDevelopment android.WritablePath |
| } |
| |
| func (m *aidlApi) apiDir() string { |
| return filepath.Join(aidlApiDir, m.properties.BaseName) |
| } |
| |
| // `m <iface>-freeze-api` will freeze ToT as this version |
| func (m *aidlApi) nextVersion() string { |
| return nextVersion(m.properties.Versions) |
| } |
| |
| type apiDump struct { |
| version string |
| dir android.Path |
| files android.Paths |
| hashFile android.OptionalPath |
| } |
| |
| func (m *aidlApi) getImports(ctx android.ModuleContext, version string) map[string]string { |
| iface := ctx.GetDirectDepWithTag(m.properties.BaseName, interfaceDep).(*aidlInterface) |
| return iface.getImports(version) |
| } |
| |
| func (m *aidlApi) createApiDumpFromSource(ctx android.ModuleContext) apiDump { |
| srcs, imports := getPaths(ctx, m.properties.Srcs, m.properties.AidlRoot) |
| |
| if ctx.Failed() { |
| return apiDump{} |
| } |
| |
| // dumpapi uses imports for ToT("") version |
| deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) |
| imports = append(imports, deps.imports...) |
| |
| var apiDir android.WritablePath |
| var apiFiles android.WritablePaths |
| var hashFile android.WritablePath |
| |
| apiDir = android.PathForModuleOut(ctx, "dump") |
| for _, src := range srcs { |
| outFile := android.PathForModuleOut(ctx, "dump", src.Rel()) |
| apiFiles = append(apiFiles, outFile) |
| } |
| hashFile = android.PathForModuleOut(ctx, "dump", ".hash") |
| |
| var optionalFlags []string |
| if m.properties.Stability != nil { |
| optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) |
| } |
| if proptools.Bool(m.properties.Dumpapi.No_license) { |
| optionalFlags = append(optionalFlags, "--no_license") |
| } |
| optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) |
| |
| version := nextVersion(m.properties.Versions) |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlDumpApiRule, |
| Outputs: append(apiFiles, hashFile), |
| Inputs: srcs, |
| Implicits: deps.preprocessed, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "imports": strings.Join(wrap("-I", imports, ""), " "), |
| "outDir": apiDir.String(), |
| "hashFile": hashFile.String(), |
| "latestVersion": versionForHashGen(version), |
| }, |
| }) |
| return apiDump{version, apiDir, apiFiles.Paths(), android.OptionalPathForPath(hashFile)} |
| } |
| |
| func wrapWithDiffCheckIfElse(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), elseBlock func(*android.RuleBuilderCommand)) { |
| rbc := rb.Command() |
| rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") |
| writer(rbc) |
| rbc.Text("; else") |
| elseBlock(rbc) |
| rbc.Text("; fi") |
| } |
| |
| func wrapWithDiffCheckIf(m *aidlApi, rb *android.RuleBuilder, writer func(*android.RuleBuilderCommand), needToWrap bool) { |
| rbc := rb.Command() |
| if needToWrap { |
| rbc.Text("if [ \"$(cat ").Input(m.hasDevelopment).Text(")\" = \"1\" ]; then") |
| } |
| writer(rbc) |
| if needToWrap { |
| rbc.Text("; fi") |
| } |
| } |
| |
| // Migrate `versions` into `version_with_info`, and then append a version if it isn't nil |
| func (m *aidlApi) migrateAndAppendVersion(ctx android.ModuleContext, rb *android.RuleBuilder, version *string, transitive bool) { |
| isFreezingApi := version != nil |
| |
| // Remove `versions` property which is deprecated. |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions -remove-property"). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| |
| var iface *aidlInterface |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep).(type) { |
| case interfaceDepTag: |
| iface = dep.(*aidlInterface) |
| } |
| }) |
| if iface == nil { |
| ctx.ModuleErrorf("aidl_interface %s doesn't exist", m.properties.BaseName) |
| return |
| } |
| var versions []string |
| if len(iface.properties.Versions_with_info) == 0 { |
| versions = append(versions, iface.getVersions()...) |
| } |
| if isFreezingApi { |
| versions = append(versions, *version) |
| } |
| for _, v := range versions { |
| importIfaces := make(map[string]*aidlInterface) |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| if _, ok := ctx.OtherModuleDependencyTag(dep).(importInterfaceDepTag); ok { |
| other := dep.(*aidlInterface) |
| importIfaces[other.BaseModuleName()] = other |
| } |
| }) |
| imports := make([]string, 0, len(iface.getImportsForVersion(v))) |
| needTransitiveFreeze := isFreezingApi && v == *version && transitive |
| |
| if needTransitiveFreeze { |
| importApis := make(map[string]*aidlApi) |
| ctx.WalkDeps(func(child android.Module, parent android.Module) bool { |
| if api, ok := child.(*aidlApi); ok { |
| moduleName := strings.TrimSuffix(api.Name(), aidlApiSuffix) |
| if _, ok := importIfaces[moduleName]; ok { |
| importApis[moduleName] = api |
| return false |
| } |
| } |
| return true |
| }) |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions_with_info -add-literal '"). |
| Text(fmt.Sprintf(`{version: "%s", imports: [`, v)) |
| |
| for _, im := range iface.getImportsForVersion(v) { |
| moduleName, version := parseModuleWithVersion(im) |
| |
| // Invoke an imported interface's freeze-api only if it depends on ToT version explicitly or implicitly. |
| if version == importIfaces[moduleName].nextVersion() || !hasVersionSuffix(im) { |
| rb.Command().Text(fmt.Sprintf(`echo "Call %s-freeze-api because %s depends on %s."`, moduleName, m.properties.BaseName, moduleName)) |
| rbc.Implicit(importApis[moduleName].freezeApiTimestamp) |
| } |
| if hasVersionSuffix(im) { |
| rbc.Text(fmt.Sprintf(`"%s",`, im)) |
| } else { |
| rbc.Text("\"" + im + "-V'" + `$(if [ "$(cat `). |
| Input(importApis[im].hasDevelopment). |
| Text(`)" = "1" ]; then echo "` + importIfaces[im].nextVersion() + |
| `"; else echo "` + importIfaces[im].latestVersion() + `"; fi)'", `) |
| } |
| } |
| rbc.Text("]}' "). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| } else { |
| for _, im := range iface.getImportsForVersion(v) { |
| if hasVersionSuffix(im) { |
| imports = append(imports, im) |
| } else { |
| imports = append(imports, im+"-V"+importIfaces[im].latestVersion()) |
| } |
| } |
| importsStr := strings.Join(wrap(`"`, imports, `"`), ", ") |
| data := fmt.Sprintf(`{version: "%s", imports: [%s]}`, v, importsStr) |
| |
| // Also modify Android.bp file to add the new version to the 'versions_with_info' property. |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.BuiltTool("bpmodify"). |
| Text("-w -m " + m.properties.BaseName). |
| Text("-parameter versions_with_info -add-literal '" + data + "' "). |
| Text(android.PathForModuleSrc(ctx, "Android.bp").String()) |
| }, isFreezingApi) |
| } |
| } |
| } |
| |
| func (m *aidlApi) makeApiDumpAsVersion(ctx android.ModuleContext, dump apiDump, version string, latestVersionDump *apiDump) android.WritablePath { |
| creatingNewVersion := version != currentVersion |
| moduleDir := android.PathForModuleSrc(ctx).String() |
| targetDir := filepath.Join(moduleDir, m.apiDir(), version) |
| rb := android.NewRuleBuilder(pctx, ctx) |
| transitive := ctx.Config().IsEnvTrue("AIDL_TRANSITIVE_FREEZE") |
| var actionWord string |
| if creatingNewVersion { |
| actionWord = "Making" |
| // We are asked to create a new version. But before doing that, check if the given |
| // dump is the same as the latest version. If so, don't create a new version, |
| // otherwise we will be unnecessarily creating many versions. |
| // Copy the given dump to the target directory only when the equality check failed |
| // (i.e. `has_development` file contains "1"). |
| wrapWithDiffCheckIf(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text("mkdir -p " + targetDir + " && "). |
| Text("cp -rf " + dump.dir.String() + "/. " + targetDir).Implicits(dump.files) |
| }, true /* needToWrap */) |
| wrapWithDiffCheckIfElse(m, rb, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text(fmt.Sprintf(`echo "There is change between ToT version and the latest stable version. Freezing %s-V%s."`, m.properties.BaseName, version)) |
| }, func(rbc *android.RuleBuilderCommand) { |
| rbc.Text(fmt.Sprintf(`echo "There is no change from the latest stable version of %s. Nothing happened."`, m.properties.BaseName)) |
| }) |
| m.migrateAndAppendVersion(ctx, rb, &version, transitive) |
| } else { |
| actionWord = "Updating" |
| // We are updating the current version. Don't copy .hash to the current dump |
| rb.Command().Text("mkdir -p " + targetDir) |
| rb.Command().Text("rm -rf " + targetDir + "/*") |
| rb.Command().Text("cp -rf " + dump.dir.String() + "/* " + targetDir).Implicits(dump.files) |
| |
| m.migrateAndAppendVersion(ctx, rb, nil, false) |
| } |
| |
| timestampFile := android.PathForModuleOut(ctx, "updateapi_"+version+".timestamp") |
| rb.Command().Text("touch").Output(timestampFile) |
| |
| rb.Build("dump_aidl_api_"+m.properties.BaseName+"_"+version, actionWord+" AIDL API dump version "+version+" for "+m.properties.BaseName+" (see "+targetDir+")") |
| return timestampFile |
| } |
| |
| type deps struct { |
| preprocessed android.Paths |
| implicits android.Paths |
| imports []string |
| } |
| |
| // calculates import flags(-I) from deps. |
| // When the target is ToT, use ToT of imported interfaces. If not, we use "current" snapshot of |
| // imported interfaces. |
| func getDeps(ctx android.ModuleContext, versionedImports map[string]string) deps { |
| var deps deps |
| ctx.VisitDirectDeps(func(dep android.Module) { |
| switch ctx.OtherModuleDependencyTag(dep).(type) { |
| case importInterfaceDepTag: |
| iface := dep.(*aidlInterface) |
| if version, ok := versionedImports[iface.BaseModuleName()]; ok { |
| if iface.preprocessed[version] == nil { |
| ctx.ModuleErrorf("can't import %v's preprocessed(version=%v)", iface.BaseModuleName(), version) |
| } |
| deps.preprocessed = append(deps.preprocessed, iface.preprocessed[version]) |
| } |
| case interfaceDepTag: |
| iface := dep.(*aidlInterface) |
| deps.imports = append(deps.imports, iface.properties.Include_dirs...) |
| case apiDepTag: |
| api := dep.(*aidlApi) |
| // add imported module's checkapiTimestamps as implicits to make sure that imported apiDump is up-to-date |
| deps.implicits = append(deps.implicits, api.checkApiTimestamps.Paths()...) |
| deps.implicits = append(deps.implicits, api.checkHashTimestamps.Paths()...) |
| } |
| }) |
| return deps |
| } |
| |
| func (m *aidlApi) checkApi(ctx android.ModuleContext, oldDump, newDump apiDump, checkApiLevel string, messageFile android.Path) android.WritablePath { |
| newVersion := newDump.dir.Base() |
| timestampFile := android.PathForModuleOut(ctx, "checkapi_"+newVersion+".timestamp") |
| |
| // --checkapi(old,new) should use imports for "new" |
| deps := getDeps(ctx, m.getImports(ctx, newDump.version)) |
| var implicits android.Paths |
| implicits = append(implicits, deps.implicits...) |
| implicits = append(implicits, deps.preprocessed...) |
| implicits = append(implicits, oldDump.files...) |
| implicits = append(implicits, newDump.files...) |
| implicits = append(implicits, messageFile) |
| |
| var optionalFlags []string |
| if m.properties.Stability != nil { |
| optionalFlags = append(optionalFlags, "--stability", *m.properties.Stability) |
| } |
| optionalFlags = append(optionalFlags, wrap("-p", deps.preprocessed.Strings(), "")...) |
| |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlCheckApiRule, |
| Implicits: implicits, |
| Output: timestampFile, |
| Args: map[string]string{ |
| "optionalFlags": strings.Join(optionalFlags, " "), |
| "imports": strings.Join(wrap("-I", deps.imports, ""), " "), |
| "old": oldDump.dir.String(), |
| "new": newDump.dir.String(), |
| "messageFile": messageFile.String(), |
| "checkApiLevel": checkApiLevel, |
| }, |
| }) |
| return timestampFile |
| } |
| |
| func (m *aidlApi) checkCompatibility(ctx android.ModuleContext, oldDump, newDump apiDump) android.WritablePath { |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_compatibility.txt") |
| return m.checkApi(ctx, oldDump, newDump, "compatible", messageFile) |
| } |
| |
| func (m *aidlApi) checkEquality(ctx android.ModuleContext, oldDump apiDump, newDump apiDump) android.WritablePath { |
| // Use different messages depending on whether platform SDK is finalized or not. |
| // In case when it is finalized, we should never allow updating the already frozen API. |
| // If it's not finalized, we let users to update the current version by invoking |
| // `m <name>-update-api`. |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality.txt") |
| sdkIsFinal := !ctx.Config().DefaultAppTargetSdk(ctx).IsPreview() |
| if sdkIsFinal { |
| messageFile = android.PathForSource(ctx, "system/tools/aidl/build/message_check_equality_release.txt") |
| } |
| formattedMessageFile := android.PathForModuleOut(ctx, "message_check_equality.txt") |
| rb := android.NewRuleBuilder(pctx, ctx) |
| rb.Command().Text("sed").Flag(" s/%s/" + m.properties.BaseName + "/g ").Input(messageFile).Text(" > ").Output(formattedMessageFile) |
| rb.Build("format_message_"+m.properties.BaseName, "") |
| |
| return m.checkApi(ctx, oldDump, newDump, "equal", formattedMessageFile) |
| } |
| |
| func (m *aidlApi) checkIntegrity(ctx android.ModuleContext, dump apiDump) android.WritablePath { |
| version := dump.dir.Base() |
| timestampFile := android.PathForModuleOut(ctx, "checkhash_"+version+".timestamp") |
| messageFile := android.PathForSource(ctx, "system/tools/aidl/build/message_check_integrity.txt") |
| |
| var implicits android.Paths |
| implicits = append(implicits, dump.files...) |
| implicits = append(implicits, dump.hashFile.Path()) |
| implicits = append(implicits, messageFile) |
| ctx.Build(pctx, android.BuildParams{ |
| Rule: aidlVerifyHashRule, |
| Implicits: implicits, |
| Output: timestampFile, |
| Args: map[string]string{ |
| "apiDir": dump.dir.String(), |
| "version": versionForHashGen(version), |
| "hashFile": dump.hashFile.Path().String(), |
| "messageFile": messageFile.String(), |
| }, |
| }) |
| return timestampFile |
| } |
| |
| func (m *aidlApi) checkForDevelopment(ctx android.ModuleContext, latestVersionDump *apiDump, totDump apiDump) android.WritablePath { |
| hasDevPath := android.PathForModuleOut(ctx, "has_development") |
| rb := android.NewRuleBuilder(pctx, ctx) |
| rb.Command().Text("rm -f " + hasDevPath.String()) |
| if latestVersionDump != nil { |
| hasDevCommand := rb.Command() |
| hasDevCommand.BuiltTool("aidl").FlagWithArg("--checkapi=", "equal") |
| if m.properties.Stability != nil { |
| hasDevCommand.FlagWithArg("--stability ", *m.properties.Stability) |
| } |
| // checkapi(latest, tot) should use imports for nextVersion(=tot) |
| deps := getDeps(ctx, m.getImports(ctx, m.nextVersion())) |
| hasDevCommand. |
| FlagForEachArg("-I", deps.imports).Implicits(deps.implicits). |
| FlagForEachInput("-p", deps.preprocessed). |
| Text(latestVersionDump.dir.String()).Implicits(latestVersionDump.files). |
| Text(totDump.dir.String()).Implicits(totDump.files). |
| Text("2> /dev/null; echo $? >").Output(hasDevPath) |
| } else { |
| rb.Command().Text("echo 1 >").Output(hasDevPath) |
| } |
| rb.Build("check_for_development", "") |
| return hasDevPath |
| } |
| |
| func (m *aidlApi) GenerateAndroidBuildActions(ctx android.ModuleContext) { |
| // An API dump is created from source and it is compared against the API dump of the |
| // 'current' (yet-to-be-finalized) version. By checking this we enforce that any change in |
| // the AIDL interface is gated by the AIDL API review even before the interface is frozen as |
| // a new version. |
| totApiDump := m.createApiDumpFromSource(ctx) |
| currentApiDir := android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion) |
| var currentApiDump apiDump |
| if currentApiDir.Valid() { |
| currentApiDump = apiDump{ |
| version: nextVersion(m.properties.Versions), |
| dir: currentApiDir.Path(), |
| files: ctx.Glob(filepath.Join(currentApiDir.Path().String(), "**/*.aidl"), nil), |
| hashFile: android.ExistentPathForSource(ctx, ctx.ModuleDir(), m.apiDir(), currentVersion, ".hash"), |
| } |
| checked := m.checkEquality(ctx, currentApiDump, totApiDump) |
| m.checkApiTimestamps = append(m.checkApiTimestamps, checked) |
| } else { |
| // The "current" directory might not exist, in case when the interface is first created. |
| // Instruct user to create one by executing `m <name>-update-api`. |
| rb := android.NewRuleBuilder(pctx, ctx) |
| ifaceName := m.properties.BaseName |
| rb.Command().Text(fmt.Sprintf(`echo "API dump for the current version of AIDL interface %s does not exist."`, ifaceName)) |
| rb.Command().Text(fmt.Sprintf(`echo Run "m %s-update-api", or add "unstable: true" to the build rule `+ |
| `for the interface if it does not need to be versioned`, ifaceName)) |
| // This file will never be created. Otherwise, the build will pass simply by running 'm; m'. |
| alwaysChecked := android.PathForModuleOut(ctx, "checkapi_current.timestamp") |
| rb.Command().Text("false").ImplicitOutput(alwaysChecked) |
| rb.Build("check_current_aidl_api", "") |
| m.checkApiTimestamps = append(m.checkApiTimestamps, alwaysChecked) |
| } |
| |
| // Also check that version X is backwards compatible with version X-1. |
| // "current" is checked against the latest version. |
| var dumps []apiDump |
| for _, ver := range m.properties.Versions { |
| apiDir := filepath.Join(ctx.ModuleDir(), m.apiDir(), ver) |
| apiDirPath := android.ExistentPathForSource(ctx, apiDir) |
| if apiDirPath.Valid() { |
| hashFilePath := filepath.Join(apiDir, ".hash") |
| dump := apiDump{ |
| version: ver, |
| dir: apiDirPath.Path(), |
| files: ctx.Glob(filepath.Join(apiDirPath.String(), "**/*.aidl"), nil), |
| hashFile: android.ExistentPathForSource(ctx, hashFilePath), |
| } |
| if !dump.hashFile.Valid() { |
| // We should show the source path of hash_gen because aidl_hash_gen cannot be built due to build error. |
| cmd := fmt.Sprintf(`(croot && system/tools/aidl/build/hash_gen.sh %s %s %s)`, apiDir, versionForHashGen(ver), hashFilePath) |
| ctx.ModuleErrorf("A frozen aidl_interface must have '.hash' file, but %s-V%s doesn't have it. Use the command below to generate hash.\n%s\n", |
| m.properties.BaseName, ver, cmd) |
| } |
| dumps = append(dumps, dump) |
| } else if ctx.Config().AllowMissingDependencies() { |
| ctx.AddMissingDependencies([]string{apiDir}) |
| } else { |
| ctx.ModuleErrorf("API version %s path %s does not exist", ver, apiDir) |
| } |
| } |
| var latestVersionDump *apiDump |
| if len(dumps) >= 1 { |
| latestVersionDump = &dumps[len(dumps)-1] |
| } |
| if currentApiDir.Valid() { |
| dumps = append(dumps, currentApiDump) |
| } |
| for i, _ := range dumps { |
| if dumps[i].hashFile.Valid() { |
| checkHashTimestamp := m.checkIntegrity(ctx, dumps[i]) |
| m.checkHashTimestamps = append(m.checkHashTimestamps, checkHashTimestamp) |
| } |
| |
| if i == 0 { |
| continue |
| } |
| checked := m.checkCompatibility(ctx, dumps[i-1], dumps[i]) |
| m.checkApiTimestamps = append(m.checkApiTimestamps, checked) |
| } |
| |
| // Check for active development on the unfrozen version |
| m.hasDevelopment = m.checkForDevelopment(ctx, latestVersionDump, totApiDump) |
| |
| // API dump from source is updated to the 'current' version. Triggered by `m <name>-update-api` |
| m.updateApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, currentVersion, nil) |
| |
| // API dump from source is frozen as the next stable version. Triggered by `m <name>-freeze-api` |
| nextVersion := m.nextVersion() |
| m.freezeApiTimestamp = m.makeApiDumpAsVersion(ctx, totApiDump, nextVersion, latestVersionDump) |
| } |
| |
| func (m *aidlApi) AndroidMk() android.AndroidMkData { |
| return android.AndroidMkData{ |
| Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { |
| android.WriteAndroidMkData(w, data) |
| targetName := m.properties.BaseName + "-freeze-api" |
| fmt.Fprintln(w, ".PHONY:", targetName) |
| fmt.Fprintln(w, targetName+":", m.freezeApiTimestamp.String()) |
| |
| targetName = m.properties.BaseName + "-update-api" |
| fmt.Fprintln(w, ".PHONY:", targetName) |
| fmt.Fprintln(w, targetName+":", m.updateApiTimestamp.String()) |
| }, |
| } |
| } |
| |
| func (m *aidlApi) DepsMutator(ctx android.BottomUpMutatorContext) { |
| ctx.AddReverseDependency(ctx.Module(), nil, aidlMetadataSingletonName) |
| } |
| |
| func aidlApiFactory() android.Module { |
| m := &aidlApi{} |
| m.AddProperties(&m.properties) |
| android.InitAndroidModule(m) |
| return m |
| } |
| |
| func addApiModule(mctx android.LoadHookContext, i *aidlInterface) string { |
| apiModule := i.ModuleBase.Name() + aidlApiSuffix |
| srcs, aidlRoot := i.srcsForVersion(mctx, i.nextVersion()) |
| mctx.CreateModule(aidlApiFactory, &nameProperties{ |
| Name: proptools.StringPtr(apiModule), |
| }, &aidlApiProperties{ |
| BaseName: i.ModuleBase.Name(), |
| Srcs: srcs, |
| AidlRoot: aidlRoot, |
| Stability: i.properties.Stability, |
| Imports: i.properties.Imports, |
| Versions: i.getVersions(), |
| Dumpapi: i.properties.Dumpapi, |
| }) |
| return apiModule |
| } |
| |
| func versionForHashGen(ver string) string { |
| // aidlHashGen uses the version before current version. If it has never been frozen, return 'latest-version'. |
| verInt, _ := strconv.Atoi(ver) |
| if verInt > 1 { |
| return strconv.Itoa(verInt - 1) |
| } |
| return "latest-version" |
| } |
| |
| func init() { |
| android.RegisterSingletonType("aidl-freeze-api", freezeApiSingletonFactory) |
| } |
| |
| func freezeApiSingletonFactory() android.Singleton { |
| return &freezeApiSingleton{} |
| } |
| |
| type freezeApiSingleton struct{} |
| |
| func (f *freezeApiSingleton) GenerateBuildActions(ctx android.SingletonContext) { |
| var files android.Paths |
| ctx.VisitAllModules(func(module android.Module) { |
| if !module.Enabled() { |
| return |
| } |
| if m, ok := module.(*aidlApi); ok { |
| ownersToFreeze := strings.Fields(ctx.Config().Getenv("AIDL_FREEZE_OWNERS")) |
| var shouldBeFrozen bool |
| if len(ownersToFreeze) > 0 { |
| shouldBeFrozen = android.InList(m.Owner(), ownersToFreeze) |
| } else { |
| shouldBeFrozen = m.Owner() == "" |
| } |
| if shouldBeFrozen { |
| files = append(files, m.freezeApiTimestamp) |
| } |
| } |
| }) |
| ctx.Phony("aidl-freeze-api", files...) |
| } |
