Merge "Add Android.mk lines for package name overriding."
diff --git a/Android.bp b/Android.bp
index a70f73c..92a6e9d 100644
--- a/Android.bp
+++ b/Android.bp
@@ -61,6 +61,7 @@
"android/prebuilt_etc.go",
"android/proto.go",
"android/register.go",
+ "android/rule_builder.go",
"android/sh_binary.go",
"android/singleton.go",
"android/testing.go",
@@ -77,9 +78,11 @@
"android/expand_test.go",
"android/namespace_test.go",
"android/neverallow_test.go",
+ "android/onceper_test.go",
"android/paths_test.go",
"android/prebuilt_test.go",
"android/prebuilt_etc_test.go",
+ "android/rule_builder_test.go",
"android/util_test.go",
"android/variable_test.go",
],
@@ -248,6 +251,7 @@
"java/gen.go",
"java/genrule.go",
"java/hiddenapi.go",
+ "java/hiddenapi_singleton.go",
"java/jacoco.go",
"java/java.go",
"java/jdeps.go",
diff --git a/android/apex.go b/android/apex.go
index a93baf6..bf11ba2 100644
--- a/android/apex.go
+++ b/android/apex.go
@@ -139,6 +139,7 @@
var apexData OncePer
var apexNamesMapMutex sync.Mutex
+var apexNamesKey = NewOnceKey("apexNames")
// This structure maintains the global mapping in between modules and APEXes.
// Examples:
@@ -147,7 +148,7 @@
// apexNamesMap()["foo"]["bar"] == false: module foo is indirectly depended on by APEX bar
// apexNamesMap()["foo"]["bar"] doesn't exist: foo is not built for APEX bar
func apexNamesMap() map[string]map[string]bool {
- return apexData.Once("apexNames", func() interface{} {
+ return apexData.Once(apexNamesKey, func() interface{} {
return make(map[string]map[string]bool)
}).(map[string]map[string]bool)
}
diff --git a/android/api_levels.go b/android/api_levels.go
index 1b56625..51d4703 100644
--- a/android/api_levels.go
+++ b/android/api_levels.go
@@ -51,8 +51,10 @@
return PathForOutput(ctx, "api_levels.json")
}
+var apiLevelsMapKey = NewOnceKey("ApiLevelsMap")
+
func getApiLevelsMap(config Config) map[string]int {
- return config.Once("ApiLevelsMap", func() interface{} {
+ return config.Once(apiLevelsMapKey, func() interface{} {
baseApiLevel := 9000
apiLevelsMap := map[string]int{
"G": 9,
diff --git a/android/arch.go b/android/arch.go
index 953e6cf..ad812a4 100644
--- a/android/arch.go
+++ b/android/arch.go
@@ -879,7 +879,7 @@
propertiesValue.Interface()))
}
- archPropTypes := archPropTypeMap.Once(t, func() interface{} {
+ archPropTypes := archPropTypeMap.Once(NewCustomOnceKey(t), func() interface{} {
return createArchType(t)
}).([]reflect.Type)
diff --git a/android/config.go b/android/config.go
index 92010fc..63788b7 100644
--- a/android/config.go
+++ b/android/config.go
@@ -1022,14 +1022,14 @@
return c.productVariables.EnforceSystemCertificateWhitelist
}
-func (c *config) HiddenAPIStubFlags() string {
- return String(c.productVariables.HiddenAPIStubFlags)
+func (c *config) ProductHiddenAPIStubs() []string {
+ return c.productVariables.ProductHiddenAPIStubs
}
-func (c *config) HiddenAPIFlags() string {
- return String(c.productVariables.HiddenAPIFlags)
+func (c *config) ProductHiddenAPIStubsSystem() []string {
+ return c.productVariables.ProductHiddenAPIStubsSystem
}
-func (c *config) HiddenAPIExtraAppUsageJars() []string {
- return c.productVariables.HiddenAPIExtraAppUsageJars
+func (c *config) ProductHiddenAPIStubsTest() []string {
+ return c.productVariables.ProductHiddenAPIStubsTest
}
diff --git a/android/makevars.go b/android/makevars.go
index 3a7ec6e..366bb6b 100644
--- a/android/makevars.go
+++ b/android/makevars.go
@@ -22,6 +22,8 @@
"strconv"
"strings"
+ "github.com/google/blueprint"
+ "github.com/google/blueprint/pathtools"
"github.com/google/blueprint/proptools"
)
@@ -38,7 +40,21 @@
type MakeVarsContext interface {
Config() Config
DeviceConfig() DeviceConfig
- SingletonContext() SingletonContext
+ AddNinjaFileDeps(deps ...string)
+ Fs() pathtools.FileSystem
+
+ ModuleName(module blueprint.Module) string
+ ModuleDir(module blueprint.Module) string
+ ModuleSubDir(module blueprint.Module) string
+ ModuleType(module blueprint.Module) string
+ BlueprintFile(module blueprint.Module) string
+
+ ModuleErrorf(module blueprint.Module, format string, args ...interface{})
+ Errorf(format string, args ...interface{})
+ Failed() bool
+
+ VisitAllModules(visit func(Module))
+ VisitAllModulesIf(pred func(Module) bool, visit func(Module))
// Verify the make variable matches the Soong version, fail the build
// if it does not. If the make variable is empty, just set it.
@@ -66,6 +82,8 @@
CheckRaw(name, value string)
}
+var _ PathContext = MakeVarsContext(nil)
+
type MakeVarsProvider func(ctx MakeVarsContext)
func RegisterMakeVarsProvider(pctx PackageContext, provider MakeVarsProvider) {
@@ -92,8 +110,8 @@
var makeVarsProviders []makeVarsProvider
type makeVarsContext struct {
+ SingletonContext
config Config
- ctx SingletonContext
pctx PackageContext
vars []makeVarsVariable
}
@@ -121,9 +139,8 @@
vars := []makeVarsVariable{}
for _, provider := range makeVarsProviders {
mctx := &makeVarsContext{
- config: ctx.Config(),
- ctx: ctx,
- pctx: provider.pctx,
+ SingletonContext: ctx,
+ pctx: provider.pctx,
}
provider.call(mctx)
@@ -229,22 +246,14 @@
return buf.Bytes()
}
-func (c *makeVarsContext) Config() Config {
- return c.config
-}
-
func (c *makeVarsContext) DeviceConfig() DeviceConfig {
- return DeviceConfig{c.config.deviceConfig}
-}
-
-func (c *makeVarsContext) SingletonContext() SingletonContext {
- return c.ctx
+ return DeviceConfig{c.Config().deviceConfig}
}
var ninjaDescaper = strings.NewReplacer("$$", "$")
func (c *makeVarsContext) Eval(ninjaStr string) (string, error) {
- s, err := c.ctx.Eval(c.pctx, ninjaStr)
+ s, err := c.SingletonContext.Eval(c.pctx, ninjaStr)
if err != nil {
return "", err
}
@@ -265,7 +274,7 @@
func (c *makeVarsContext) addVariable(name, ninjaStr string, strict, sort bool) {
value, err := c.Eval(ninjaStr)
if err != nil {
- c.ctx.Errorf(err.Error())
+ c.SingletonContext.Errorf(err.Error())
}
c.addVariableRaw(name, value, strict, sort)
}
diff --git a/android/onceper.go b/android/onceper.go
index f19f75c..6160506 100644
--- a/android/onceper.go
+++ b/android/onceper.go
@@ -24,8 +24,6 @@
valuesLock sync.Mutex
}
-type valueMap map[interface{}]interface{}
-
// Once computes a value the first time it is called with a given key per OncePer, and returns the
// value without recomputing when called with the same key. key must be hashable.
func (once *OncePer) Once(key interface{}, value func() interface{}) interface{} {
@@ -50,6 +48,8 @@
return v
}
+// Get returns the value previously computed with Once for a given key. If Once has not been called for the given
+// key Get will panic.
func (once *OncePer) Get(key interface{}) interface{} {
v, ok := once.values.Load(key)
if !ok {
@@ -59,10 +59,12 @@
return v
}
+// OnceStringSlice is the same as Once, but returns the value cast to a []string
func (once *OncePer) OnceStringSlice(key interface{}, value func() []string) []string {
return once.Once(key, func() interface{} { return value() }).([]string)
}
+// OnceStringSlice is the same as Once, but returns two values cast to []string
func (once *OncePer) Once2StringSlice(key interface{}, value func() ([]string, []string)) ([]string, []string) {
type twoStringSlice [2][]string
s := once.Once(key, func() interface{} {
@@ -72,3 +74,21 @@
}).(twoStringSlice)
return s[0], s[1]
}
+
+// OnceKey is an opaque type to be used as the key in calls to Once.
+type OnceKey struct {
+ key interface{}
+}
+
+// NewOnceKey returns an opaque OnceKey object for the provided key. Two calls to NewOnceKey with the same key string
+// DO NOT produce the same OnceKey object.
+func NewOnceKey(key string) OnceKey {
+ return OnceKey{&key}
+}
+
+// NewCustomOnceKey returns an opaque OnceKey object for the provided key. The key can be any type that is valid as the
+// key in a map, i.e. comparable. Two calls to NewCustomOnceKey with key values that compare equal will return OnceKey
+// objects that access the same value stored with Once.
+func NewCustomOnceKey(key interface{}) OnceKey {
+ return OnceKey{key}
+}
diff --git a/android/onceper_test.go b/android/onceper_test.go
new file mode 100644
index 0000000..d2ca9ad
--- /dev/null
+++ b/android/onceper_test.go
@@ -0,0 +1,135 @@
+// Copyright 2019 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 android
+
+import (
+ "testing"
+)
+
+func TestOncePer_Once(t *testing.T) {
+ once := OncePer{}
+ key := NewOnceKey("key")
+
+ a := once.Once(key, func() interface{} { return "a" }).(string)
+ b := once.Once(key, func() interface{} { return "b" }).(string)
+
+ if a != "a" {
+ t.Errorf(`first call to Once should return "a": %q`, a)
+ }
+
+ if b != "a" {
+ t.Errorf(`second call to Once with the same key should return "a": %q`, b)
+ }
+}
+
+func TestOncePer_Get(t *testing.T) {
+ once := OncePer{}
+ key := NewOnceKey("key")
+
+ a := once.Once(key, func() interface{} { return "a" }).(string)
+ b := once.Get(key).(string)
+
+ if a != "a" {
+ t.Errorf(`first call to Once should return "a": %q`, a)
+ }
+
+ if b != "a" {
+ t.Errorf(`Get with the same key should return "a": %q`, b)
+ }
+}
+
+func TestOncePer_Get_panic(t *testing.T) {
+ once := OncePer{}
+ key := NewOnceKey("key")
+
+ defer func() {
+ p := recover()
+
+ if p == nil {
+ t.Error("call to Get for unused key should panic")
+ }
+ }()
+
+ once.Get(key)
+}
+
+func TestOncePer_OnceStringSlice(t *testing.T) {
+ once := OncePer{}
+ key := NewOnceKey("key")
+
+ a := once.OnceStringSlice(key, func() []string { return []string{"a"} })
+ b := once.OnceStringSlice(key, func() []string { return []string{"a"} })
+
+ if a[0] != "a" {
+ t.Errorf(`first call to OnceStringSlice should return ["a"]: %q`, a)
+ }
+
+ if b[0] != "a" {
+ t.Errorf(`second call to OnceStringSlice with the same key should return ["a"]: %q`, b)
+ }
+}
+
+func TestOncePer_Once2StringSlice(t *testing.T) {
+ once := OncePer{}
+ key := NewOnceKey("key")
+
+ a, b := once.Once2StringSlice(key, func() ([]string, []string) { return []string{"a"}, []string{"b"} })
+ c, d := once.Once2StringSlice(key, func() ([]string, []string) { return []string{"c"}, []string{"d"} })
+
+ if a[0] != "a" || b[0] != "b" {
+ t.Errorf(`first call to Once2StringSlice should return ["a"], ["b"]: %q, %q`, a, b)
+ }
+
+ if c[0] != "a" || d[0] != "b" {
+ t.Errorf(`second call to Once2StringSlice with the same key should return ["a"], ["b"]: %q, %q`, c, d)
+ }
+}
+
+func TestNewOnceKey(t *testing.T) {
+ once := OncePer{}
+ key1 := NewOnceKey("key")
+ key2 := NewOnceKey("key")
+
+ a := once.Once(key1, func() interface{} { return "a" }).(string)
+ b := once.Once(key2, func() interface{} { return "b" }).(string)
+
+ if a != "a" {
+ t.Errorf(`first call to Once should return "a": %q`, a)
+ }
+
+ if b != "b" {
+ t.Errorf(`second call to Once with the NewOnceKey from same string should return "b": %q`, b)
+ }
+}
+
+func TestNewCustomOnceKey(t *testing.T) {
+ type key struct {
+ key string
+ }
+ once := OncePer{}
+ key1 := NewCustomOnceKey(key{"key"})
+ key2 := NewCustomOnceKey(key{"key"})
+
+ a := once.Once(key1, func() interface{} { return "a" }).(string)
+ b := once.Once(key2, func() interface{} { return "b" }).(string)
+
+ if a != "a" {
+ t.Errorf(`first call to Once should return "a": %q`, a)
+ }
+
+ if b != "a" {
+ t.Errorf(`second call to Once with the NewCustomOnceKey from equal key should return "a": %q`, b)
+ }
+}
diff --git a/android/paths.go b/android/paths.go
index 4b84c97..4b35fef 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -263,9 +263,9 @@
}
// PathsWithOptionalDefaultForModuleSrc returns Paths rooted from the module's
-// local source directory. If none are provided, use the default if it exists.
+// local source directory. If input is nil, use the default if it exists. If input is empty, returns nil.
func PathsWithOptionalDefaultForModuleSrc(ctx ModuleContext, input []string, def string) Paths {
- if len(input) > 0 {
+ if input != nil {
return PathsForModuleSrc(ctx, input)
}
// Use Glob so that if the default doesn't exist, a dependency is added so that when it
diff --git a/android/prebuilt_etc.go b/android/prebuilt_etc.go
index e180342..33647d7 100644
--- a/android/prebuilt_etc.go
+++ b/android/prebuilt_etc.go
@@ -25,6 +25,7 @@
func init() {
RegisterModuleType("prebuilt_etc", PrebuiltEtcFactory)
+ RegisterModuleType("prebuilt_etc_host", prebuiltEtcHostFactory)
PreDepsMutators(func(ctx RegisterMutatorsContext) {
ctx.BottomUp("prebuilt_etc", prebuiltEtcMutator).Parallel()
@@ -149,6 +150,9 @@
fmt.Fprintln(w, "LOCAL_MODULE_OWNER :=", *p.commonProperties.Owner)
}
fmt.Fprintln(w, "LOCAL_MODULE_TAGS := optional")
+ if p.Host() {
+ fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
+ }
fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", p.outputFilePath.String())
fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", "$(OUT_DIR)/"+p.installDirPath.RelPathString())
fmt.Fprintln(w, "LOCAL_INSTALLED_MODULE_STEM :=", p.outputFilePath.Base())
@@ -178,6 +182,14 @@
return module
}
+func prebuiltEtcHostFactory() Module {
+ module := &PrebuiltEtc{}
+ InitPrebuiltEtcModule(module)
+ // This module is host-only
+ InitAndroidArchModule(module, HostSupported, MultilibCommon)
+ return module
+}
+
const (
// coreMode is the variant for modules to be installed to system.
coreMode = "core"
@@ -190,7 +202,7 @@
// system or recovery.
func prebuiltEtcMutator(mctx BottomUpMutatorContext) {
m, ok := mctx.Module().(*PrebuiltEtc)
- if !ok {
+ if !ok || m.Host() {
return
}
diff --git a/android/prebuilt_etc_test.go b/android/prebuilt_etc_test.go
index d1a80af..f31fc9e 100644
--- a/android/prebuilt_etc_test.go
+++ b/android/prebuilt_etc_test.go
@@ -28,6 +28,7 @@
defer tearDown(buildDir)
ctx := NewTestArchContext()
ctx.RegisterModuleType("prebuilt_etc", ModuleFactoryAdaptor(PrebuiltEtcFactory))
+ ctx.RegisterModuleType("prebuilt_etc_host", ModuleFactoryAdaptor(prebuiltEtcHostFactory))
ctx.PreDepsMutators(func(ctx RegisterMutatorsContext) {
ctx.BottomUp("prebuilt_etc", prebuiltEtcMutator).Parallel()
})
@@ -177,3 +178,18 @@
}
}
}
+
+func TestPrebuiltEtcHost(t *testing.T) {
+ ctx := testPrebuiltEtc(t, `
+ prebuilt_etc_host {
+ name: "foo.conf",
+ src: "foo.conf",
+ }
+ `)
+
+ buildOS := BuildOs.String()
+ p := ctx.ModuleForTests("foo.conf", buildOS+"_common").Module().(*PrebuiltEtc)
+ if !p.Host() {
+ t.Errorf("host bit is not set for a prebuilt_etc_host module.")
+ }
+}
diff --git a/android/rule_builder.go b/android/rule_builder.go
new file mode 100644
index 0000000..38018be
--- /dev/null
+++ b/android/rule_builder.go
@@ -0,0 +1,417 @@
+// Copyright 2018 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 android
+
+import (
+ "fmt"
+ "path/filepath"
+ "sort"
+ "strings"
+
+ "github.com/google/blueprint"
+ "github.com/google/blueprint/proptools"
+)
+
+// RuleBuilder provides an alternative to ModuleContext.Rule and ModuleContext.Build to add a command line to the build
+// graph.
+type RuleBuilder struct {
+ commands []*RuleBuilderCommand
+ installs []RuleBuilderInstall
+ temporariesSet map[string]bool
+ restat bool
+ missingDeps []string
+}
+
+// NewRuleBuilder returns a newly created RuleBuilder.
+func NewRuleBuilder() *RuleBuilder {
+ return &RuleBuilder{
+ temporariesSet: make(map[string]bool),
+ }
+}
+
+// RuleBuilderInstall is a tuple of install from and to locations.
+type RuleBuilderInstall struct {
+ From, To string
+}
+
+// MissingDeps adds modules to the list of missing dependencies. If MissingDeps
+// is called with a non-empty input, any call to Build will result in a rule
+// that will print an error listing the missing dependencies and fail.
+// MissingDeps should only be called if Config.AllowMissingDependencies() is
+// true.
+func (r *RuleBuilder) MissingDeps(missingDeps []string) {
+ r.missingDeps = append(r.missingDeps, missingDeps...)
+}
+
+// Restat marks the rule as a restat rule, which will be passed to ModuleContext.Rule in BuildParams.Restat.
+func (r *RuleBuilder) Restat() *RuleBuilder {
+ r.restat = true
+ return r
+}
+
+// Install associates an output of the rule with an install location, which can be retrieved later using
+// RuleBuilder.Installs.
+func (r *RuleBuilder) Install(from, to string) {
+ r.installs = append(r.installs, RuleBuilderInstall{from, to})
+}
+
+// Command returns a new RuleBuilderCommand for the rule. The commands will be ordered in the rule by when they were
+// created by this method. That can be mutated through their methods in any order, as long as the mutations do not
+// race with any call to Build.
+func (r *RuleBuilder) Command() *RuleBuilderCommand {
+ command := &RuleBuilderCommand{}
+ r.commands = append(r.commands, command)
+ return command
+}
+
+// Temporary marks an output of a command as an intermediate file that will be used as an input to another command
+// in the same rule, and should not be listed in Outputs.
+func (r *RuleBuilder) Temporary(path string) {
+ r.temporariesSet[path] = true
+}
+
+// DeleteTemporaryFiles adds a command to the rule that deletes any outputs that have been marked using Temporary
+// when the rule runs. DeleteTemporaryFiles should be called after all calls to Temporary.
+func (r *RuleBuilder) DeleteTemporaryFiles() {
+ var temporariesList []string
+
+ for intermediate := range r.temporariesSet {
+ temporariesList = append(temporariesList, intermediate)
+ }
+ sort.Strings(temporariesList)
+
+ r.Command().Text("rm").Flag("-f").Outputs(temporariesList)
+}
+
+// Inputs returns the list of paths that were passed to the RuleBuilderCommand methods that take input paths, such
+// as RuleBuilderCommand.Input, RuleBuilderComand.Implicit, or RuleBuilderCommand.FlagWithInput. Inputs to a command
+// that are also outputs of another command in the same RuleBuilder are filtered out.
+func (r *RuleBuilder) Inputs() []string {
+ outputs := r.outputSet()
+
+ inputs := make(map[string]bool)
+ for _, c := range r.commands {
+ for _, input := range c.inputs {
+ if !outputs[input] {
+ inputs[input] = true
+ }
+ }
+ }
+
+ var inputList []string
+ for input := range inputs {
+ inputList = append(inputList, input)
+ }
+ sort.Strings(inputList)
+
+ return inputList
+}
+
+func (r *RuleBuilder) outputSet() map[string]bool {
+ outputs := make(map[string]bool)
+ for _, c := range r.commands {
+ for _, output := range c.outputs {
+ outputs[output] = true
+ }
+ }
+ return outputs
+}
+
+// Outputs returns the list of paths that were passed to the RuleBuilderCommand methods that take output paths, such
+// as RuleBuilderCommand.Output, RuleBuilderCommand.ImplicitOutput, or RuleBuilderCommand.FlagWithInput.
+func (r *RuleBuilder) Outputs() []string {
+ outputs := r.outputSet()
+
+ var outputList []string
+ for output := range outputs {
+ if !r.temporariesSet[output] {
+ outputList = append(outputList, output)
+ }
+ }
+ sort.Strings(outputList)
+ return outputList
+}
+
+// Installs returns the list of tuples passed to Install.
+func (r *RuleBuilder) Installs() []RuleBuilderInstall {
+ return append([]RuleBuilderInstall(nil), r.installs...)
+}
+
+func (r *RuleBuilder) toolsSet() map[string]bool {
+ tools := make(map[string]bool)
+ for _, c := range r.commands {
+ for _, tool := range c.tools {
+ tools[tool] = true
+ }
+ }
+
+ return tools
+}
+
+// Tools returns the list of paths that were passed to the RuleBuilderCommand.Tool method.
+func (r *RuleBuilder) Tools() []string {
+ toolsSet := r.toolsSet()
+
+ var toolsList []string
+ for tool := range toolsSet {
+ toolsList = append(toolsList, tool)
+ }
+ sort.Strings(toolsList)
+ return toolsList
+}
+
+// Commands returns a slice containing a the built command line for each call to RuleBuilder.Command.
+func (r *RuleBuilder) Commands() []string {
+ var commands []string
+ for _, c := range r.commands {
+ commands = append(commands, string(c.buf))
+ }
+ return commands
+}
+
+// BuilderContext is a subset of ModuleContext and SingletonContext.
+type BuilderContext interface {
+ PathContext
+ Rule(PackageContext, string, blueprint.RuleParams, ...string) blueprint.Rule
+ Build(PackageContext, BuildParams)
+}
+
+var _ BuilderContext = ModuleContext(nil)
+var _ BuilderContext = SingletonContext(nil)
+
+// Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
+// Outputs.
+func (r *RuleBuilder) Build(pctx PackageContext, ctx BuilderContext, name string, desc string) {
+ // TODO: convert RuleBuilder arguments and storage to Paths
+ mctx, _ := ctx.(ModuleContext)
+ var inputs Paths
+ for _, input := range r.Inputs() {
+ // Module output paths
+ if mctx != nil {
+ rel, isRel := MaybeRel(ctx, PathForModuleOut(mctx).String(), input)
+ if isRel {
+ inputs = append(inputs, PathForModuleOut(mctx, rel))
+ continue
+ }
+ }
+
+ // Other output paths
+ rel, isRel := MaybeRel(ctx, PathForOutput(ctx).String(), input)
+ if isRel {
+ inputs = append(inputs, PathForOutput(ctx, rel))
+ continue
+ }
+
+ // TODO: remove this once boot image is moved to where PathForOutput can find it.
+ inputs = append(inputs, &unknownRulePath{input})
+ }
+
+ var outputs WritablePaths
+ for _, output := range r.Outputs() {
+ if mctx != nil {
+ rel := Rel(ctx, PathForModuleOut(mctx).String(), output)
+ outputs = append(outputs, PathForModuleOut(mctx, rel))
+ } else {
+ rel := Rel(ctx, PathForOutput(ctx).String(), output)
+ outputs = append(outputs, PathForOutput(ctx, rel))
+ }
+ }
+
+ if len(r.missingDeps) > 0 {
+ ctx.Build(pctx, BuildParams{
+ Rule: ErrorRule,
+ Outputs: outputs,
+ Description: desc,
+ Args: map[string]string{
+ "error": "missing dependencies: " + strings.Join(r.missingDeps, ", "),
+ },
+ })
+ return
+ }
+
+ if len(r.Commands()) > 0 {
+ ctx.Build(pctx, BuildParams{
+ Rule: ctx.Rule(pctx, name, blueprint.RuleParams{
+ Command: strings.Join(proptools.NinjaEscape(r.Commands()), " && "),
+ CommandDeps: r.Tools(),
+ }),
+ Implicits: inputs,
+ Outputs: outputs,
+ Description: desc,
+ })
+ }
+}
+
+// RuleBuilderCommand is a builder for a command in a command line. It can be mutated by its methods to add to the
+// command and track dependencies. The methods mutate the RuleBuilderCommand in place, as well as return the
+// RuleBuilderCommand, so they can be used chained or unchained. All methods that add text implicitly add a single
+// space as a separator from the previous method.
+type RuleBuilderCommand struct {
+ buf []byte
+ inputs []string
+ outputs []string
+ tools []string
+}
+
+// Text adds the specified raw text to the command line. The text should not contain input or output paths or the
+// rule will not have them listed in its dependencies or outputs.
+func (c *RuleBuilderCommand) Text(text string) *RuleBuilderCommand {
+ if len(c.buf) > 0 {
+ c.buf = append(c.buf, ' ')
+ }
+ c.buf = append(c.buf, text...)
+ return c
+}
+
+// Textf adds the specified formatted text to the command line. The text should not contain input or output paths or
+// the rule will not have them listed in its dependencies or outputs.
+func (c *RuleBuilderCommand) Textf(format string, a ...interface{}) *RuleBuilderCommand {
+ return c.Text(fmt.Sprintf(format, a...))
+}
+
+// Flag adds the specified raw text to the command line. The text should not contain input or output paths or the
+// rule will not have them listed in its dependencies or outputs.
+func (c *RuleBuilderCommand) Flag(flag string) *RuleBuilderCommand {
+ return c.Text(flag)
+}
+
+// FlagWithArg adds the specified flag and argument text to the command line, with no separator between them. The flag
+// and argument should not contain input or output paths or the rule will not have them listed in its dependencies or
+// outputs.
+func (c *RuleBuilderCommand) FlagWithArg(flag, arg string) *RuleBuilderCommand {
+ return c.Text(flag + arg)
+}
+
+// FlagWithArg adds the specified flag and list of arguments to the command line, with the arguments joined by sep
+// and no separator between the flag and arguments. The flag and arguments should not contain input or output paths or
+// the rule will not have them listed in its dependencies or outputs.
+func (c *RuleBuilderCommand) FlagWithList(flag string, list []string, sep string) *RuleBuilderCommand {
+ return c.Text(flag + strings.Join(list, sep))
+}
+
+// Tool adds the specified tool path to the command line. The path will be also added to the dependencies returned by
+// RuleBuilder.Tools.
+func (c *RuleBuilderCommand) Tool(path string) *RuleBuilderCommand {
+ c.tools = append(c.tools, path)
+ return c.Text(path)
+}
+
+// Input adds the specified input path to the command line. The path will also be added to the dependencies returned by
+// RuleBuilder.Inputs.
+func (c *RuleBuilderCommand) Input(path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c.Text(path)
+}
+
+// Inputs adds the specified input paths to the command line, separated by spaces. The paths will also be added to the
+// dependencies returned by RuleBuilder.Inputs.
+func (c *RuleBuilderCommand) Inputs(paths []string) *RuleBuilderCommand {
+ for _, path := range paths {
+ c.Input(path)
+ }
+ return c
+}
+
+// Implicit adds the specified input path to the dependencies returned by RuleBuilder.Inputs without modifying the
+// command line.
+func (c *RuleBuilderCommand) Implicit(path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c
+}
+
+// Implicits adds the specified input paths to the dependencies returned by RuleBuilder.Inputs without modifying the
+// command line.
+func (c *RuleBuilderCommand) Implicits(paths []string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, paths...)
+ return c
+}
+
+// Output adds the specified output path to the command line. The path will also be added to the outputs returned by
+// RuleBuilder.Outputs.
+func (c *RuleBuilderCommand) Output(path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c.Text(path)
+}
+
+// Outputs adds the specified output paths to the command line, separated by spaces. The paths will also be added to
+// the outputs returned by RuleBuilder.Outputs.
+func (c *RuleBuilderCommand) Outputs(paths []string) *RuleBuilderCommand {
+ for _, path := range paths {
+ c.Output(path)
+ }
+ return c
+}
+
+// ImplicitOutput adds the specified output path to the dependencies returned by RuleBuilder.Outputs without modifying
+// the command line.
+func (c *RuleBuilderCommand) ImplicitOutput(path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c
+}
+
+// ImplicitOutputs adds the specified output paths to the dependencies returned by RuleBuilder.Outputs without modifying
+// the command line.
+func (c *RuleBuilderCommand) ImplicitOutputs(paths []string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, paths...)
+ return c
+}
+
+// FlagWithInput adds the specified flag and input path to the command line, with no separator between them. The path
+// will also be added to the dependencies returned by RuleBuilder.Inputs.
+func (c *RuleBuilderCommand) FlagWithInput(flag, path string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, path)
+ return c.Text(flag + path)
+}
+
+// FlagWithInputList adds the specified flag and input paths to the command line, with the inputs joined by sep
+// and no separator between the flag and inputs. The input paths will also be added to the dependencies returned by
+// RuleBuilder.Inputs.
+func (c *RuleBuilderCommand) FlagWithInputList(flag string, paths []string, sep string) *RuleBuilderCommand {
+ c.inputs = append(c.inputs, paths...)
+ return c.FlagWithList(flag, paths, sep)
+}
+
+// FlagForEachInput adds the specified flag joined with each input path to the command line. The input paths will also
+// be added to the dependencies returned by RuleBuilder.Inputs. The result is identical to calling FlagWithInput for
+// each input path.
+func (c *RuleBuilderCommand) FlagForEachInput(flag string, paths []string) *RuleBuilderCommand {
+ for _, path := range paths {
+ c.FlagWithInput(flag, path)
+ }
+ return c
+}
+
+// FlagWithOutput adds the specified flag and output path to the command line, with no separator between them. The path
+// will also be added to the outputs returned by RuleBuilder.Outputs.
+func (c *RuleBuilderCommand) FlagWithOutput(flag, path string) *RuleBuilderCommand {
+ c.outputs = append(c.outputs, path)
+ return c.Text(flag + path)
+}
+
+// String returns the command line.
+func (c *RuleBuilderCommand) String() string {
+ return string(c.buf)
+}
+
+type unknownRulePath struct {
+ path string
+}
+
+var _ Path = (*unknownRulePath)(nil)
+
+func (p *unknownRulePath) String() string { return p.path }
+func (p *unknownRulePath) Ext() string { return filepath.Ext(p.path) }
+func (p *unknownRulePath) Base() string { return filepath.Base(p.path) }
+func (p *unknownRulePath) Rel() string { return p.path }
diff --git a/android/rule_builder_test.go b/android/rule_builder_test.go
new file mode 100644
index 0000000..f7577a6
--- /dev/null
+++ b/android/rule_builder_test.go
@@ -0,0 +1,292 @@
+// Copyright 2019 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 android
+
+import (
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "reflect"
+ "strings"
+ "testing"
+)
+
+func ExampleRuleBuilder() {
+ rule := NewRuleBuilder()
+
+ rule.Command().Tool("ld").Inputs([]string{"a.o", "b.o"}).FlagWithOutput("-o ", "linked")
+ rule.Command().Text("echo success")
+
+ // To add the command to the build graph:
+ // rule.Build(pctx, ctx, "link", "link")
+
+ fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && "))
+ fmt.Printf("tools: %q\n", rule.Tools())
+ fmt.Printf("inputs: %q\n", rule.Inputs())
+ fmt.Printf("outputs: %q\n", rule.Outputs())
+
+ // Output:
+ // commands: "ld a.o b.o -o linked && echo success"
+ // tools: ["ld"]
+ // inputs: ["a.o" "b.o"]
+ // outputs: ["linked"]
+}
+
+func ExampleRuleBuilder_Temporary() {
+ rule := NewRuleBuilder()
+
+ rule.Command().Tool("cp").Input("a").Output("b")
+ rule.Command().Tool("cp").Input("b").Output("c")
+ rule.Temporary("b")
+
+ fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && "))
+ fmt.Printf("tools: %q\n", rule.Tools())
+ fmt.Printf("inputs: %q\n", rule.Inputs())
+ fmt.Printf("outputs: %q\n", rule.Outputs())
+
+ // Output:
+ // commands: "cp a b && cp b c"
+ // tools: ["cp"]
+ // inputs: ["a"]
+ // outputs: ["c"]
+}
+
+func ExampleRuleBuilder_DeleteTemporaryFiles() {
+ rule := NewRuleBuilder()
+
+ rule.Command().Tool("cp").Input("a").Output("b")
+ rule.Command().Tool("cp").Input("b").Output("c")
+ rule.Temporary("b")
+ rule.DeleteTemporaryFiles()
+
+ fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && "))
+ fmt.Printf("tools: %q\n", rule.Tools())
+ fmt.Printf("inputs: %q\n", rule.Inputs())
+ fmt.Printf("outputs: %q\n", rule.Outputs())
+
+ // Output:
+ // commands: "cp a b && cp b c && rm -f b"
+ // tools: ["cp"]
+ // inputs: ["a"]
+ // outputs: ["c"]
+}
+
+func ExampleRuleBuilderCommand() {
+ rule := NewRuleBuilder()
+
+ // chained
+ rule.Command().Tool("ld").Inputs([]string{"a.o", "b.o"}).FlagWithOutput("-o ", "linked")
+
+ // unchained
+ cmd := rule.Command()
+ cmd.Tool("ld")
+ cmd.Inputs([]string{"a.o", "b.o"})
+ cmd.FlagWithOutput("-o ", "linked")
+
+ // mixed:
+ cmd = rule.Command().Tool("ld")
+ cmd.Inputs([]string{"a.o", "b.o"})
+ cmd.FlagWithOutput("-o ", "linked")
+}
+
+func ExampleRuleBuilderCommand_Flag() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("ls").Flag("-l"))
+ // Output:
+ // ls -l
+}
+
+func ExampleRuleBuilderCommand_FlagWithArg() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("ls").
+ FlagWithArg("--sort=", "time"))
+ // Output:
+ // ls --sort=time
+}
+
+func ExampleRuleBuilderCommand_FlagForEachInput() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("turbine").
+ FlagForEachInput("--classpath ", []string{"a.jar", "b.jar"}))
+ // Output:
+ // turbine --classpath a.jar --classpath b.jar
+}
+
+func ExampleRuleBuilderCommand_FlagWithInputList() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("java").
+ FlagWithInputList("-classpath=", []string{"a.jar", "b.jar"}, ":"))
+ // Output:
+ // java -classpath=a.jar:b.jar
+}
+
+func ExampleRuleBuilderCommand_FlagWithInput() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("java").
+ FlagWithInput("-classpath=", "a"))
+ // Output:
+ // java -classpath=a
+}
+
+func ExampleRuleBuilderCommand_FlagWithList() {
+ fmt.Println(NewRuleBuilder().Command().
+ Tool("ls").
+ FlagWithList("--sort=", []string{"time", "size"}, ","))
+ // Output:
+ // ls --sort=time,size
+}
+
+func TestRuleBuilder(t *testing.T) {
+ rule := NewRuleBuilder()
+
+ cmd := rule.Command().
+ Flag("Flag").
+ FlagWithArg("FlagWithArg=", "arg").
+ FlagWithInput("FlagWithInput=", "input").
+ FlagWithOutput("FlagWithOutput=", "output").
+ Implicit("Implicit").
+ ImplicitOutput("ImplicitOutput").
+ Input("Input").
+ Output("Output").
+ Text("Text").
+ Tool("Tool")
+
+ rule.Command().
+ Text("command2").
+ Input("input2").
+ Output("output2").
+ Tool("tool2")
+
+ // Test updates to the first command after the second command has been started
+ cmd.Text("after command2")
+ // Test updating a command when the previous update did not replace the cmd variable
+ cmd.Text("old cmd")
+
+ // Test a command that uses the output of a previous command as an input
+ rule.Command().
+ Text("command3").
+ Input("input3").
+ Input("output2").
+ Output("output3")
+
+ wantCommands := []string{
+ "Flag FlagWithArg=arg FlagWithInput=input FlagWithOutput=output Input Output Text Tool after command2 old cmd",
+ "command2 input2 output2 tool2",
+ "command3 input3 output2 output3",
+ }
+ wantInputs := []string{"Implicit", "Input", "input", "input2", "input3"}
+ wantOutputs := []string{"ImplicitOutput", "Output", "output", "output2", "output3"}
+ wantTools := []string{"Tool", "tool2"}
+
+ if !reflect.DeepEqual(rule.Commands(), wantCommands) {
+ t.Errorf("\nwant rule.Commands() = %#v\n got %#v", wantCommands, rule.Commands())
+ }
+ if !reflect.DeepEqual(rule.Inputs(), wantInputs) {
+ t.Errorf("\nwant rule.Inputs() = %#v\n got %#v", wantInputs, rule.Inputs())
+ }
+ if !reflect.DeepEqual(rule.Outputs(), wantOutputs) {
+ t.Errorf("\nwant rule.Outputs() = %#v\n got %#v", wantOutputs, rule.Outputs())
+ }
+ if !reflect.DeepEqual(rule.Tools(), wantTools) {
+ t.Errorf("\nwant rule.Tools() = %#v\n got %#v", wantTools, rule.Tools())
+ }
+}
+
+func testRuleBuilderFactory() Module {
+ module := &testRuleBuilderModule{}
+ module.AddProperties(&module.properties)
+ InitAndroidModule(module)
+ return module
+}
+
+type testRuleBuilderModule struct {
+ ModuleBase
+ properties struct {
+ Src string
+ }
+}
+
+func (t *testRuleBuilderModule) GenerateAndroidBuildActions(ctx ModuleContext) {
+ in := PathForSource(ctx, t.properties.Src)
+ out := PathForModuleOut(ctx, ctx.ModuleName())
+
+ testRuleBuilder_Build(ctx, in, out)
+}
+
+type testRuleBuilderSingleton struct{}
+
+func testRuleBuilderSingletonFactory() Singleton {
+ return &testRuleBuilderSingleton{}
+}
+
+func (t *testRuleBuilderSingleton) GenerateBuildActions(ctx SingletonContext) {
+ in := PathForSource(ctx, "bar")
+ out := PathForOutput(ctx, "baz")
+ testRuleBuilder_Build(ctx, in, out)
+}
+
+func testRuleBuilder_Build(ctx BuilderContext, in Path, out WritablePath) {
+ rule := NewRuleBuilder()
+
+ rule.Command().Tool("cp").Input(in.String()).Output(out.String())
+
+ rule.Build(pctx, ctx, "rule", "desc")
+}
+
+func TestRuleBuilder_Build(t *testing.T) {
+ buildDir, err := ioutil.TempDir("", "soong_test_rule_builder")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(buildDir)
+
+ bp := `
+ rule_builder_test {
+ name: "foo",
+ src: "bar",
+ }
+ `
+
+ config := TestConfig(buildDir, nil)
+ ctx := NewTestContext()
+ ctx.MockFileSystem(map[string][]byte{
+ "Android.bp": []byte(bp),
+ "bar": nil,
+ "cp": nil,
+ })
+ ctx.RegisterModuleType("rule_builder_test", ModuleFactoryAdaptor(testRuleBuilderFactory))
+ ctx.RegisterSingletonType("rule_builder_test", SingletonFactoryAdaptor(testRuleBuilderSingletonFactory))
+ ctx.Register()
+
+ _, errs := ctx.ParseFileList(".", []string{"Android.bp"})
+ FailIfErrored(t, errs)
+ _, errs = ctx.PrepareBuildActions(config)
+ FailIfErrored(t, errs)
+
+ foo := ctx.ModuleForTests("foo", "").Rule("rule")
+
+ // TODO: make RuleParams accessible to tests and verify rule.Command().Tools() ends up in CommandDeps
+
+ if len(foo.Implicits) != 1 || foo.Implicits[0].String() != "bar" {
+ t.Errorf("want foo.Implicits = [%q], got %q", "bar", foo.Implicits.Strings())
+ }
+
+ wantOutput := filepath.Join(buildDir, ".intermediates", "foo", "foo")
+ if len(foo.Outputs) != 1 || foo.Outputs[0].String() != wantOutput {
+ t.Errorf("want foo.Outputs = [%q], got %q", wantOutput, foo.Outputs.Strings())
+ }
+
+}
diff --git a/android/singleton.go b/android/singleton.go
index f926435..05ec6b5 100644
--- a/android/singleton.go
+++ b/android/singleton.go
@@ -22,6 +22,7 @@
// SingletonContext
type SingletonContext interface {
Config() Config
+ DeviceConfig() DeviceConfig
ModuleName(module blueprint.Module) string
ModuleDir(module blueprint.Module) string
@@ -93,6 +94,10 @@
return s.SingletonContext.Config().(Config)
}
+func (s singletonContextAdaptor) DeviceConfig() DeviceConfig {
+ return DeviceConfig{s.Config().deviceConfig}
+}
+
func (s singletonContextAdaptor) Variable(pctx PackageContext, name, value string) {
s.SingletonContext.Variable(pctx.PackageContext, name, value)
}
diff --git a/android/variable.go b/android/variable.go
index f38cf25..dc880b8 100644
--- a/android/variable.go
+++ b/android/variable.go
@@ -278,10 +278,9 @@
EnforceSystemCertificate *bool `json:",omitempty"`
EnforceSystemCertificateWhitelist []string `json:",omitempty"`
- // TODO(ccross): move these to a Singleton in Soong
- HiddenAPIStubFlags *string `json:",omitempty"`
- HiddenAPIFlags *string `json:",omitempty"`
- HiddenAPIExtraAppUsageJars []string `json:",omitempty"`
+ ProductHiddenAPIStubs []string `json:",omitempty"`
+ ProductHiddenAPIStubsSystem []string `json:",omitempty"`
+ ProductHiddenAPIStubsTest []string `json:",omitempty"`
}
func boolPtr(v bool) *bool {
diff --git a/apex/apex.go b/apex/apex.go
index 9172bb3..95cee0c 100644
--- a/apex/apex.go
+++ b/apex/apex.go
@@ -136,7 +136,9 @@
pctx.HostBinToolVariable("zip2zip", "zip2zip")
pctx.HostBinToolVariable("zipalign", "zipalign")
- android.RegisterModuleType("apex", ApexBundleFactory)
+ android.RegisterModuleType("apex", apexBundleFactory)
+ android.RegisterModuleType("apex_test", testApexBundleFactory)
+ android.RegisterModuleType("apex_defaults", defaultsFactory)
android.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.TopDown("apex_deps", apexDepsMutator)
@@ -147,13 +149,18 @@
// Mark the direct and transitive dependencies of apex bundles so that they
// can be built for the apex bundles.
func apexDepsMutator(mctx android.TopDownMutatorContext) {
- if _, ok := mctx.Module().(*apexBundle); ok {
+ if a, ok := mctx.Module().(*apexBundle); ok {
apexBundleName := mctx.ModuleName()
mctx.WalkDeps(func(child, parent android.Module) bool {
depName := mctx.OtherModuleName(child)
// If the parent is apexBundle, this child is directly depended.
_, directDep := parent.(*apexBundle)
- android.UpdateApexDependency(apexBundleName, depName, directDep)
+ if a.installable() && !a.testApex {
+ // TODO(b/123892969): Workaround for not having any way to annotate test-apexs
+ // non-installable apex's cannot be installed and so should not prevent libraries from being
+ // installed to the system.
+ android.UpdateApexDependency(apexBundleName, depName, directDep)
+ }
if am, ok := child.(android.ApexModule); ok && am.CanHaveApexVariants() {
am.BuildForApex(apexBundleName)
@@ -274,6 +281,7 @@
etc apexFileClass = iota
nativeSharedLib
nativeExecutable
+ shBinary
javaSharedLib
)
@@ -333,7 +341,7 @@
return "ETC"
case nativeSharedLib:
return "SHARED_LIBRARIES"
- case nativeExecutable:
+ case nativeExecutable, shBinary:
return "EXECUTABLES"
case javaSharedLib:
return "JAVA_LIBRARIES"
@@ -368,6 +376,8 @@
filesInfo []apexFile
flattened bool
+
+ testApex bool
}
func addDependenciesForNativeModules(ctx android.BottomUpMutatorContext,
@@ -570,6 +580,12 @@
return
}
+func getCopyManifestForShBinary(sh *android.ShBinary) (fileToCopy android.Path, dirInApex string) {
+ dirInApex = filepath.Join("bin", sh.SubDir())
+ fileToCopy = sh.OutputFile()
+ return
+}
+
func getCopyManifestForJavaLibrary(java *java.Library) (fileToCopy android.Path, dirInApex string) {
dirInApex = "javalib"
fileToCopy = java.DexJarFile()
@@ -626,8 +642,11 @@
fileToCopy, dirInApex := getCopyManifestForExecutable(cc)
filesInfo = append(filesInfo, apexFile{fileToCopy, depName, dirInApex, nativeExecutable, cc, cc.Symlinks()})
return true
+ } else if sh, ok := child.(*android.ShBinary); ok {
+ fileToCopy, dirInApex := getCopyManifestForShBinary(sh)
+ filesInfo = append(filesInfo, apexFile{fileToCopy, depName, dirInApex, shBinary, sh, nil})
} else {
- ctx.PropertyErrorf("binaries", "%q is not a cc_binary module", depName)
+ ctx.PropertyErrorf("binaries", "%q is neithher cc_binary nor sh_binary", depName)
}
case javaLibTag:
if java, ok := child.(*java.Library); ok {
@@ -954,91 +973,99 @@
}}
}
+func (a *apexBundle) androidMkForFiles(w io.Writer, name, moduleDir string) []string {
+ moduleNames := []string{}
+
+ for _, fi := range a.filesInfo {
+ if cc, ok := fi.module.(*cc.Module); ok && cc.Properties.HideFromMake {
+ continue
+ }
+ if !android.InList(fi.moduleName, moduleNames) {
+ moduleNames = append(moduleNames, fi.moduleName)
+ }
+ fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
+ fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
+ fmt.Fprintln(w, "LOCAL_MODULE :=", fi.moduleName)
+ if a.flattened {
+ // /system/apex/<name>/{lib|framework|...}
+ fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", filepath.Join("$(OUT_DIR)",
+ a.installDir.RelPathString(), name, fi.installDir))
+ } else {
+ // /apex/<name>/{lib|framework|...}
+ fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", filepath.Join("$(PRODUCT_OUT)",
+ "apex", name, fi.installDir))
+ }
+ fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", fi.builtFile.String())
+ fmt.Fprintln(w, "LOCAL_MODULE_CLASS :=", fi.class.NameInMake())
+ if fi.module != nil {
+ archStr := fi.module.Target().Arch.ArchType.String()
+ host := false
+ switch fi.module.Target().Os.Class {
+ case android.Host:
+ if archStr != "common" {
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH :=", archStr)
+ }
+ host = true
+ case android.HostCross:
+ if archStr != "common" {
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH :=", archStr)
+ }
+ host = true
+ case android.Device:
+ if archStr != "common" {
+ fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
+ }
+ }
+ if host {
+ makeOs := fi.module.Target().Os.String()
+ if fi.module.Target().Os == android.Linux || fi.module.Target().Os == android.LinuxBionic {
+ makeOs = "linux"
+ }
+ fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", makeOs)
+ fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
+ }
+ }
+ if fi.class == javaSharedLib {
+ javaModule := fi.module.(*java.Library)
+ // soong_java_prebuilt.mk sets LOCAL_MODULE_SUFFIX := .jar Therefore
+ // we need to remove the suffix from LOCAL_MODULE_STEM, otherwise
+ // we will have foo.jar.jar
+ fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.builtFile.Base(), ".jar"))
+ fmt.Fprintln(w, "LOCAL_SOONG_CLASSES_JAR :=", javaModule.ImplementationAndResourcesJars()[0].String())
+ fmt.Fprintln(w, "LOCAL_SOONG_HEADER_JAR :=", javaModule.HeaderJars()[0].String())
+ fmt.Fprintln(w, "LOCAL_SOONG_DEX_JAR :=", fi.builtFile.String())
+ fmt.Fprintln(w, "LOCAL_DEX_PREOPT := false")
+ fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_java_prebuilt.mk")
+ } else if fi.class == nativeSharedLib || fi.class == nativeExecutable {
+ fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
+ if cc, ok := fi.module.(*cc.Module); ok && cc.UnstrippedOutputFile() != nil {
+ fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", cc.UnstrippedOutputFile().String())
+ }
+ fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_cc_prebuilt.mk")
+ } else {
+ fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
+ fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
+ }
+ }
+ return moduleNames
+}
+
func (a *apexBundle) androidMkForType(apexType apexPackaging) android.AndroidMkData {
return android.AndroidMkData{
Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) {
moduleNames := []string{}
- for _, fi := range a.filesInfo {
- if !android.InList(fi.moduleName, moduleNames) {
- moduleNames = append(moduleNames, fi.moduleName)
- }
+ if a.installable() {
+ moduleNames = a.androidMkForFiles(w, name, moduleDir)
}
- for _, fi := range a.filesInfo {
- if cc, ok := fi.module.(*cc.Module); ok && cc.Properties.HideFromMake {
- continue
- }
- fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
- fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
- fmt.Fprintln(w, "LOCAL_MODULE :=", fi.moduleName)
- if a.flattened {
- // /system/apex/<name>/{lib|framework|...}
- fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", filepath.Join("$(OUT_DIR)",
- a.installDir.RelPathString(), name, fi.installDir))
- } else {
- // /apex/<name>/{lib|framework|...}
- fmt.Fprintln(w, "LOCAL_MODULE_PATH :=", filepath.Join("$(PRODUCT_OUT)",
- "apex", name, fi.installDir))
- }
- fmt.Fprintln(w, "LOCAL_PREBUILT_MODULE_FILE :=", fi.builtFile.String())
- fmt.Fprintln(w, "LOCAL_MODULE_CLASS :=", fi.class.NameInMake())
- fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE :=", !a.installable())
- if fi.module != nil {
- archStr := fi.module.Target().Arch.ArchType.String()
- host := false
- switch fi.module.Target().Os.Class {
- case android.Host:
- if archStr != "common" {
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_ARCH :=", archStr)
- }
- host = true
- case android.HostCross:
- if archStr != "common" {
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_CROSS_ARCH :=", archStr)
- }
- host = true
- case android.Device:
- if archStr != "common" {
- fmt.Fprintln(w, "LOCAL_MODULE_TARGET_ARCH :=", archStr)
- }
- }
- if host {
- makeOs := fi.module.Target().Os.String()
- if fi.module.Target().Os == android.Linux || fi.module.Target().Os == android.LinuxBionic {
- makeOs = "linux"
- }
- fmt.Fprintln(w, "LOCAL_MODULE_HOST_OS :=", makeOs)
- fmt.Fprintln(w, "LOCAL_IS_HOST_MODULE := true")
- }
- }
- if fi.class == javaSharedLib {
- javaModule := fi.module.(*java.Library)
- // soong_java_prebuilt.mk sets LOCAL_MODULE_SUFFIX := .jar Therefore
- // we need to remove the suffix from LOCAL_MODULE_STEM, otherwise
- // we will have foo.jar.jar
- fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", strings.TrimSuffix(fi.builtFile.Base(), ".jar"))
- fmt.Fprintln(w, "LOCAL_SOONG_CLASSES_JAR :=", javaModule.ImplementationAndResourcesJars()[0].String())
- fmt.Fprintln(w, "LOCAL_SOONG_HEADER_JAR :=", javaModule.HeaderJars()[0].String())
- fmt.Fprintln(w, "LOCAL_SOONG_DEX_JAR :=", fi.builtFile.String())
- fmt.Fprintln(w, "LOCAL_DEX_PREOPT := false")
- fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_java_prebuilt.mk")
- } else if fi.class == nativeSharedLib || fi.class == nativeExecutable {
- fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
- if cc, ok := fi.module.(*cc.Module); ok && cc.UnstrippedOutputFile() != nil {
- fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", cc.UnstrippedOutputFile().String())
- }
- fmt.Fprintln(w, "include $(BUILD_SYSTEM)/soong_cc_prebuilt.mk")
- } else {
- fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", fi.builtFile.Base())
- fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
- }
- }
if a.flattened && apexType.image() {
// Only image APEXes can be flattened.
fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)")
fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir)
fmt.Fprintln(w, "LOCAL_MODULE :=", name)
- fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES :=", strings.Join(moduleNames, " "))
+ if len(moduleNames) > 0 {
+ fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES :=", strings.Join(moduleNames, " "))
+ }
fmt.Fprintln(w, "include $(BUILD_PHONY_PACKAGE)")
} else {
// zip-apex is the less common type so have the name refer to the image-apex
@@ -1055,7 +1082,9 @@
fmt.Fprintln(w, "LOCAL_MODULE_STEM :=", name+apexType.suffix())
fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE :=", !a.installable())
fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES :=", String(a.properties.Key))
- fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES +=", strings.Join(moduleNames, " "))
+ if len(moduleNames) > 0 {
+ fmt.Fprintln(w, "LOCAL_REQUIRED_MODULES +=", strings.Join(moduleNames, " "))
+ }
fmt.Fprintln(w, "include $(BUILD_PREBUILT)")
if apexType == imageApex {
@@ -1065,9 +1094,18 @@
}}
}
-func ApexBundleFactory() android.Module {
+func testApexBundleFactory() android.Module {
+ return ApexBundleFactory( /*testApex*/ true)
+}
+
+func apexBundleFactory() android.Module {
+ return ApexBundleFactory( /*testApex*/ false)
+}
+
+func ApexBundleFactory(testApex bool) android.Module {
module := &apexBundle{
outputFiles: map[apexPackaging]android.WritablePath{},
+ testApex: testApex,
}
module.AddProperties(&module.properties)
module.AddProperties(&module.targetProperties)
@@ -1078,3 +1116,31 @@
android.InitDefaultableModule(module)
return module
}
+
+//
+// Defaults
+//
+type Defaults struct {
+ android.ModuleBase
+ android.DefaultsModuleBase
+}
+
+func (*Defaults) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+}
+
+func defaultsFactory() android.Module {
+ return DefaultsFactory()
+}
+
+func DefaultsFactory(props ...interface{}) android.Module {
+ module := &Defaults{}
+
+ module.AddProperties(props...)
+ module.AddProperties(
+ &apexBundleProperties{},
+ &apexTargetBundleProperties{},
+ )
+
+ android.InitDefaultsModule(module)
+ return module
+}
diff --git a/apex/apex_test.go b/apex/apex_test.go
index 1315c25..2c7f285 100644
--- a/apex/apex_test.go
+++ b/apex/apex_test.go
@@ -31,8 +31,11 @@
defer teardown(buildDir)
ctx := android.NewTestArchContext()
- ctx.RegisterModuleType("apex", android.ModuleFactoryAdaptor(ApexBundleFactory))
+ ctx.RegisterModuleType("apex", android.ModuleFactoryAdaptor(apexBundleFactory))
+ ctx.RegisterModuleType("apex_test", android.ModuleFactoryAdaptor(testApexBundleFactory))
ctx.RegisterModuleType("apex_key", android.ModuleFactoryAdaptor(apexKeyFactory))
+ ctx.RegisterModuleType("apex_defaults", android.ModuleFactoryAdaptor(defaultsFactory))
+ ctx.PreArchMutators(android.RegisterDefaultsPreArchMutators)
ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.TopDown("apex_deps", apexDepsMutator)
@@ -47,6 +50,7 @@
ctx.RegisterModuleType("llndk_library", android.ModuleFactoryAdaptor(cc.LlndkLibraryFactory))
ctx.RegisterModuleType("toolchain_library", android.ModuleFactoryAdaptor(cc.ToolchainLibraryFactory))
ctx.RegisterModuleType("prebuilt_etc", android.ModuleFactoryAdaptor(android.PrebuiltEtcFactory))
+ ctx.RegisterModuleType("sh_binary", android.ModuleFactoryAdaptor(android.ShBinaryFactory))
ctx.PreDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.BottomUp("image", cc.ImageMutator).Parallel()
ctx.BottomUp("link", cc.LinkageMutator).Parallel()
@@ -200,8 +204,8 @@
// Minimal test
func TestBasicApex(t *testing.T) {
ctx := testApex(t, `
- apex {
- name: "myapex",
+ apex_defaults {
+ name: "myapex-defaults",
key: "myapex.key",
native_shared_libs: ["mylib"],
multilib: {
@@ -211,6 +215,11 @@
}
}
+ apex {
+ name: "myapex",
+ defaults: ["myapex-defaults"],
+ }
+
apex_key {
name: "myapex.key",
public_key: "testkey.avbpubkey",
@@ -896,6 +905,105 @@
ensureContains(t, cFlags, "-Imy_include")
}
+func TestNonTestApex(t *testing.T) {
+ ctx := testApex(t, `
+ apex {
+ name: "myapex",
+ key: "myapex.key",
+ native_shared_libs: ["mylib_common"],
+ }
+
+ apex_key {
+ name: "myapex.key",
+ public_key: "testkey.avbpubkey",
+ private_key: "testkey.pem",
+ }
+
+ cc_library {
+ name: "mylib_common",
+ srcs: ["mylib.cpp"],
+ system_shared_libs: [],
+ stl: "none",
+ }
+ `)
+
+ module := ctx.ModuleForTests("myapex", "android_common_myapex")
+ apexRule := module.Rule("apexRule")
+ copyCmds := apexRule.Args["copy_commands"]
+
+ if apex, ok := module.Module().(*apexBundle); !ok || apex.testApex {
+ t.Log("Apex was a test apex!")
+ t.Fail()
+ }
+ // Ensure that main rule creates an output
+ ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
+
+ // Ensure that apex variant is created for the direct dep
+ ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared_myapex")
+
+ // Ensure that both direct and indirect deps are copied into apex
+ ensureContains(t, copyCmds, "image.apex/lib64/mylib_common.so")
+
+ // Ensure that the platform variant ends with _core_shared
+ ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared")
+
+ if !android.InAnyApex("mylib_common") {
+ t.Log("Found mylib_common not in any apex!")
+ t.Fail()
+ }
+}
+
+func TestTestApex(t *testing.T) {
+ if android.InAnyApex("mylib_common_test") {
+ t.Fatal("mylib_common_test must not be used in any other tests since this checks that global state is not updated in an illegal way!")
+ }
+ ctx := testApex(t, `
+ apex_test {
+ name: "myapex",
+ key: "myapex.key",
+ native_shared_libs: ["mylib_common_test"],
+ }
+
+ apex_key {
+ name: "myapex.key",
+ public_key: "testkey.avbpubkey",
+ private_key: "testkey.pem",
+ }
+
+ cc_library {
+ name: "mylib_common_test",
+ srcs: ["mylib.cpp"],
+ system_shared_libs: [],
+ stl: "none",
+ }
+ `)
+
+ module := ctx.ModuleForTests("myapex", "android_common_myapex")
+ apexRule := module.Rule("apexRule")
+ copyCmds := apexRule.Args["copy_commands"]
+
+ if apex, ok := module.Module().(*apexBundle); !ok || !apex.testApex {
+ t.Log("Apex was not a test apex!")
+ t.Fail()
+ }
+ // Ensure that main rule creates an output
+ ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
+
+ // Ensure that apex variant is created for the direct dep
+ ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_core_shared_myapex")
+
+ // Ensure that both direct and indirect deps are copied into apex
+ ensureContains(t, copyCmds, "image.apex/lib64/mylib_common_test.so")
+
+ // Ensure that the platform variant ends with _core_shared
+ ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_core_shared")
+
+ if android.InAnyApex("mylib_common_test") {
+ t.Log("Found mylib_common_test in some apex!")
+ t.Fail()
+ }
+}
+
func TestApexWithTarget(t *testing.T) {
ctx := testApex(t, `
apex {
@@ -975,3 +1083,31 @@
ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_core_shared")
ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_core_shared")
}
+
+func TestApexWithShBinary(t *testing.T) {
+ ctx := testApex(t, `
+ apex {
+ name: "myapex",
+ key: "myapex.key",
+ binaries: ["myscript"],
+ }
+
+ apex_key {
+ name: "myapex.key",
+ public_key: "testkey.avbpubkey",
+ private_key: "testkey.pem",
+ }
+
+ sh_binary {
+ name: "myscript",
+ src: "mylib.cpp",
+ filename: "myscript.sh",
+ sub_dir: "script",
+ }
+ `)
+
+ apexRule := ctx.ModuleForTests("myapex", "android_common_myapex").Rule("apexRule")
+ copyCmds := apexRule.Args["copy_commands"]
+
+ ensureContains(t, copyCmds, "image.apex/bin/script/myscript.sh")
+}
diff --git a/cc/androidmk.go b/cc/androidmk.go
index 0e4245e..fc791fe 100644
--- a/cc/androidmk.go
+++ b/cc/androidmk.go
@@ -152,7 +152,9 @@
ret.Class = "SHARED_LIBRARIES"
ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
fmt.Fprintln(w, "LOCAL_SOONG_TOC :=", library.toc().String())
- fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", library.unstrippedOutputFile.String())
+ if !library.buildStubs() {
+ fmt.Fprintln(w, "LOCAL_SOONG_UNSTRIPPED_BINARY :=", library.unstrippedOutputFile.String())
+ }
if len(library.Properties.Overrides) > 0 {
fmt.Fprintln(w, "LOCAL_OVERRIDES_MODULES := "+strings.Join(library.Properties.Overrides, " "))
}
diff --git a/cc/cc.go b/cc/cc.go
index 02f36d5..c09a2f3 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -1378,6 +1378,7 @@
// NDK code linking to platform code is never okay.
ctx.ModuleErrorf("depends on non-NDK-built library %q",
ctx.OtherModuleName(to))
+ return
}
// At this point we know we have two NDK libraries, but we need to
diff --git a/cc/compiler.go b/cc/compiler.go
index fbe10b5..0aee0bd 100644
--- a/cc/compiler.go
+++ b/cc/compiler.go
@@ -250,8 +250,8 @@
return false
}
-func addToModuleList(ctx ModuleContext, list string, module string) {
- getNamedMapForConfig(ctx.Config(), list).Store(module, true)
+func addToModuleList(ctx ModuleContext, key android.OnceKey, module string) {
+ getNamedMapForConfig(ctx.Config(), key).Store(module, true)
}
// Create a Flags struct that collects the compile flags from global values,
@@ -503,10 +503,10 @@
if len(compiler.Properties.Srcs) > 0 {
module := ctx.ModuleDir() + "/Android.bp:" + ctx.ModuleName()
if inList("-Wno-error", flags.CFlags) || inList("-Wno-error", flags.CppFlags) {
- addToModuleList(ctx, modulesUsingWnoError, module)
+ addToModuleList(ctx, modulesUsingWnoErrorKey, module)
} else if !inList("-Werror", flags.CFlags) && !inList("-Werror", flags.CppFlags) {
if warningsAreAllowed(ctx.ModuleDir()) {
- addToModuleList(ctx, modulesAddedWall, module)
+ addToModuleList(ctx, modulesAddedWallKey, module)
flags.CFlags = append([]string{"-Wall"}, flags.CFlags...)
} else {
flags.CFlags = append([]string{"-Wall", "-Werror"}, flags.CFlags...)
diff --git a/cc/gen_stub_libs.py b/cc/gen_stub_libs.py
index 4906ea2..81bc398 100755
--- a/cc/gen_stub_libs.py
+++ b/cc/gen_stub_libs.py
@@ -119,9 +119,12 @@
return True
if 'platform-only' in version.tags:
return True
- if 'vndk' in version.tags and not vndk:
- return True
- if 'apex' in version.tags and not apex:
+
+ no_vndk_no_apex = 'vndk' not in version.tags and 'apex' not in version.tags
+ keep = no_vndk_no_apex or \
+ ('vndk' in version.tags and vndk) or \
+ ('apex' in version.tags and apex)
+ if not keep:
return True
if not symbol_in_arch(version.tags, arch):
return True
@@ -132,9 +135,11 @@
def should_omit_symbol(symbol, arch, api, vndk, apex):
"""Returns True if the symbol should be omitted."""
- if not vndk and 'vndk' in symbol.tags:
- return True
- if not apex and 'apex' in symbol.tags:
+ no_vndk_no_apex = 'vndk' not in symbol.tags and 'apex' not in symbol.tags
+ keep = no_vndk_no_apex or \
+ ('vndk' in symbol.tags and vndk) or \
+ ('apex' in symbol.tags and apex)
+ if not keep:
return True
if not symbol_in_arch(symbol.tags, arch):
return True
diff --git a/cc/library.go b/cc/library.go
index d716ffa..b4b89d2 100644
--- a/cc/library.go
+++ b/cc/library.go
@@ -968,8 +968,10 @@
return library.MutatedProperties.StubsVersion
}
+var versioningMacroNamesListKey = android.NewOnceKey("versioningMacroNamesList")
+
func versioningMacroNamesList(config android.Config) *map[string]string {
- return config.Once("versioningMacroNamesList", func() interface{} {
+ return config.Once(versioningMacroNamesListKey, func() interface{} {
m := make(map[string]string)
return &m
}).(*map[string]string)
@@ -1059,9 +1061,11 @@
}
}
+var stubVersionsKey = android.NewOnceKey("stubVersions")
+
// maps a module name to the list of stubs versions available for the module
func stubsVersionsFor(config android.Config) map[string][]string {
- return config.Once("stubVersions", func() interface{} {
+ return config.Once(stubVersionsKey, func() interface{} {
return make(map[string][]string)
}).(map[string][]string)
}
diff --git a/cc/makevars.go b/cc/makevars.go
index fb567ba..4a9ade2 100644
--- a/cc/makevars.go
+++ b/cc/makevars.go
@@ -24,24 +24,24 @@
"android/soong/cc/config"
)
-const (
- modulesAddedWall = "ModulesAddedWall"
- modulesUsingWnoError = "ModulesUsingWnoError"
- modulesMissingProfileFile = "ModulesMissingProfileFile"
+var (
+ modulesAddedWallKey = android.NewOnceKey("ModulesAddedWall")
+ modulesUsingWnoErrorKey = android.NewOnceKey("ModulesUsingWnoError")
+ modulesMissingProfileFileKey = android.NewOnceKey("ModulesMissingProfileFile")
)
func init() {
android.RegisterMakeVarsProvider(pctx, makeVarsProvider)
}
-func getNamedMapForConfig(config android.Config, name string) *sync.Map {
- return config.Once(name, func() interface{} {
+func getNamedMapForConfig(config android.Config, key android.OnceKey) *sync.Map {
+ return config.Once(key, func() interface{} {
return &sync.Map{}
}).(*sync.Map)
}
-func makeStringOfKeys(ctx android.MakeVarsContext, setName string) string {
- set := getNamedMapForConfig(ctx.Config(), setName)
+func makeStringOfKeys(ctx android.MakeVarsContext, key android.OnceKey) string {
+ set := getNamedMapForConfig(ctx.Config(), key)
keys := []string{}
set.Range(func(key interface{}, value interface{}) bool {
keys = append(keys, key.(string))
@@ -100,7 +100,7 @@
// Filter vendor_public_library that are exported to make
exportedVendorPublicLibraries := []string{}
- ctx.SingletonContext().VisitAllModules(func(module android.Module) {
+ ctx.VisitAllModules(func(module android.Module) {
if ccModule, ok := module.(*Module); ok {
baseName := ccModule.BaseModuleName()
if inList(baseName, vendorPublicLibraries) && module.ExportedToMake() {
@@ -117,9 +117,9 @@
ctx.Strict("LSDUMP_PATHS", strings.Join(lsdumpPaths, " "))
ctx.Strict("ANDROID_WARNING_ALLOWED_PROJECTS", makeStringOfWarningAllowedProjects())
- ctx.Strict("SOONG_MODULES_ADDED_WALL", makeStringOfKeys(ctx, modulesAddedWall))
- ctx.Strict("SOONG_MODULES_USING_WNO_ERROR", makeStringOfKeys(ctx, modulesUsingWnoError))
- ctx.Strict("SOONG_MODULES_MISSING_PGO_PROFILE_FILE", makeStringOfKeys(ctx, modulesMissingProfileFile))
+ ctx.Strict("SOONG_MODULES_ADDED_WALL", makeStringOfKeys(ctx, modulesAddedWallKey))
+ ctx.Strict("SOONG_MODULES_USING_WNO_ERROR", makeStringOfKeys(ctx, modulesUsingWnoErrorKey))
+ ctx.Strict("SOONG_MODULES_MISSING_PGO_PROFILE_FILE", makeStringOfKeys(ctx, modulesMissingProfileFileKey))
ctx.Strict("ADDRESS_SANITIZER_CONFIG_EXTRA_CFLAGS", strings.Join(asanCflags, " "))
ctx.Strict("ADDRESS_SANITIZER_CONFIG_EXTRA_LDFLAGS", strings.Join(asanLdflags, " "))
diff --git a/cc/ndk_library.go b/cc/ndk_library.go
index 1b09f88..3ae4452 100644
--- a/cc/ndk_library.go
+++ b/cc/ndk_library.go
@@ -53,6 +53,7 @@
"OpenMAXAL",
"OpenSLES",
"stdc++",
+ "sync",
"vulkan",
"z",
}
diff --git a/cc/pgo.go b/cc/pgo.go
index a341ab9..9363916 100644
--- a/cc/pgo.go
+++ b/cc/pgo.go
@@ -36,7 +36,8 @@
}
)
-const pgoProfileProjectsConfigKey = "PgoProfileProjects"
+var pgoProfileProjectsConfigKey = android.NewOnceKey("PgoProfileProjects")
+
const profileInstrumentFlag = "-fprofile-generate=/data/local/tmp"
const profileSamplingFlag = "-gline-tables-only"
const profileUseInstrumentFormat = "-fprofile-use=%s"
@@ -49,7 +50,7 @@
}
func recordMissingProfileFile(ctx BaseModuleContext, missing string) {
- getNamedMapForConfig(ctx.Config(), modulesMissingProfileFile).Store(missing, true)
+ getNamedMapForConfig(ctx.Config(), modulesMissingProfileFileKey).Store(missing, true)
}
type PgoProperties struct {
diff --git a/cc/sanitize.go b/cc/sanitize.go
index bcc4de3..fc2ed50 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -958,20 +958,26 @@
}
}
+var cfiStaticLibsKey = android.NewOnceKey("cfiStaticLibs")
+
func cfiStaticLibs(config android.Config) *[]string {
- return config.Once("cfiStaticLibs", func() interface{} {
+ return config.Once(cfiStaticLibsKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
+var hwasanStaticLibsKey = android.NewOnceKey("hwasanStaticLibs")
+
func hwasanStaticLibs(config android.Config) *[]string {
- return config.Once("hwasanStaticLibs", func() interface{} {
+ return config.Once(hwasanStaticLibsKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
+var hwasanVendorStaticLibsKey = android.NewOnceKey("hwasanVendorStaticLibs")
+
func hwasanVendorStaticLibs(config android.Config) *[]string {
- return config.Once("hwasanVendorStaticLibs", func() interface{} {
+ return config.Once(hwasanVendorStaticLibsKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
diff --git a/cc/test_gen_stub_libs.py b/cc/test_gen_stub_libs.py
index 594c1bc..2ee9886 100755
--- a/cc/test_gen_stub_libs.py
+++ b/cc/test_gen_stub_libs.py
@@ -751,6 +751,8 @@
wibble;
wizzes; # vndk
waggle; # apex
+ bubble; # apex vndk
+ duddle; # vndk apex
} VERSION_2;
VERSION_5 { # versioned=14
@@ -771,6 +773,8 @@
void qux() {}
void wibble() {}
void waggle() {}
+ void bubble() {}
+ void duddle() {}
void wobble() {}
""")
self.assertEqual(expected_src, src_file.getvalue())
@@ -788,6 +792,8 @@
global:
wibble;
waggle;
+ bubble;
+ duddle;
} VERSION_2;
""")
self.assertEqual(expected_version, version_file.getvalue())
diff --git a/cmd/multiproduct_kati/main.go b/cmd/multiproduct_kati/main.go
index 6a3d579..330c5dd 100644
--- a/cmd/multiproduct_kati/main.go
+++ b/cmd/multiproduct_kati/main.go
@@ -172,7 +172,8 @@
stat := &status.Status{}
defer stat.Finish()
- stat.AddOutput(terminal.NewStatusOutput(writer, ""))
+ stat.AddOutput(terminal.NewStatusOutput(writer, "",
+ build.OsEnvironment().IsEnvTrue("ANDROID_QUIET_BUILD")))
var failures failureCount
stat.AddOutput(&failures)
@@ -389,7 +390,8 @@
Thread: mpctx.Tracer.NewThread(product),
Status: &status.Status{},
}}
- ctx.Status.AddOutput(terminal.NewStatusOutput(ctx.Writer, ""))
+ ctx.Status.AddOutput(terminal.NewStatusOutput(ctx.Writer, "",
+ build.OsEnvironment().IsEnvTrue("ANDROID_QUIET_BUILD")))
config := build.NewConfig(ctx, flag.Args()...)
config.Environment().Set("OUT_DIR", outDir)
diff --git a/cmd/soong_ui/main.go b/cmd/soong_ui/main.go
index 0380368..d6999c5 100644
--- a/cmd/soong_ui/main.go
+++ b/cmd/soong_ui/main.go
@@ -78,7 +78,8 @@
stat := &status.Status{}
defer stat.Finish()
- stat.AddOutput(terminal.NewStatusOutput(writer, os.Getenv("NINJA_STATUS")))
+ stat.AddOutput(terminal.NewStatusOutput(writer, os.Getenv("NINJA_STATUS"),
+ build.OsEnvironment().IsEnvTrue("ANDROID_QUIET_BUILD")))
stat.AddOutput(trace.StatusTracer())
build.SetupSignals(log, cancel, func() {
diff --git a/dexpreopt/Android.bp b/dexpreopt/Android.bp
index b832529..c5f24e2 100644
--- a/dexpreopt/Android.bp
+++ b/dexpreopt/Android.bp
@@ -4,12 +4,12 @@
srcs: [
"config.go",
"dexpreopt.go",
- "script.go",
],
testSrcs: [
"dexpreopt_test.go",
],
deps: [
"blueprint-pathtools",
+ "soong-android",
],
-}
\ No newline at end of file
+}
diff --git a/dexpreopt/config.go b/dexpreopt/config.go
index 3725146..319e36e 100644
--- a/dexpreopt/config.go
+++ b/dexpreopt/config.go
@@ -91,7 +91,6 @@
DexLocation string // dex location on device
BuildPath string
DexPath string
- UseEmbeddedDex bool
UncompressedDex bool
HasApkLibraries bool
PreoptFlags []string
diff --git a/dexpreopt/dexpreopt.go b/dexpreopt/dexpreopt.go
index f316be4..c38fbff 100644
--- a/dexpreopt/dexpreopt.go
+++ b/dexpreopt/dexpreopt.go
@@ -39,6 +39,8 @@
"path/filepath"
"strings"
+ "android/soong/android"
+
"github.com/google/blueprint/pathtools"
)
@@ -47,7 +49,7 @@
// GenerateStripRule generates a set of commands that will take an APK or JAR as an input and strip the dex files if
// they are no longer necessary after preopting.
-func GenerateStripRule(global GlobalConfig, module ModuleConfig) (rule *Rule, err error) {
+func GenerateStripRule(global GlobalConfig, module ModuleConfig) (rule *android.RuleBuilder, err error) {
defer func() {
if r := recover(); r != nil {
if e, ok := r.(error); ok {
@@ -61,7 +63,7 @@
tools := global.Tools
- rule = &Rule{}
+ rule = android.NewRuleBuilder()
strip := shouldStripDex(module, global)
@@ -81,7 +83,7 @@
// GenerateDexpreoptRule generates a set of commands that will preopt a module based on a GlobalConfig and a
// ModuleConfig. The produced files and their install locations will be available through rule.Installs().
-func GenerateDexpreoptRule(global GlobalConfig, module ModuleConfig) (rule *Rule, err error) {
+func GenerateDexpreoptRule(global GlobalConfig, module ModuleConfig) (rule *android.RuleBuilder, err error) {
defer func() {
if r := recover(); r != nil {
if e, ok := r.(error); ok {
@@ -93,7 +95,7 @@
}
}()
- rule = &Rule{}
+ rule = android.NewRuleBuilder()
generateProfile := module.ProfileClassListing != "" && !global.DisableGenerateProfile
@@ -141,7 +143,7 @@
return false
}
-func profileCommand(global GlobalConfig, module ModuleConfig, rule *Rule) string {
+func profileCommand(global GlobalConfig, module ModuleConfig, rule *android.RuleBuilder) string {
profilePath := filepath.Join(filepath.Dir(module.BuildPath), "profile.prof")
profileInstalledPath := module.DexLocation + ".prof"
@@ -178,8 +180,8 @@
return profilePath
}
-func dexpreoptCommand(global GlobalConfig, module ModuleConfig, rule *Rule, profile, arch, bootImageLocation string,
- appImage, generateDM bool) {
+func dexpreoptCommand(global GlobalConfig, module ModuleConfig, rule *android.RuleBuilder,
+ profile, arch, bootImageLocation string, appImage, generateDM bool) {
// HACK: make soname in Soong-generated .odex files match Make.
base := filepath.Base(module.DexLocation)
diff --git a/dexpreopt/dexpreopt_gen/dexpreopt_gen.go b/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
index 46d8795..1467a02 100644
--- a/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
+++ b/dexpreopt/dexpreopt_gen/dexpreopt_gen.go
@@ -22,6 +22,7 @@
"path/filepath"
"runtime"
+ "android/soong/android"
"android/soong/dexpreopt"
"github.com/google/blueprint/pathtools"
@@ -121,7 +122,7 @@
panic(err)
}
- write := func(rule *dexpreopt.Rule, file string) {
+ write := func(rule *android.RuleBuilder, file string) {
script := &bytes.Buffer{}
script.WriteString(scriptHeader)
for _, c := range rule.Commands() {
diff --git a/dexpreopt/dexpreopt_test.go b/dexpreopt/dexpreopt_test.go
index 073d463..d949852 100644
--- a/dexpreopt/dexpreopt_test.go
+++ b/dexpreopt/dexpreopt_test.go
@@ -15,6 +15,7 @@
package dexpreopt
import (
+ "android/soong/android"
"reflect"
"strings"
"testing"
@@ -66,7 +67,6 @@
DexLocation: "",
BuildPath: "",
DexPath: "",
- UseEmbeddedDex: false,
UncompressedDex: false,
HasApkLibraries: false,
PreoptFlags: nil,
@@ -100,7 +100,7 @@
t.Error(err)
}
- wantInstalls := []Install{
+ wantInstalls := []android.RuleBuilderInstall{
{"out/test/oat/arm/package.odex", "/system/app/test/oat/arm/test.odex"},
{"out/test/oat/arm/package.vdex", "/system/app/test/oat/arm/test.vdex"},
}
@@ -126,7 +126,7 @@
t.Error(err)
}
- wantInstalls := []Install{
+ wantInstalls := []android.RuleBuilderInstall{
{"out/test/oat/arm/package.odex", "/system_other/app/test/oat/arm/test.odex"},
{"out/test/oat/arm/package.vdex", "/system_other/app/test/oat/arm/test.vdex"},
}
@@ -150,7 +150,7 @@
t.Error(err)
}
- wantInstalls := []Install{
+ wantInstalls := []android.RuleBuilderInstall{
{"out/test/profile.prof", "/system/app/test/test.apk.prof"},
{"out/test/oat/arm/package.art", "/system/app/test/oat/arm/test.art"},
{"out/test/oat/arm/package.odex", "/system/app/test/oat/arm/test.odex"},
diff --git a/dexpreopt/script.go b/dexpreopt/script.go
deleted file mode 100644
index 9d4329c..0000000
--- a/dexpreopt/script.go
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2018 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 dexpreopt
-
-import (
- "fmt"
- "sort"
- "strings"
-)
-
-type Install struct {
- From, To string
-}
-
-type Rule struct {
- commands []*Command
- installs []Install
-}
-
-func (r *Rule) Install(from, to string) {
- r.installs = append(r.installs, Install{from, to})
-}
-
-func (r *Rule) Command() *Command {
- command := &Command{}
- r.commands = append(r.commands, command)
- return command
-}
-
-func (r *Rule) Inputs() []string {
- outputs := r.outputSet()
-
- inputs := make(map[string]bool)
- for _, c := range r.commands {
- for _, input := range c.inputs {
- if !outputs[input] {
- inputs[input] = true
- }
- }
- }
-
- var inputList []string
- for input := range inputs {
- inputList = append(inputList, input)
- }
- sort.Strings(inputList)
-
- return inputList
-}
-
-func (r *Rule) outputSet() map[string]bool {
- outputs := make(map[string]bool)
- for _, c := range r.commands {
- for _, output := range c.outputs {
- outputs[output] = true
- }
- }
- return outputs
-}
-
-func (r *Rule) Outputs() []string {
- outputs := r.outputSet()
-
- var outputList []string
- for output := range outputs {
- outputList = append(outputList, output)
- }
- sort.Strings(outputList)
- return outputList
-}
-
-func (r *Rule) Installs() []Install {
- return append([]Install(nil), r.installs...)
-}
-
-func (r *Rule) Tools() []string {
- var tools []string
- for _, c := range r.commands {
- tools = append(tools, c.tools...)
- }
- return tools
-}
-
-func (r *Rule) Commands() []string {
- var commands []string
- for _, c := range r.commands {
- commands = append(commands, string(c.buf))
- }
- return commands
-}
-
-type Command struct {
- buf []byte
- inputs []string
- outputs []string
- tools []string
-}
-
-func (c *Command) Text(text string) *Command {
- if len(c.buf) > 0 {
- c.buf = append(c.buf, ' ')
- }
- c.buf = append(c.buf, text...)
- return c
-}
-
-func (c *Command) Textf(format string, a ...interface{}) *Command {
- return c.Text(fmt.Sprintf(format, a...))
-}
-
-func (c *Command) Flag(flag string) *Command {
- return c.Text(flag)
-}
-
-func (c *Command) FlagWithArg(flag, arg string) *Command {
- return c.Text(flag + arg)
-}
-
-func (c *Command) FlagWithList(flag string, list []string, sep string) *Command {
- return c.Text(flag + strings.Join(list, sep))
-}
-
-func (c *Command) Tool(path string) *Command {
- c.tools = append(c.tools, path)
- return c.Text(path)
-}
-
-func (c *Command) Input(path string) *Command {
- c.inputs = append(c.inputs, path)
- return c.Text(path)
-}
-
-func (c *Command) Implicit(path string) *Command {
- c.inputs = append(c.inputs, path)
- return c
-}
-
-func (c *Command) Implicits(paths []string) *Command {
- c.inputs = append(c.inputs, paths...)
- return c
-}
-
-func (c *Command) Output(path string) *Command {
- c.outputs = append(c.outputs, path)
- return c.Text(path)
-}
-
-func (c *Command) ImplicitOutput(path string) *Command {
- c.outputs = append(c.outputs, path)
- return c
-}
-
-func (c *Command) FlagWithInput(flag, path string) *Command {
- c.inputs = append(c.inputs, path)
- return c.Text(flag + path)
-}
-
-func (c *Command) FlagWithInputList(flag string, paths []string, sep string) *Command {
- c.inputs = append(c.inputs, paths...)
- return c.FlagWithList(flag, paths, sep)
-}
-
-func (c *Command) FlagWithOutput(flag, path string) *Command {
- c.outputs = append(c.outputs, path)
- return c.Text(flag + path)
-}
diff --git a/java/aar.go b/java/aar.go
index d08e487..fcdd518 100644
--- a/java/aar.go
+++ b/java/aar.go
@@ -26,6 +26,7 @@
Dependency
ExportPackage() android.Path
ExportedProguardFlagFiles() android.Paths
+ ExportedRRODirs() android.Paths
ExportedStaticPackages() android.Paths
ExportedManifest() android.Path
}
@@ -52,11 +53,13 @@
Aapt_include_all_resources *bool
// list of directories relative to the Blueprints file containing assets.
- // Defaults to "assets"
+ // Defaults to ["assets"] if a directory called assets exists. Set to []
+ // to disable the default.
Asset_dirs []string
// list of directories relative to the Blueprints file containing
- // Android resources
+ // Android resources. Defaults to ["res"] if a directory called res exists.
+ // Set to [] to disable the default.
Resource_dirs []string
// path to AndroidManifest.xml. If unset, defaults to "AndroidManifest.xml".
@@ -80,6 +83,14 @@
return a.exportPackage
}
+func (a *aapt) ExportedRRODirs() android.Paths {
+ return a.rroDirs
+}
+
+func (a *aapt) ExportedManifest() android.Path {
+ return a.manifestPath
+}
+
func (a *aapt) aapt2Flags(ctx android.ModuleContext, sdkContext sdkContext, manifestPath android.Path) (flags []string,
deps android.Paths, resDirs, overlayDirs []globbedResourceDir, rroDirs android.Paths) {
@@ -164,7 +175,7 @@
}
func (a *aapt) buildActions(ctx android.ModuleContext, sdkContext sdkContext, extraLinkFlags ...string) {
- transitiveStaticLibs, staticLibManifests, libDeps, libFlags := aaptLibs(ctx, sdkContext)
+ transitiveStaticLibs, staticLibManifests, staticRRODirs, libDeps, libFlags := aaptLibs(ctx, sdkContext)
// App manifest file
manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
@@ -174,6 +185,10 @@
linkFlags, linkDeps, resDirs, overlayDirs, rroDirs := a.aapt2Flags(ctx, sdkContext, manifestPath)
+ rroDirs = append(rroDirs, staticRRODirs...)
+ // TODO(b/124035856): stop de-duping when there are no more dupe resource dirs.
+ rroDirs = android.FirstUniquePaths(rroDirs)
+
linkFlags = append(linkFlags, libFlags...)
linkDeps = append(linkDeps, libDeps...)
linkFlags = append(linkFlags, extraLinkFlags...)
@@ -235,7 +250,7 @@
// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
func aaptLibs(ctx android.ModuleContext, sdkContext sdkContext) (transitiveStaticLibs, staticLibManifests,
- deps android.Paths, flags []string) {
+ staticRRODirs, deps android.Paths, flags []string) {
var sharedLibs android.Paths
@@ -263,6 +278,7 @@
transitiveStaticLibs = append(transitiveStaticLibs, exportPackage)
transitiveStaticLibs = append(transitiveStaticLibs, aarDep.ExportedStaticPackages()...)
staticLibManifests = append(staticLibManifests, aarDep.ExportedManifest())
+ staticRRODirs = append(staticRRODirs, aarDep.ExportedRRODirs()...)
}
}
})
@@ -279,8 +295,9 @@
}
transitiveStaticLibs = android.FirstUniquePaths(transitiveStaticLibs)
+ staticRRODirs = android.FirstUniquePaths(staticRRODirs)
- return transitiveStaticLibs, staticLibManifests, deps, flags
+ return transitiveStaticLibs, staticLibManifests, staticRRODirs, deps, flags
}
type AndroidLibrary struct {
@@ -303,10 +320,6 @@
return a.exportedStaticPackages
}
-func (a *AndroidLibrary) ExportedManifest() android.Path {
- return a.manifestPath
-}
-
var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)
func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
@@ -426,6 +439,10 @@
return android.Paths{a.proguardFlags}
}
+func (a *AARImport) ExportedRRODirs() android.Paths {
+ return nil
+}
+
func (a *AARImport) ExportedStaticPackages() android.Paths {
return a.exportedStaticPackages
}
@@ -518,9 +535,10 @@
linkFlags = append(linkFlags, "--manifest "+a.manifest.String())
linkDeps = append(linkDeps, a.manifest)
- transitiveStaticLibs, staticLibManifests, libDeps, libFlags := aaptLibs(ctx, sdkContext(a))
+ transitiveStaticLibs, staticLibManifests, staticRRODirs, libDeps, libFlags := aaptLibs(ctx, sdkContext(a))
_ = staticLibManifests
+ _ = staticRRODirs
linkDeps = append(linkDeps, libDeps...)
linkFlags = append(linkFlags, libFlags...)
@@ -549,6 +567,10 @@
return android.Paths{a.classpathFile}
}
+func (a *AARImport) DexJar() android.Path {
+ return nil
+}
+
func (a *AARImport) AidlIncludeDirs() android.Paths {
return nil
}
diff --git a/java/android_resources.go b/java/android_resources.go
index efd3e3d..44cb709 100644
--- a/java/android_resources.go
+++ b/java/android_resources.go
@@ -46,7 +46,7 @@
paths android.DirectorySortedPaths
}
-const overlayDataKey = "overlayDataKey"
+var overlayDataKey = android.NewOnceKey("overlayDataKey")
type globbedResourceDir struct {
dir android.Path
diff --git a/java/app.go b/java/app.go
index e9c12e0..08714f2 100644
--- a/java/app.go
+++ b/java/app.go
@@ -95,10 +95,6 @@
return nil
}
-func (a *AndroidApp) ExportedManifest() android.Path {
- return a.manifestPath
-}
-
var _ AndroidLibraryDependency = (*AndroidApp)(nil)
type Certificate struct {
diff --git a/java/app_test.go b/java/app_test.go
index 2455145..103f24b 100644
--- a/java/app_test.go
+++ b/java/app_test.go
@@ -106,68 +106,144 @@
}
}
-var testEnforceRROTests = []struct {
- name string
- enforceRROTargets []string
- enforceRROExcludedOverlays []string
- overlayFiles map[string][]string
- rroDirs map[string][]string
-}{
- {
- name: "no RRO",
- enforceRROTargets: nil,
- enforceRROExcludedOverlays: nil,
- overlayFiles: map[string][]string{
- "foo": []string{
- "device/vendor/blah/static_overlay/foo/res/values/strings.xml",
- "device/vendor/blah/overlay/foo/res/values/strings.xml",
- },
- "bar": []string{
- "device/vendor/blah/static_overlay/bar/res/values/strings.xml",
- "device/vendor/blah/overlay/bar/res/values/strings.xml",
- },
+func TestResourceDirs(t *testing.T) {
+ testCases := []struct {
+ name string
+ prop string
+ resources []string
+ }{
+ {
+ name: "no resource_dirs",
+ prop: "",
+ resources: []string{"res/res/values/strings.xml"},
},
- rroDirs: map[string][]string{
- "foo": nil,
- "bar": nil,
+ {
+ name: "resource_dirs",
+ prop: `resource_dirs: ["res"]`,
+ resources: []string{"res/res/values/strings.xml"},
},
- },
- {
- name: "enforce RRO on foo",
- enforceRROTargets: []string{"foo"},
- enforceRROExcludedOverlays: []string{"device/vendor/blah/static_overlay"},
- overlayFiles: map[string][]string{
- "foo": []string{"device/vendor/blah/static_overlay/foo/res/values/strings.xml"},
- "bar": []string{
- "device/vendor/blah/static_overlay/bar/res/values/strings.xml",
- "device/vendor/blah/overlay/bar/res/values/strings.xml",
- },
+ {
+ name: "empty resource_dirs",
+ prop: `resource_dirs: []`,
+ resources: nil,
},
- rroDirs: map[string][]string{
- "foo": []string{"device/vendor/blah/overlay/foo/res"},
- "bar": nil,
- },
- },
- {
- name: "enforce RRO on all",
- enforceRROTargets: []string{"*"},
- enforceRROExcludedOverlays: []string{
- // Excluding specific apps/res directories also allowed.
- "device/vendor/blah/static_overlay/foo",
- "device/vendor/blah/static_overlay/bar/res",
- },
- overlayFiles: map[string][]string{
- "foo": []string{"device/vendor/blah/static_overlay/foo/res/values/strings.xml"},
- "bar": []string{"device/vendor/blah/static_overlay/bar/res/values/strings.xml"},
- },
- rroDirs: map[string][]string{
- "foo": []string{"device/vendor/blah/overlay/foo/res"},
- "bar": []string{"device/vendor/blah/overlay/bar/res"},
- },
- },
+ }
+
+ fs := map[string][]byte{
+ "res/res/values/strings.xml": nil,
+ }
+
+ bp := `
+ android_app {
+ name: "foo",
+ %s
+ }
+ `
+
+ for _, testCase := range testCases {
+ t.Run(testCase.name, func(t *testing.T) {
+ config := testConfig(nil)
+ ctx := testContext(config, fmt.Sprintf(bp, testCase.prop), fs)
+ run(t, ctx, config)
+
+ module := ctx.ModuleForTests("foo", "android_common")
+ resourceList := module.MaybeOutput("aapt2/res.list")
+
+ var resources []string
+ if resourceList.Rule != nil {
+ for _, compiledResource := range resourceList.Inputs.Strings() {
+ resources = append(resources, module.Output(compiledResource).Inputs.Strings()...)
+ }
+ }
+
+ if !reflect.DeepEqual(resources, testCase.resources) {
+ t.Errorf("expected resource files %q, got %q",
+ testCase.resources, resources)
+ }
+ })
+ }
}
func TestEnforceRRO(t *testing.T) {
+ testCases := []struct {
+ name string
+ enforceRROTargets []string
+ enforceRROExcludedOverlays []string
+ overlayFiles map[string][]string
+ rroDirs map[string][]string
+ }{
+ {
+ name: "no RRO",
+ enforceRROTargets: nil,
+ enforceRROExcludedOverlays: nil,
+ overlayFiles: map[string][]string{
+ "foo": []string{
+ buildDir + "/.intermediates/lib/android_common/package-res.apk",
+ "foo/res/res/values/strings.xml",
+ "device/vendor/blah/static_overlay/foo/res/values/strings.xml",
+ "device/vendor/blah/overlay/foo/res/values/strings.xml",
+ },
+ "bar": []string{
+ "device/vendor/blah/static_overlay/bar/res/values/strings.xml",
+ "device/vendor/blah/overlay/bar/res/values/strings.xml",
+ },
+ },
+ rroDirs: map[string][]string{
+ "foo": nil,
+ "bar": nil,
+ },
+ },
+ {
+ name: "enforce RRO on foo",
+ enforceRROTargets: []string{"foo"},
+ enforceRROExcludedOverlays: []string{"device/vendor/blah/static_overlay"},
+ overlayFiles: map[string][]string{
+ "foo": []string{
+ buildDir + "/.intermediates/lib/android_common/package-res.apk",
+ "foo/res/res/values/strings.xml",
+ "device/vendor/blah/static_overlay/foo/res/values/strings.xml",
+ },
+ "bar": []string{
+ "device/vendor/blah/static_overlay/bar/res/values/strings.xml",
+ "device/vendor/blah/overlay/bar/res/values/strings.xml",
+ },
+ },
+
+ rroDirs: map[string][]string{
+ "foo": []string{
+ "device/vendor/blah/overlay/foo/res",
+ // Enforce RRO on "foo" could imply RRO on static dependencies, but for now it doesn't.
+ // "device/vendor/blah/overlay/lib/res",
+ },
+ "bar": nil,
+ },
+ },
+ {
+ name: "enforce RRO on all",
+ enforceRROTargets: []string{"*"},
+ enforceRROExcludedOverlays: []string{
+ // Excluding specific apps/res directories also allowed.
+ "device/vendor/blah/static_overlay/foo",
+ "device/vendor/blah/static_overlay/bar/res",
+ },
+ overlayFiles: map[string][]string{
+ "foo": []string{
+ buildDir + "/.intermediates/lib/android_common/package-res.apk",
+ "foo/res/res/values/strings.xml",
+ "device/vendor/blah/static_overlay/foo/res/values/strings.xml",
+ },
+ "bar": []string{"device/vendor/blah/static_overlay/bar/res/values/strings.xml"},
+ },
+ rroDirs: map[string][]string{
+ "foo": []string{
+ "device/vendor/blah/overlay/foo/res",
+ "device/vendor/blah/overlay/lib/res",
+ },
+ "bar": []string{"device/vendor/blah/overlay/bar/res"},
+ },
+ },
+ }
+
resourceOverlays := []string{
"device/vendor/blah/overlay",
"device/vendor/blah/overlay2",
@@ -177,8 +253,10 @@
fs := map[string][]byte{
"foo/res/res/values/strings.xml": nil,
"bar/res/res/values/strings.xml": nil,
+ "lib/res/res/values/strings.xml": nil,
"device/vendor/blah/overlay/foo/res/values/strings.xml": nil,
"device/vendor/blah/overlay/bar/res/values/strings.xml": nil,
+ "device/vendor/blah/overlay/lib/res/values/strings.xml": nil,
"device/vendor/blah/static_overlay/foo/res/values/strings.xml": nil,
"device/vendor/blah/static_overlay/bar/res/values/strings.xml": nil,
"device/vendor/blah/overlay2/res/values/strings.xml": nil,
@@ -188,15 +266,21 @@
android_app {
name: "foo",
resource_dirs: ["foo/res"],
+ static_libs: ["lib"],
}
android_app {
name: "bar",
resource_dirs: ["bar/res"],
}
+
+ android_library {
+ name: "lib",
+ resource_dirs: ["lib/res"],
+ }
`
- for _, testCase := range testEnforceRROTests {
+ for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
config := testConfig(nil)
config.TestProductVariables.ResourceOverlays = resourceOverlays
@@ -216,7 +300,15 @@
var overlayFiles []string
if overlayFile.Rule != nil {
for _, o := range overlayFile.Inputs.Strings() {
- overlayFiles = append(overlayFiles, module.Output(o).Inputs.Strings()...)
+ overlayOutput := module.MaybeOutput(o)
+ if overlayOutput.Rule != nil {
+ // If the overlay is compiled as part of this module (i.e. a .arsc.flat file),
+ // verify the inputs to the .arsc.flat rule.
+ overlayFiles = append(overlayFiles, overlayOutput.Inputs.Strings()...)
+ } else {
+ // Otherwise, verify the full path to the output of the other module
+ overlayFiles = append(overlayFiles, o)
+ }
}
}
diff --git a/java/config/config.go b/java/config/config.go
index 5c838a5..75be9e2 100644
--- a/java/config/config.go
+++ b/java/config/config.go
@@ -33,6 +33,12 @@
DefaultLambdaStubsLibrary = "core-lambda-stubs"
SdkLambdaStubsPath = "prebuilts/sdk/tools/core-lambda-stubs.jar"
+ // A list of the jars that provide information about usages of the hidden API.
+ HiddenAPIExtraAppUsageJars = []string{
+ // The core-oj-hiddenapi provides information for the core-oj jar.
+ "core-oj-hiddenapi",
+ }
+
DefaultJacocoExcludeFilter = []string{"org.junit.*", "org.jacoco.*", "org.mockito.*"}
InstrumentFrameworkModules = []string{
@@ -107,6 +113,7 @@
pctx.HostBinToolVariable("ApiCheckCmd", "apicheck")
pctx.HostBinToolVariable("D8Cmd", "d8")
pctx.HostBinToolVariable("R8Cmd", "r8-compat-proguard")
+ pctx.HostBinToolVariable("HiddenAPICmd", "hiddenapi")
pctx.VariableFunc("TurbineJar", func(ctx android.PackageVarContext) string {
turbine := "turbine.jar"
diff --git a/java/dexpreopt.go b/java/dexpreopt.go
index 6e46bc9..55662cf 100644
--- a/java/dexpreopt.go
+++ b/java/dexpreopt.go
@@ -15,12 +15,6 @@
package java
import (
- "path/filepath"
- "strings"
-
- "github.com/google/blueprint"
- "github.com/google/blueprint/proptools"
-
"android/soong/android"
"android/soong/dexpreopt"
)
@@ -87,12 +81,14 @@
return false
}
+var dexpreoptGlobalConfigKey = android.NewOnceKey("DexpreoptGlobalConfig")
+
func (d *dexpreopter) dexpreopt(ctx android.ModuleContext, dexJarFile android.ModuleOutPath) android.ModuleOutPath {
if d.dexpreoptDisabled(ctx) {
return dexJarFile
}
- globalConfig := ctx.Config().Once("DexpreoptGlobalConfig", func() interface{} {
+ globalConfig := ctx.Config().Once(dexpreoptGlobalConfigKey, func() interface{} {
if f := ctx.Config().DexpreoptGlobalConfig(); f != "" {
ctx.AddNinjaFileDeps(f)
globalConfig, err := dexpreopt.LoadGlobalConfig(f)
@@ -153,7 +149,6 @@
DexLocation: dexLocation,
BuildPath: android.PathForModuleOut(ctx, "dexpreopt", ctx.ModuleName()+".jar").String(),
DexPath: dexJarFile.String(),
- UseEmbeddedDex: false,
UncompressedDex: d.uncompressedDex,
HasApkLibraries: false,
PreoptFlags: nil,
@@ -185,69 +180,19 @@
return dexJarFile
}
- var inputs android.Paths
- for _, input := range dexpreoptRule.Inputs() {
- if input == "" {
- // Tests sometimes have empty configuration values that lead to empty inputs
- continue
- }
- rel, isRel := android.MaybeRel(ctx, android.PathForModuleOut(ctx).String(), input)
- if isRel {
- inputs = append(inputs, android.PathForModuleOut(ctx, rel))
- } else {
- // TODO: use PathForOutput once boot image is moved to where PathForOutput can find it.
- inputs = append(inputs, &bootImagePath{input})
- }
- }
-
- var outputs android.WritablePaths
- for _, output := range dexpreoptRule.Outputs() {
- rel := android.Rel(ctx, android.PathForModuleOut(ctx).String(), output)
- outputs = append(outputs, android.PathForModuleOut(ctx, rel))
- }
+ dexpreoptRule.Build(pctx, ctx, "dexpreopt", "dexpreopt")
for _, install := range dexpreoptRule.Installs() {
d.builtInstalled = append(d.builtInstalled, install.From+":"+install.To)
}
- if len(dexpreoptRule.Commands()) > 0 {
- ctx.Build(pctx, android.BuildParams{
- Rule: ctx.Rule(pctx, "dexpreopt", blueprint.RuleParams{
- Command: strings.Join(proptools.NinjaEscape(dexpreoptRule.Commands()), " && "),
- CommandDeps: dexpreoptRule.Tools(),
- }),
- Implicits: inputs,
- Outputs: outputs,
- Description: "dexpreopt",
- })
- }
-
stripRule, err := dexpreopt.GenerateStripRule(globalConfig, dexpreoptConfig)
if err != nil {
ctx.ModuleErrorf("error generating dexpreopt strip rule: %s", err.Error())
return dexJarFile
}
- ctx.Build(pctx, android.BuildParams{
- Rule: ctx.Rule(pctx, "dexpreopt_strip", blueprint.RuleParams{
- Command: strings.Join(proptools.NinjaEscape(stripRule.Commands()), " && "),
- CommandDeps: stripRule.Tools(),
- }),
- Input: dexJarFile,
- Output: strippedDexJarFile,
- Description: "dexpreopt strip",
- })
+ stripRule.Build(pctx, ctx, "dexpreopt_strip", "dexpreopt strip")
return strippedDexJarFile
}
-
-type bootImagePath struct {
- path string
-}
-
-var _ android.Path = (*bootImagePath)(nil)
-
-func (p *bootImagePath) String() string { return p.path }
-func (p *bootImagePath) Ext() string { return filepath.Ext(p.path) }
-func (p *bootImagePath) Base() string { return filepath.Base(p.path) }
-func (p *bootImagePath) Rel() string { return p.path }
diff --git a/java/hiddenapi.go b/java/hiddenapi.go
index 67df575..f199051 100644
--- a/java/hiddenapi.go
+++ b/java/hiddenapi.go
@@ -15,13 +15,12 @@
package java
import (
- "sort"
- "strings"
- "sync"
+ "path/filepath"
"github.com/google/blueprint"
"android/soong/android"
+ "android/soong/java/config"
)
var hiddenAPIGenerateCSVRule = pctx.AndroidStaticRule("hiddenAPIGenerateCSV", blueprint.RuleParams{
@@ -29,10 +28,60 @@
CommandDeps: []string{"${config.Class2Greylist}"},
}, "outFlag", "stubAPIFlags")
-func hiddenAPIGenerateCSV(ctx android.ModuleContext, classesJar android.Path) {
- flagsCSV := android.PathForModuleOut(ctx, "hiddenapi", "flags.csv")
- metadataCSV := android.PathForModuleOut(ctx, "hiddenapi", "metadata.csv")
- stubFlagsCSV := &bootImagePath{ctx.Config().HiddenAPIStubFlags()}
+type hiddenAPI struct {
+ flagsCSVPath android.Path
+ metadataCSVPath android.Path
+ bootDexJarPath android.Path
+}
+
+func (h *hiddenAPI) flagsCSV() android.Path {
+ return h.flagsCSVPath
+}
+
+func (h *hiddenAPI) metadataCSV() android.Path {
+ return h.metadataCSVPath
+}
+
+func (h *hiddenAPI) bootDexJar() android.Path {
+ return h.bootDexJarPath
+}
+
+type hiddenAPIIntf interface {
+ flagsCSV() android.Path
+ metadataCSV() android.Path
+ bootDexJar() android.Path
+}
+
+var _ hiddenAPIIntf = (*hiddenAPI)(nil)
+
+func (h *hiddenAPI) hiddenAPI(ctx android.ModuleContext, dexJar android.ModuleOutPath, implementationJar android.Path,
+ uncompressDex bool) android.ModuleOutPath {
+
+ if !ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") {
+ isBootJar := inList(ctx.ModuleName(), ctx.Config().BootJars())
+ if isBootJar || inList(ctx.ModuleName(), config.HiddenAPIExtraAppUsageJars) {
+ // Derive the greylist from classes jar.
+ flagsCSV := android.PathForModuleOut(ctx, "hiddenapi", "flags.csv")
+ metadataCSV := android.PathForModuleOut(ctx, "hiddenapi", "metadata.csv")
+ hiddenAPIGenerateCSV(ctx, flagsCSV, metadataCSV, implementationJar)
+ h.flagsCSVPath = flagsCSV
+ h.metadataCSVPath = metadataCSV
+ }
+ if isBootJar {
+ hiddenAPIJar := android.PathForModuleOut(ctx, "hiddenapi", ctx.ModuleName()+".jar")
+ h.bootDexJarPath = dexJar
+ hiddenAPIEncodeDex(ctx, hiddenAPIJar, dexJar, uncompressDex)
+ dexJar = hiddenAPIJar
+ }
+ }
+
+ return dexJar
+}
+
+func hiddenAPIGenerateCSV(ctx android.ModuleContext, flagsCSV, metadataCSV android.WritablePath,
+ classesJar android.Path) {
+
+ stubFlagsCSV := hiddenAPISingletonPaths(ctx).stubFlags
ctx.Build(pctx, android.BuildParams{
Rule: hiddenAPIGenerateCSVRule,
@@ -58,7 +107,6 @@
},
})
- hiddenAPISaveCSVOutputs(ctx, flagsCSV, metadataCSV)
}
var hiddenAPIEncodeDexRule = pctx.AndroidStaticRule("hiddenAPIEncodeDex", blueprint.RuleParams{
@@ -77,10 +125,10 @@
},
}, "flagsCsv", "hiddenapiFlags", "tmpDir", "soongZipFlags")
-func hiddenAPIEncodeDex(ctx android.ModuleContext, output android.WritablePath, dexInput android.WritablePath,
+func hiddenAPIEncodeDex(ctx android.ModuleContext, output android.WritablePath, dexInput android.Path,
uncompressDex bool) {
- flagsCsv := &bootImagePath{ctx.Config().HiddenAPIFlags()}
+ flagsCSV := hiddenAPISingletonPaths(ctx).flags
// The encode dex rule requires unzipping and rezipping the classes.dex files, ensure that if it was uncompressed
// in the input it stays uncompressed in the output.
@@ -104,9 +152,9 @@
Description: "hiddenapi encode dex",
Input: dexInput,
Output: tmpOutput,
- Implicit: flagsCsv,
+ Implicit: flagsCSV,
Args: map[string]string{
- "flagsCsv": flagsCsv.String(),
+ "flagsCsv": flagsCSV.String(),
"tmpDir": tmpDir.String(),
"soongZipFlags": soongZipFlags,
"hiddenapiFlags": hiddenapiFlags,
@@ -116,55 +164,15 @@
if uncompressDex {
TransformZipAlign(ctx, output, tmpOutput)
}
-
- hiddenAPISaveDexInputs(ctx, dexInput)
}
-const hiddenAPIOutputsKey = "hiddenAPIOutputsKey"
-
-var hiddenAPIOutputsLock sync.Mutex
-
-func hiddenAPIGetOutputs(config android.Config) (*android.Paths, *android.Paths, *android.Paths) {
- type threePathsPtrs [3]*android.Paths
- s := config.Once(hiddenAPIOutputsKey, func() interface{} {
- return threePathsPtrs{new(android.Paths), new(android.Paths), new(android.Paths)}
- }).(threePathsPtrs)
- return s[0], s[1], s[2]
+type hiddenAPIPath struct {
+ path string
}
-func hiddenAPISaveCSVOutputs(ctx android.ModuleContext, flagsCSV, metadataCSV android.Path) {
- flagsCSVList, metadataCSVList, _ := hiddenAPIGetOutputs(ctx.Config())
+var _ android.Path = (*hiddenAPIPath)(nil)
- hiddenAPIOutputsLock.Lock()
- defer hiddenAPIOutputsLock.Unlock()
-
- *flagsCSVList = append(*flagsCSVList, flagsCSV)
- *metadataCSVList = append(*metadataCSVList, metadataCSV)
-}
-
-func hiddenAPISaveDexInputs(ctx android.ModuleContext, dexInput android.Path) {
- _, _, dexInputList := hiddenAPIGetOutputs(ctx.Config())
-
- hiddenAPIOutputsLock.Lock()
- defer hiddenAPIOutputsLock.Unlock()
-
- *dexInputList = append(*dexInputList, dexInput)
-}
-
-func init() {
- android.RegisterMakeVarsProvider(pctx, hiddenAPIMakeVars)
-}
-
-func hiddenAPIMakeVars(ctx android.MakeVarsContext) {
- flagsCSVList, metadataCSVList, dexInputList := hiddenAPIGetOutputs(ctx.Config())
-
- export := func(name string, paths *android.Paths) {
- s := paths.Strings()
- sort.Strings(s)
- ctx.Strict(name, strings.Join(s, " "))
- }
-
- export("SOONG_HIDDENAPI_FLAGS", flagsCSVList)
- export("SOONG_HIDDENAPI_GREYLIST_METADATA", metadataCSVList)
- export("SOONG_HIDDENAPI_DEX_INPUTS", dexInputList)
-}
+func (p *hiddenAPIPath) String() string { return p.path }
+func (p *hiddenAPIPath) Ext() string { return filepath.Ext(p.path) }
+func (p *hiddenAPIPath) Base() string { return filepath.Base(p.path) }
+func (p *hiddenAPIPath) Rel() string { return p.path }
diff --git a/java/hiddenapi_singleton.go b/java/hiddenapi_singleton.go
new file mode 100644
index 0000000..de1bcf5
--- /dev/null
+++ b/java/hiddenapi_singleton.go
@@ -0,0 +1,290 @@
+// Copyright 2019 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 (
+ "android/soong/android"
+)
+
+func init() {
+ android.RegisterSingletonType("hiddenapi", hiddenAPISingletonFactory)
+}
+
+type hiddenAPISingletonPathsStruct struct {
+ stubFlags android.OutputPath
+ flags android.OutputPath
+ metadata android.OutputPath
+}
+
+var hiddenAPISingletonPathsKey = android.NewOnceKey("hiddenAPISingletonPathsKey")
+
+// hiddenAPISingletonPaths creates all the paths for singleton files the first time it is called, which may be
+// from a ModuleContext that needs to reference a file that will be created by a singleton rule that hasn't
+// yet been created.
+func hiddenAPISingletonPaths(ctx android.PathContext) hiddenAPISingletonPathsStruct {
+ return ctx.Config().Once(hiddenAPISingletonPathsKey, func() interface{} {
+ return hiddenAPISingletonPathsStruct{
+ stubFlags: android.PathForOutput(ctx, "hiddenapi", "hiddenapi-stub-flags.txt"),
+ flags: android.PathForOutput(ctx, "hiddenapi", "hiddenapi-flags.csv"),
+ metadata: android.PathForOutput(ctx, "hiddenapi", "hiddenapi-greylist.csv"),
+ }
+ }).(hiddenAPISingletonPathsStruct)
+}
+
+func hiddenAPISingletonFactory() android.Singleton {
+ return hiddenAPISingleton{}
+}
+
+type hiddenAPISingleton struct{}
+
+// hiddenAPI singleton rules
+func (hiddenAPISingleton) GenerateBuildActions(ctx android.SingletonContext) {
+ // Don't run any hiddenapi rules if UNSAFE_DISABLE_HIDDENAPI_FLAGS=true
+ if ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") {
+ return
+ }
+
+ stubFlagsRule(ctx)
+
+ // These rules depend on files located in frameworks/base, skip them if running in a tree that doesn't have them.
+ if ctx.Config().FrameworksBaseDirExists(ctx) {
+ flagsRule(ctx)
+ metadataRule(ctx)
+ } else {
+ emptyFlagsRule(ctx)
+ }
+}
+
+// stubFlagsRule creates the rule to build hiddenapi-stub-flags.txt out of dex jars from stub modules and boot image
+// modules.
+func stubFlagsRule(ctx android.SingletonContext) {
+ // Public API stubs
+ publicStubModules := []string{
+ "android_stubs_current",
+ "android.test.base.stubs",
+ }
+
+ // System API stubs
+ systemStubModules := []string{
+ "android_system_stubs_current",
+ }
+
+ // Test API stubs
+ testStubModules := []string{
+ "android_test_stubs_current",
+ }
+
+ // Core Platform API stubs
+ corePlatformStubModules := []string{
+ "core.platform.api.stubs",
+ }
+
+ // Allow products to define their own stubs for custom product jars that apps can use.
+ publicStubModules = append(publicStubModules, ctx.Config().ProductHiddenAPIStubs()...)
+ systemStubModules = append(systemStubModules, ctx.Config().ProductHiddenAPIStubsSystem()...)
+ testStubModules = append(testStubModules, ctx.Config().ProductHiddenAPIStubsTest()...)
+
+ publicStubPaths := make(android.Paths, len(publicStubModules))
+ systemStubPaths := make(android.Paths, len(systemStubModules))
+ testStubPaths := make(android.Paths, len(testStubModules))
+ corePlatformStubPaths := make(android.Paths, len(corePlatformStubModules))
+
+ moduleListToPathList := map[*[]string]android.Paths{
+ &publicStubModules: publicStubPaths,
+ &systemStubModules: systemStubPaths,
+ &testStubModules: testStubPaths,
+ &corePlatformStubModules: corePlatformStubPaths,
+ }
+
+ var bootDexJars android.Paths
+
+ ctx.VisitAllModules(func(module android.Module) {
+ // Collect dex jar paths for the modules listed above.
+ if j, ok := module.(Dependency); ok {
+ name := ctx.ModuleName(module)
+ for moduleList, pathList := range moduleListToPathList {
+ if i := android.IndexList(name, *moduleList); i != -1 {
+ pathList[i] = j.DexJar()
+ }
+ }
+ }
+
+ // Collect dex jar paths for modules that had hiddenapi encode called on them.
+ if h, ok := module.(hiddenAPIIntf); ok {
+ if jar := h.bootDexJar(); jar != nil {
+ bootDexJars = append(bootDexJars, jar)
+ }
+ }
+ })
+
+ var missingDeps []string
+ // Ensure all modules were converted to paths
+ for moduleList, pathList := range moduleListToPathList {
+ for i := range pathList {
+ if pathList[i] == nil {
+ if ctx.Config().AllowMissingDependencies() {
+ missingDeps = append(missingDeps, (*moduleList)[i])
+ pathList[i] = android.PathForOutput(ctx, "missing")
+ } else {
+ ctx.Errorf("failed to find dex jar path for module %q",
+ (*moduleList)[i])
+ }
+ }
+ }
+ }
+
+ // Singleton rule which applies hiddenapi on all boot class path dex files.
+ rule := android.NewRuleBuilder()
+
+ outputPath := hiddenAPISingletonPaths(ctx).stubFlags
+ tempPath := android.PathForOutput(ctx, outputPath.Rel()+".tmp")
+
+ rule.MissingDeps(missingDeps)
+
+ rule.Command().
+ Tool(pctx.HostBinToolPath(ctx, "hiddenapi").String()).
+ Text("list").
+ FlagForEachInput("--boot-dex=", bootDexJars.Strings()).
+ FlagWithInputList("--public-stub-classpath=", publicStubPaths.Strings(), ":").
+ FlagWithInputList("--public-stub-classpath=", systemStubPaths.Strings(), ":").
+ FlagWithInputList("--public-stub-classpath=", testStubPaths.Strings(), ":").
+ FlagWithInputList("--core-platform-stub-classpath=", corePlatformStubPaths.Strings(), ":").
+ FlagWithOutput("--out-api-flags=", tempPath.String())
+
+ commitChangeForRestat(rule, tempPath, outputPath)
+
+ rule.Build(pctx, ctx, "hiddenAPIStubFlagsFile", "hiddenapi stub flags")
+}
+
+// flagsRule creates a rule to build hiddenapi-flags.csv out of flags.csv files generated for boot image modules and
+// the greylists.
+func flagsRule(ctx android.SingletonContext) {
+ var flagsCSV android.Paths
+
+ var greylistIgnoreConflicts android.Path
+
+ ctx.VisitAllModules(func(module android.Module) {
+ if h, ok := module.(hiddenAPIIntf); ok {
+ if csv := h.flagsCSV(); csv != nil {
+ flagsCSV = append(flagsCSV, csv)
+ }
+ } else if ds, ok := module.(*Droidstubs); ok && ctx.ModuleName(module) == "hiddenapi-lists-docs" {
+ greylistIgnoreConflicts = ds.removedDexApiFile
+ }
+ })
+
+ if greylistIgnoreConflicts == nil {
+ ctx.Errorf("failed to find removed_dex_api_filename from hiddenapi-lists-docs module")
+ return
+ }
+
+ rule := android.NewRuleBuilder()
+
+ outputPath := hiddenAPISingletonPaths(ctx).flags
+ tempPath := android.PathForOutput(ctx, outputPath.Rel()+".tmp")
+
+ stubFlags := hiddenAPISingletonPaths(ctx).stubFlags
+
+ rule.Command().
+ Tool(android.PathForSource(ctx, "frameworks/base/tools/hiddenapi/generate_hiddenapi_lists.py").String()).
+ FlagWithInput("--csv ", stubFlags.String()).
+ Inputs(flagsCSV.Strings()).
+ FlagWithInput("--greylist ",
+ android.PathForSource(ctx, "frameworks/base/config/hiddenapi-greylist.txt").String()).
+ FlagWithInput("--greylist-ignore-conflicts ",
+ greylistIgnoreConflicts.String()).
+ FlagWithInput("--greylist-max-p ",
+ android.PathForSource(ctx, "frameworks/base/config/hiddenapi-greylist-max-p.txt").String()).
+ FlagWithInput("--greylist-max-o-ignore-conflicts ",
+ android.PathForSource(ctx, "frameworks/base/config/hiddenapi-greylist-max-o.txt").String()).
+ FlagWithInput("--blacklist ",
+ android.PathForSource(ctx, "frameworks/base/config/hiddenapi-force-blacklist.txt").String()).
+ FlagWithOutput("--output ", tempPath.String())
+
+ commitChangeForRestat(rule, tempPath, outputPath)
+
+ rule.Build(pctx, ctx, "hiddenAPIFlagsFile", "hiddenapi flags")
+}
+
+// emptyFlagsRule creates a rule to build an empty hiddenapi-flags.csv, which is needed by master-art-host builds that
+// have a partial manifest without frameworks/base but still need to build a boot image.
+func emptyFlagsRule(ctx android.SingletonContext) {
+ rule := android.NewRuleBuilder()
+
+ outputPath := hiddenAPISingletonPaths(ctx).flags
+
+ rule.Command().Text("rm").Flag("-f").Output(outputPath.String())
+ rule.Command().Text("touch").Output(outputPath.String())
+
+ rule.Build(pctx, ctx, "emptyHiddenAPIFlagsFile", "empty hiddenapi flags")
+}
+
+// metadataRule creates a rule to build hiddenapi-greylist.csv out of the metadata.csv files generated for boot image
+// modules.
+func metadataRule(ctx android.SingletonContext) {
+ var metadataCSV android.Paths
+
+ ctx.VisitAllModules(func(module android.Module) {
+ if h, ok := module.(hiddenAPIIntf); ok {
+ if csv := h.metadataCSV(); csv != nil {
+ metadataCSV = append(metadataCSV, csv)
+ }
+ }
+ })
+
+ rule := android.NewRuleBuilder()
+
+ outputPath := hiddenAPISingletonPaths(ctx).metadata
+
+ rule.Command().
+ Tool(android.PathForSource(ctx, "frameworks/base/tools/hiddenapi/merge_csv.py").String()).
+ Inputs(metadataCSV.Strings()).
+ Text(">").
+ Output(outputPath.String())
+
+ rule.Build(pctx, ctx, "hiddenAPIGreylistMetadataFile", "hiddenapi greylist metadata")
+}
+
+// commitChangeForRestat adds a command to a rule that updates outputPath from tempPath if they are different. It
+// also marks the rule as restat and marks the tempPath as a temporary file that should not be considered an output of
+// the rule.
+func commitChangeForRestat(rule *android.RuleBuilder, tempPath, outputPath android.WritablePath) {
+ rule.Restat()
+ rule.Temporary(tempPath.String())
+ rule.Command().
+ Text("(").
+ Text("if").
+ Text("cmp -s").Input(tempPath.String()).Output(outputPath.String()).Text(";").
+ Text("then").
+ Text("rm").Input(tempPath.String()).Text(";").
+ Text("else").
+ Text("mv").Input(tempPath.String()).Output(outputPath.String()).Text(";").
+ Text("fi").
+ Text(")")
+}
+
+func init() {
+ android.RegisterMakeVarsProvider(pctx, hiddenAPIMakeVars)
+}
+
+// Export paths to Make. INTERNAL_PLATFORM_HIDDENAPI_FLAGS is used by Make rules in art/ and cts/.
+// Both paths are used to call dist-for-goals.
+func hiddenAPIMakeVars(ctx android.MakeVarsContext) {
+ if !ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") {
+ singletonPaths := hiddenAPISingletonPaths(ctx)
+ ctx.Strict("INTERNAL_PLATFORM_HIDDENAPI_FLAGS", singletonPaths.flags.String())
+ ctx.Strict("INTERNAL_PLATFORM_HIDDENAPI_GREYLIST_METADATA", singletonPaths.metadata.String())
+ }
+}
diff --git a/java/java.go b/java/java.go
index 70c6c43..3d7d6ad 100644
--- a/java/java.go
+++ b/java/java.go
@@ -313,6 +313,7 @@
// expanded Jarjar_rules
expandJarjarRules android.Path
+ hiddenAPI
dexpreopter
}
@@ -331,6 +332,7 @@
ImplementationJars() android.Paths
ResourceJars() android.Paths
ImplementationAndResourcesJars() android.Paths
+ DexJar() android.Path
AidlIncludeDirs() android.Paths
ExportedSdkLibs() []string
}
@@ -531,7 +533,7 @@
aidlIncludes = append(aidlIncludes,
android.PathsForSource(ctx, j.deviceProperties.Aidl.Include_dirs)...)
- flags := []string{"-b"}
+ flags := []string{}
if aidlPreprocess.Valid() {
flags = append(flags, "-p"+aidlPreprocess.String())
@@ -1216,18 +1218,8 @@
}
// Hidden API CSV generation and dex encoding
- if !ctx.Config().IsEnvTrue("UNSAFE_DISABLE_HIDDENAPI_FLAGS") {
- isBootJar := inList(ctx.ModuleName(), ctx.Config().BootJars())
- if isBootJar || inList(ctx.ModuleName(), ctx.Config().HiddenAPIExtraAppUsageJars()) {
- // Derive the greylist from classes jar.
- hiddenAPIGenerateCSV(ctx, j.implementationJarFile)
- }
- if isBootJar {
- hiddenAPIJar := android.PathForModuleOut(ctx, "hiddenapi", jarName)
- hiddenAPIEncodeDex(ctx, hiddenAPIJar, dexOutputFile, j.deviceProperties.UncompressDex)
- dexOutputFile = hiddenAPIJar
- }
- }
+ dexOutputFile = j.hiddenAPI.hiddenAPI(ctx, dexOutputFile, j.implementationJarFile,
+ j.deviceProperties.UncompressDex)
// merge dex jar with resources if necessary
if j.resourceJar != nil {
@@ -1365,6 +1357,10 @@
return android.Paths{j.implementationJarFile}
}
+func (j *Module) DexJar() android.Path {
+ return j.dexJarFile
+}
+
func (j *Module) ResourceJars() android.Paths {
if j.resourceJar == nil {
return nil
@@ -1427,6 +1423,11 @@
android.DirectlyInAnyApex(ctx, ctx.ModuleName()) {
return true
}
+ if ctx.Config().UncompressPrivAppDex() &&
+ inList(ctx.ModuleName(), ctx.Config().ModulesLoadedByPrivilegedModules()) {
+ return true
+ }
+
return false
}
@@ -1775,6 +1776,10 @@
return android.Paths{j.combinedClasspathFile}
}
+func (j *Import) DexJar() android.Path {
+ return nil
+}
+
func (j *Import) AidlIncludeDirs() android.Paths {
return nil
}
diff --git a/java/sdk.go b/java/sdk.go
index 988610f..0959be7 100644
--- a/java/sdk.go
+++ b/java/sdk.go
@@ -28,7 +28,7 @@
android.RegisterPreSingletonType("sdk", sdkSingletonFactory)
}
-const sdkSingletonKey = "sdkSingletonKey"
+var sdkSingletonKey = android.NewOnceKey("sdkSingletonKey")
type sdkContext interface {
// sdkVersion eturns the sdk_version property of the current module, or an empty string if it is not set.
diff --git a/java/sdk_library.go b/java/sdk_library.go
index ca3131c..1b0fe75 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -627,8 +627,10 @@
}
}
+var javaSdkLibrariesKey = android.NewOnceKey("javaSdkLibraries")
+
func javaSdkLibraries(config android.Config) *[]string {
- return config.Once("javaSdkLibraries", func() interface{} {
+ return config.Once(javaSdkLibrariesKey, func() interface{} {
return &[]string{}
}).(*[]string)
}
diff --git a/java/support_libraries.go b/java/support_libraries.go
index 320afae..5a72f41 100644
--- a/java/support_libraries.go
+++ b/java/support_libraries.go
@@ -28,9 +28,8 @@
func supportLibrariesMakeVarsProvider(ctx android.MakeVarsContext) {
var supportAars, supportJars []string
- sctx := ctx.SingletonContext()
- sctx.VisitAllModules(func(module android.Module) {
- dir := sctx.ModuleDir(module)
+ ctx.VisitAllModules(func(module android.Module) {
+ dir := ctx.ModuleDir(module)
switch {
case strings.HasPrefix(dir, "prebuilts/sdk/current/extras"),
dir == "prebuilts/sdk/current/androidx",
@@ -43,7 +42,7 @@
return
}
- name := sctx.ModuleName(module)
+ name := ctx.ModuleName(module)
if strings.HasSuffix(name, "-nodeps") {
return
}
@@ -54,7 +53,7 @@
case *Library, *Import:
supportJars = append(supportJars, name)
default:
- sctx.ModuleErrorf(module, "unknown module type %t", module)
+ ctx.ModuleErrorf(module, "unknown module type %t", module)
}
})
diff --git a/scripts/build_broken_logs.go b/scripts/build_broken_logs.go
new file mode 100644
index 0000000..73832a6
--- /dev/null
+++ b/scripts/build_broken_logs.go
@@ -0,0 +1,266 @@
+// Copyright 2019 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.
+
+// This is a script that can be used to analyze the results from
+// build/soong/build_test.bash and recommend what devices need changes to their
+// BUILD_BROKEN_* flags.
+//
+// To use, download the logs.zip from one or more branches, and extract them
+// into subdirectories of the current directory. So for example, I have:
+//
+// ./aosp-master/aosp_arm/std_full.log
+// ./aosp-master/aosp_arm64/std_full.log
+// ./aosp-master/...
+// ./internal-master/aosp_arm/std_full.log
+// ./internal-master/aosp_arm64/std_full.log
+// ./internal-master/...
+//
+// Then I use `go run path/to/build_broken_logs.go *`
+package main
+
+import (
+ "fmt"
+ "io/ioutil"
+ "log"
+ "os"
+ "path/filepath"
+ "sort"
+ "strings"
+)
+
+func main() {
+ for _, branch := range os.Args[1:] {
+ fmt.Printf("\nBranch %s:\n", branch)
+ PrintResults(ParseBranch(branch))
+ }
+}
+
+type BuildBrokenBehavior int
+
+const (
+ DefaultFalse BuildBrokenBehavior = iota
+ DefaultTrue
+ DefaultDeprecated
+)
+
+var buildBrokenSettings = []struct {
+ name string
+ behavior BuildBrokenBehavior
+ warnings []string
+}{
+ {
+ name: "BUILD_BROKEN_DUP_COPY_HEADERS",
+ behavior: DefaultDeprecated,
+ warnings: []string{"Duplicate header copy:"},
+ },
+ {
+ name: "BUILD_BROKEN_DUP_RULES",
+ behavior: DefaultFalse,
+ warnings: []string{"overriding commands for target"},
+ },
+ {
+ name: "BUILD_BROKEN_ANDROIDMK_EXPORTS",
+ behavior: DefaultFalse,
+ warnings: []string{"export_keyword"},
+ },
+ {
+ name: "BUILD_BROKEN_PHONY_TARGETS",
+ behavior: DefaultFalse,
+ warnings: []string{
+ "depends on PHONY target",
+ "looks like a real file",
+ "writing to readonly directory",
+ },
+ },
+ {
+ name: "BUILD_BROKEN_ENG_DEBUG_TAGS",
+ behavior: DefaultTrue,
+ warnings: []string{
+ "Changes.md#LOCAL_MODULE_TAGS",
+ },
+ },
+}
+
+type ProductBranch struct {
+ Branch string
+ Name string
+}
+
+type ProductLog struct {
+ ProductBranch
+ Log
+ Device string
+}
+
+type Log struct {
+ BuildBroken []*bool
+ HasBroken []bool
+}
+
+func Merge(l, l2 Log) Log {
+ if len(l.BuildBroken) == 0 {
+ l.BuildBroken = make([]*bool, len(buildBrokenSettings))
+ }
+ if len(l.HasBroken) == 0 {
+ l.HasBroken = make([]bool, len(buildBrokenSettings))
+ }
+
+ if len(l.BuildBroken) != len(l2.BuildBroken) || len(l.HasBroken) != len(l2.HasBroken) {
+ panic("mis-matched logs")
+ }
+
+ for i, v := range l.BuildBroken {
+ if v == nil {
+ l.BuildBroken[i] = l2.BuildBroken[i]
+ }
+ }
+ for i := range l.HasBroken {
+ l.HasBroken[i] = l.HasBroken[i] || l2.HasBroken[i]
+ }
+
+ return l
+}
+
+func PrintResults(products []ProductLog) {
+ devices := map[string]Log{}
+ deviceNames := []string{}
+
+ for _, product := range products {
+ device := product.Device
+ if _, ok := devices[device]; !ok {
+ deviceNames = append(deviceNames, device)
+ }
+ devices[device] = Merge(devices[device], product.Log)
+ }
+
+ sort.Strings(deviceNames)
+
+ for i, setting := range buildBrokenSettings {
+ printed := false
+
+ for _, device := range deviceNames {
+ log := devices[device]
+
+ if setting.behavior == DefaultTrue {
+ if log.BuildBroken[i] == nil || *log.BuildBroken[i] == false {
+ if log.HasBroken[i] {
+ printed = true
+ fmt.Printf(" %s needs to set %s := true\n", device, setting.name)
+ }
+ } else if !log.HasBroken[i] {
+ printed = true
+ fmt.Printf(" %s sets %s := true, but does not need it\n", device, setting.name)
+ }
+ } else if setting.behavior == DefaultFalse {
+ if log.BuildBroken[i] == nil {
+ // Nothing to be done
+ } else if *log.BuildBroken[i] == false {
+ printed = true
+ fmt.Printf(" %s sets %s := false, which is the default and can be removed\n", device, setting.name)
+ } else if !log.HasBroken[i] {
+ printed = true
+ fmt.Printf(" %s sets %s := true, but does not need it\n", device, setting.name)
+ }
+ } else if setting.behavior == DefaultDeprecated {
+ if log.BuildBroken[i] != nil {
+ printed = true
+ if log.HasBroken[i] {
+ fmt.Printf(" %s sets %s := %v, which is deprecated, but has failures\n", device, setting.name, *log.BuildBroken[i])
+ } else {
+ fmt.Printf(" %s sets %s := %v, which is deprecated and can be removed\n", device, setting.name, *log.BuildBroken[i])
+ }
+ }
+ }
+ }
+
+ if printed {
+ fmt.Println()
+ }
+ }
+}
+
+func ParseBranch(name string) []ProductLog {
+ products, err := filepath.Glob(filepath.Join(name, "*"))
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ ret := []ProductLog{}
+ for _, product := range products {
+ product = filepath.Base(product)
+
+ ret = append(ret, ParseProduct(ProductBranch{Branch: name, Name: product}))
+ }
+ return ret
+}
+
+func ParseProduct(p ProductBranch) ProductLog {
+ soongLog, err := ioutil.ReadFile(filepath.Join(p.Branch, p.Name, "soong.log"))
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ ret := ProductLog{
+ ProductBranch: p,
+ Log: Log{
+ BuildBroken: make([]*bool, len(buildBrokenSettings)),
+ HasBroken: make([]bool, len(buildBrokenSettings)),
+ },
+ }
+
+ lines := strings.Split(string(soongLog), "\n")
+ for _, line := range lines {
+ fields := strings.Split(line, " ")
+ if len(fields) != 5 {
+ continue
+ }
+
+ if fields[3] == "TARGET_DEVICE" {
+ ret.Device = fields[4]
+ }
+
+ if strings.HasPrefix(fields[3], "BUILD_BROKEN_") {
+ for i, setting := range buildBrokenSettings {
+ if setting.name == fields[3] {
+ ret.BuildBroken[i] = ParseBoolPtr(fields[4])
+ }
+ }
+ }
+ }
+
+ stdLog, err := ioutil.ReadFile(filepath.Join(p.Branch, p.Name, "std_full.log"))
+ if err != nil {
+ log.Fatal(err)
+ }
+ stdStr := string(stdLog)
+
+ for i, setting := range buildBrokenSettings {
+ for _, warning := range setting.warnings {
+ if strings.Contains(stdStr, warning) {
+ ret.HasBroken[i] = true
+ }
+ }
+ }
+
+ return ret
+}
+
+func ParseBoolPtr(str string) *bool {
+ var ret *bool
+ if str != "" {
+ b := str == "true"
+ ret = &b
+ }
+ return ret
+}
diff --git a/ui/build/dumpvars.go b/ui/build/dumpvars.go
index 1ab855d..d644f5f 100644
--- a/ui/build/dumpvars.go
+++ b/ui/build/dumpvars.go
@@ -206,6 +206,7 @@
// Not used, but useful to be in the soong.log
"BUILD_BROKEN_ANDROIDMK_EXPORTS",
"BUILD_BROKEN_DUP_COPY_HEADERS",
+ "BUILD_BROKEN_ENG_DEBUG_TAGS",
}, exportEnvVars...), BannerVars...)
make_vars, err := dumpMakeVars(ctx, config, config.Arguments(), allVars, true)
@@ -213,11 +214,13 @@
ctx.Fatalln("Error dumping make vars:", err)
}
+ env := config.Environment()
// Print the banner like make does
- ctx.Writer.Print(Banner(make_vars))
+ if !env.IsEnvTrue("ANDROID_QUIET_BUILD") {
+ ctx.Writer.Print(Banner(make_vars))
+ }
// Populate the environment
- env := config.Environment()
for _, name := range exportEnvVars {
if make_vars[name] == "" {
env.Unset(name)
diff --git a/ui/terminal/status.go b/ui/terminal/status.go
index c8eb382..2445c5b 100644
--- a/ui/terminal/status.go
+++ b/ui/terminal/status.go
@@ -27,6 +27,7 @@
format string
start time.Time
+ quiet bool
}
// NewStatusOutput returns a StatusOutput that represents the
@@ -35,12 +36,13 @@
//
// statusFormat takes nearly all the same options as NINJA_STATUS.
// %c is currently unsupported.
-func NewStatusOutput(w Writer, statusFormat string) status.StatusOutput {
+func NewStatusOutput(w Writer, statusFormat string, quietBuild bool) status.StatusOutput {
return &statusOutput{
writer: w,
format: statusFormat,
start: time.Now(),
+ quiet: quietBuild,
}
}
@@ -76,13 +78,12 @@
progress := s.progress(counts) + str
if result.Error != nil {
- hasCommand := ""
- if result.Command != "" {
- hasCommand = "\n"
+ targets := strings.Join(result.Outputs, " ")
+ if s.quiet || result.Command == "" {
+ s.writer.StatusAndMessage(progress, fmt.Sprintf("FAILED: %s\n%s", targets, result.Output))
+ } else {
+ s.writer.StatusAndMessage(progress, fmt.Sprintf("FAILED: %s\n%s\n%s", targets, result.Command, result.Output))
}
-
- s.writer.StatusAndMessage(progress, fmt.Sprintf("FAILED: %s\n%s%s%s",
- strings.Join(result.Outputs, " "), result.Command, hasCommand, result.Output))
} else if result.Output != "" {
s.writer.StatusAndMessage(progress, result.Output)
} else {