// 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 android_sdk import ( "fmt" "io" "path/filepath" "strings" "github.com/google/blueprint" "github.com/google/blueprint/pathtools" "github.com/google/blueprint/proptools" "android/soong/android" "android/soong/cc/config" ) var pctx = android.NewPackageContext("android/soong/android_sdk") func init() { registerBuildComponents(android.InitRegistrationContext) } func registerBuildComponents(ctx android.RegistrationContext) { ctx.RegisterModuleType("android_sdk_repo_host", SdkRepoHostFactory) } type sdkRepoHost struct { android.ModuleBase android.PackagingBase properties sdkRepoHostProperties outputBaseName string outputFile android.OptionalPath } type remapProperties struct { From string To string } type sdkRepoHostProperties struct { // The top level directory to use for the SDK repo. Base_dir *string // List of src:dst mappings to rename files from `deps`. Deps_remap []remapProperties `android:"arch_variant"` // List of zip files to merge into the SDK repo. Merge_zips []string `android:"arch_variant,path"` // List of sources to include into the SDK repo. These are usually raw files, filegroups, // or genrules, as most built modules should be referenced via `deps`. Srcs []string `android:"arch_variant,path"` // List of files to strip. This should be a list of files, not modules. This happens after // `deps_remap` and `merge_zips` are applied, but before the `base_dir` is added. Strip_files []string `android:"arch_variant"` } // android_sdk_repo_host defines an Android SDK repo containing host tools. // // This implementation is trying to be a faithful reproduction of how these sdk-repos were produced // in the Make system, which may explain some of the oddities (like `strip_files` not being // automatic) func SdkRepoHostFactory() android.Module { return newSdkRepoHostModule() } func newSdkRepoHostModule() *sdkRepoHost { s := &sdkRepoHost{} s.AddProperties(&s.properties) android.InitPackageModule(s) android.InitAndroidMultiTargetsArchModule(s, android.HostSupported, android.MultilibCommon) return s } type dependencyTag struct { blueprint.BaseDependencyTag android.PackagingItemAlwaysDepTag } // TODO(b/201696252): Evaluate whether licenses should be propagated through this dependency. func (d dependencyTag) PropagateLicenses() bool { return false } var depTag = dependencyTag{} func (s *sdkRepoHost) DepsMutator(ctx android.BottomUpMutatorContext) { s.AddDeps(ctx, depTag) } func (s *sdkRepoHost) GenerateAndroidBuildActions(ctx android.ModuleContext) { dir := android.PathForModuleOut(ctx, "zip") outputZipFile := dir.Join(ctx, "output.zip") builder := android.NewRuleBuilder(pctx, ctx). Sbox(dir, android.PathForModuleOut(ctx, "out.sbox.textproto")). SandboxInputs() // Get files from modules listed in `deps` packageSpecs := s.GatherPackagingSpecs(ctx) // Handle `deps_remap` renames err := remapPackageSpecs(packageSpecs, s.properties.Deps_remap) if err != nil { ctx.PropertyErrorf("deps_remap", "%s", err.Error()) } s.CopySpecsToDir(ctx, builder, packageSpecs, dir) noticeFile := android.PathForModuleOut(ctx, "NOTICES.txt") android.BuildNoticeTextOutputFromLicenseMetadata( ctx, noticeFile, "", "", []string{ android.PathForModuleInstall(ctx, "sdk-repo").String() + "/", outputZipFile.String(), }) builder.Command().Text("cp"). Input(noticeFile). Text(filepath.Join(dir.String(), "NOTICE.txt")) // Handle `merge_zips` by extracting their contents into our tmpdir for _, zip := range android.PathsForModuleSrc(ctx, s.properties.Merge_zips) { builder.Command(). Text("unzip"). Flag("-DD"). Flag("-q"). FlagWithArg("-d ", dir.String()). Input(zip) } // Copy files from `srcs` into our tmpdir for _, src := range android.PathsForModuleSrc(ctx, s.properties.Srcs) { builder.Command(). Text("cp").Input(src).Flag(dir.Join(ctx, src.Rel()).String()) } // Handle `strip_files` by calling the necessary strip commands // // Note: this stripping logic was copied over from the old Make implementation // It's not using the same flags as the regular stripping support, nor does it // support the array of per-module stripping options. It would be nice if we // pulled the stripped versions from the CC modules, but that doesn't exist // for host tools today. (And not all the things we strip are CC modules today) if ctx.Darwin() { macStrip := config.MacStripPath(ctx) for _, strip := range s.properties.Strip_files { builder.Command(). Text(macStrip).Flag("-x"). Flag(dir.Join(ctx, strip).String()) } } else { llvmStrip := config.ClangPath(ctx, "bin/llvm-strip") llvmLib := config.ClangPath(ctx, "lib/x86_64-unknown-linux-gnu/libc++.so.1") for _, strip := range s.properties.Strip_files { cmd := builder.Command().Tool(llvmStrip).ImplicitTool(llvmLib) if !ctx.Windows() { cmd.Flag("-x") } cmd.Flag(dir.Join(ctx, strip).String()) } } // Fix up the line endings of all text files. This also removes executable permissions. builder.Command(). Text("find"). Flag(dir.String()). Flag("-name '*.aidl' -o -name '*.css' -o -name '*.html' -o -name '*.java'"). Flag("-o -name '*.js' -o -name '*.prop' -o -name '*.template'"). Flag("-o -name '*.txt' -o -name '*.windows' -o -name '*.xml' -print0"). // Using -n 500 for xargs to limit the max number of arguments per call to line_endings // to 500. This avoids line_endings failing with "arguments too long". Text("| xargs -0 -n 500 "). BuiltTool("line_endings"). Flag("unix") // Exclude some file types (roughly matching sdk.exclude.atree) builder.Command(). Text("find"). Flag(dir.String()). Flag("'('"). Flag("-name '.*' -o -name '*~' -o -name 'Makefile' -o -name 'Android.mk' -o"). Flag("-name '.*.swp' -o -name '.DS_Store' -o -name '*.pyc' -o -name 'OWNERS' -o"). Flag("-name 'MODULE_LICENSE_*' -o -name '*.ezt' -o -name 'Android.bp'"). Flag("')' -print0"). Text("| xargs -0 -r rm -rf") builder.Command(). Text("find"). Flag(dir.String()). Flag("-name '_*' ! -name '__*' -print0"). Text("| xargs -0 -r rm -rf") if ctx.Windows() { // Fix EOL chars to make window users happy builder.Command(). Text("find"). Flag(dir.String()). Flag("-maxdepth 2 -name '*.bat' -type f -print0"). Text("| xargs -0 -r unix2dos") } // Zip up our temporary directory as the sdk-repo builder.Command(). BuiltTool("soong_zip"). FlagWithOutput("-o ", outputZipFile). FlagWithArg("-P ", proptools.StringDefault(s.properties.Base_dir, ".")). FlagWithArg("-C ", dir.String()). FlagWithArg("-D ", dir.String()) builder.Command().Text("rm").Flag("-rf").Text(dir.String()) builder.Build("build_sdk_repo", "Creating sdk-repo-"+s.BaseModuleName()) osName := ctx.Os().String() if osName == "linux_glibc" { osName = "linux" } name := fmt.Sprintf("sdk-repo-%s-%s", osName, s.BaseModuleName()) s.outputBaseName = name s.outputFile = android.OptionalPathForPath(outputZipFile) ctx.InstallFile(android.PathForModuleInstall(ctx, "sdk-repo"), name+".zip", outputZipFile) } func (s *sdkRepoHost) AndroidMk() android.AndroidMkData { return android.AndroidMkData{ Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { fmt.Fprintln(w, ".PHONY:", name, "sdk_repo", "sdk-repo-"+name) fmt.Fprintln(w, "sdk_repo", "sdk-repo-"+name+":", strings.Join(s.FilesToInstall().Strings(), " ")) fmt.Fprintf(w, "$(call dist-for-goals,sdk_repo sdk-repo-%s,%s:%s-FILE_NAME_TAG_PLACEHOLDER.zip)\n\n", s.BaseModuleName(), s.outputFile.String(), s.outputBaseName) }, } } func remapPackageSpecs(specs map[string]android.PackagingSpec, remaps []remapProperties) error { for _, remap := range remaps { for path, spec := range specs { if match, err := pathtools.Match(remap.From, path); err != nil { return fmt.Errorf("Error parsing %q: %v", remap.From, err) } else if match { newPath := remap.To if pathtools.IsGlob(remap.From) { rel, err := filepath.Rel(constantPartOfPattern(remap.From), path) if err != nil { return fmt.Errorf("Error handling %q", path) } newPath = filepath.Join(remap.To, rel) } delete(specs, path) spec.SetRelPathInPackage(newPath) specs[newPath] = spec } } } return nil } func constantPartOfPattern(pattern string) string { ret := "" for pattern != "" { var first string first, pattern = splitFirst(pattern) if pathtools.IsGlob(first) { return ret } ret = filepath.Join(ret, first) } return ret } func splitFirst(path string) (string, string) { i := strings.IndexRune(path, filepath.Separator) if i < 0 { return path, "" } return path[:i], path[i+1:] }