| // Copyright (C) 2019 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 sdk |
| |
| import ( |
| "fmt" |
| "io" |
| "path/filepath" |
| "strconv" |
| "strings" |
| |
| "github.com/google/blueprint/proptools" |
| |
| "android/soong/android" |
| "android/soong/java" |
| ) |
| |
| var pctx = android.NewPackageContext("android/soong/sdk") |
| |
| // generatedFile abstracts operations for writing contents into a file and emit a build rule |
| // for the file. |
| type generatedFile struct { |
| path android.OutputPath |
| content strings.Builder |
| } |
| |
| func newGeneratedFile(ctx android.ModuleContext, name string) *generatedFile { |
| return &generatedFile{ |
| path: android.PathForModuleOut(ctx, name).OutputPath, |
| } |
| } |
| |
| func (gf *generatedFile) printfln(format string, args ...interface{}) { |
| // ninja consumes newline characters in rspfile_content. Prevent it by |
| // escaping the backslash in the newline character. The extra backshash |
| // is removed when the rspfile is written to the actual script file |
| fmt.Fprintf(&(gf.content), format+"\\n", args...) |
| } |
| |
| func (gf *generatedFile) build(pctx android.PackageContext, ctx android.BuilderContext, implicits android.Paths) { |
| rb := android.NewRuleBuilder() |
| // convert \\n to \n |
| rb.Command(). |
| Implicits(implicits). |
| Text("echo").Text(proptools.ShellEscape(gf.content.String())). |
| Text("| sed 's/\\\\n/\\n/g' >").Output(gf.path) |
| rb.Command(). |
| Text("chmod a+x").Output(gf.path) |
| rb.Build(pctx, ctx, gf.path.Base(), "Build "+gf.path.Base()) |
| } |
| |
| func (s *sdk) javaMemberNames(ctx android.ModuleContext) []string { |
| result := []string{} |
| ctx.VisitDirectDeps(func(m android.Module) { |
| if _, ok := m.(*java.Library); ok { |
| result = append(result, m.Name()) |
| } |
| }) |
| return result |
| } |
| |
| // buildAndroidBp creates the blueprint file that defines prebuilt modules for each of |
| // the SDK members, and the sdk_snapshot module for the specified version |
| func (s *sdk) buildAndroidBp(ctx android.ModuleContext, version string) android.OutputPath { |
| bp := newGeneratedFile(ctx, "blueprint-"+version+".sh") |
| |
| makePrebuiltName := func(name string) string { |
| return ctx.ModuleName() + "_" + name + string(android.SdkVersionSeparator) + version |
| } |
| |
| javaLibs := s.javaMemberNames(ctx) |
| for _, name := range javaLibs { |
| prebuiltName := makePrebuiltName(name) |
| jar := filepath.Join("java", name, "stub.jar") |
| |
| bp.printfln("java_import {") |
| bp.printfln(" name: %q,", prebuiltName) |
| bp.printfln(" jars: [%q],", jar) |
| bp.printfln(" sdk_member_name: %q,", name) |
| bp.printfln("}") |
| bp.printfln("") |
| |
| // This module is for the case when the source tree for the unversioned module |
| // doesn't exist (i.e. building in an unbundled tree). "prefer:" is set to false |
| // so that this module does not eclipse the unversioned module if it exists. |
| bp.printfln("java_import {") |
| bp.printfln(" name: %q,", name) |
| bp.printfln(" jars: [%q],", jar) |
| bp.printfln(" prefer: false,") |
| bp.printfln("}") |
| bp.printfln("") |
| |
| } |
| |
| // TODO(jiyong): emit cc_prebuilt_library_shared for the native libs |
| |
| bp.printfln("sdk_snapshot {") |
| bp.printfln(" name: %q,", ctx.ModuleName()+string(android.SdkVersionSeparator)+version) |
| bp.printfln(" java_libs: [") |
| for _, n := range javaLibs { |
| bp.printfln(" %q,", makePrebuiltName(n)) |
| } |
| bp.printfln(" ],") |
| // TODO(jiyong): emit native_shared_libs |
| bp.printfln("}") |
| bp.printfln("") |
| |
| bp.build(pctx, ctx, nil) |
| return bp.path |
| } |
| |
| func (s *sdk) buildScript(ctx android.ModuleContext, version string) android.OutputPath { |
| sh := newGeneratedFile(ctx, "update_prebuilt-"+version+".sh") |
| |
| snapshotRoot := filepath.Join(ctx.ModuleDir(), version) |
| aidlIncludeDir := filepath.Join(snapshotRoot, "aidl") |
| javaStubsDir := filepath.Join(snapshotRoot, "java") |
| |
| sh.printfln("#!/bin/bash") |
| sh.printfln("echo Updating snapshot of %s in %s", ctx.ModuleName(), snapshotRoot) |
| sh.printfln("pushd $ANDROID_BUILD_TOP > /dev/null") |
| sh.printfln("rm -rf %s", snapshotRoot) |
| sh.printfln("mkdir -p %s", aidlIncludeDir) |
| sh.printfln("mkdir -p %s", javaStubsDir) |
| // TODO(jiyong): mkdir the 'native' dir |
| |
| var implicits android.Paths |
| ctx.VisitDirectDeps(func(m android.Module) { |
| if javaLib, ok := m.(*java.Library); ok { |
| headerJars := javaLib.HeaderJars() |
| if len(headerJars) != 1 { |
| panic(fmt.Errorf("there must be only one header jar from %q", m.Name())) |
| } |
| implicits = append(implicits, headerJars...) |
| |
| exportedAidlIncludeDirs := javaLib.AidlIncludeDirs() |
| for _, dir := range exportedAidlIncludeDirs { |
| // Using tar to copy with the directory structure |
| // TODO(jiyong): copy parcelable declarations only |
| sh.printfln("find %s -name \"*.aidl\" | tar cf - -T - | (cd %s; tar xf -)", |
| dir.String(), aidlIncludeDir) |
| } |
| |
| copiedHeaderJar := filepath.Join(javaStubsDir, m.Name(), "stub.jar") |
| sh.printfln("mkdir -p $(dirname %s) && cp %s %s", |
| copiedHeaderJar, headerJars[0].String(), copiedHeaderJar) |
| } |
| // TODO(jiyong): emit the commands for copying the headers and stub libraries for native libs |
| }) |
| |
| bp := s.buildAndroidBp(ctx, version) |
| implicits = append(implicits, bp) |
| sh.printfln("cp %s %s", bp.String(), filepath.Join(snapshotRoot, "Android.bp")) |
| |
| sh.printfln("popd > /dev/null") |
| sh.printfln("rm -- \"$0\"") // self deleting so that stale script is not used |
| sh.printfln("echo Done") |
| |
| sh.build(pctx, ctx, implicits) |
| return sh.path |
| } |
| |
| func (s *sdk) buildSnapshotGenerationScripts(ctx android.ModuleContext) { |
| if s.snapshot() { |
| // we don't need a script for sdk_snapshot.. as they are frozen |
| return |
| } |
| |
| // script to update the 'current' snapshot |
| s.updateScript = s.buildScript(ctx, "current") |
| |
| versions := s.frozenVersions(ctx) |
| newVersion := "1" |
| if len(versions) >= 1 { |
| lastVersion := versions[len(versions)-1] |
| lastVersionNum, err := strconv.Atoi(lastVersion) |
| if err != nil { |
| panic(err) |
| return |
| } |
| newVersion = strconv.Itoa(lastVersionNum + 1) |
| } |
| // script to create a new frozen version of snapshot |
| s.freezeScript = s.buildScript(ctx, newVersion) |
| } |
| |
| func (s *sdk) androidMkEntriesForScript() android.AndroidMkEntries { |
| if s.snapshot() { |
| // we don't need a script for sdk_snapshot.. as they are frozen |
| return android.AndroidMkEntries{} |
| } |
| |
| entries := android.AndroidMkEntries{ |
| Class: "FAKE", |
| // TODO(jiyong): remove this? but androidmk.go expects OutputFile to be specified anyway |
| OutputFile: android.OptionalPathForPath(s.updateScript), |
| Include: "$(BUILD_SYSTEM)/base_rules.mk", |
| ExtraEntries: []android.AndroidMkExtraEntriesFunc{ |
| func(entries *android.AndroidMkEntries) { |
| entries.AddStrings("LOCAL_ADDITIONAL_DEPENDENCIES", |
| s.updateScript.String(), s.freezeScript.String()) |
| }, |
| }, |
| ExtraFooters: []android.AndroidMkExtraFootersFunc{ |
| func(w io.Writer, name, prefix, moduleDir string, entries *android.AndroidMkEntries) { |
| fmt.Fprintln(w, "$(LOCAL_BUILT_MODULE): $(LOCAL_ADDITIONAL_DEPENDENCIES)") |
| fmt.Fprintln(w, " touch $@") |
| fmt.Fprintln(w, " echo ##################################################") |
| fmt.Fprintln(w, " echo To update current SDK: execute", s.updateScript.String()) |
| fmt.Fprintln(w, " echo To freeze current SDK: execute", s.freezeScript.String()) |
| fmt.Fprintln(w, " echo ##################################################") |
| }, |
| }, |
| } |
| return entries |
| } |