openkylin
/
platform_build_soong
mirror of https://gitee.com/openkylin/platform_build_soong.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge "Track sources for srcjars across modules" 

am: 082640d6ee

Change-Id: Ia5505e67614e1531acd9fed44491faef4596a62c
This commit is contained in:
Colin Cross 2019-05-07 10:38:18 -07:00 committed by android-build-merger
parent 04c69f1c9d 082640d6ee
commit 222f5ee5f2
5 changed files with 111 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
java/aar.go
View File

@ -647,6 +647,10 @@ func (a *AARImport) ExportedSdkLibs() []string {
return nil
}
func (a *AARImport) SrcJarArgs() ([]string, android.Paths) {
return nil, nil
}
var _ android.PrebuiltInterface = (*Import)(nil)
// android_library_import imports an `.aar` file into the build graph as if it was built with android_library.

11
java/device_host_converter.go
View File

@ -34,6 +34,9 @@ type DeviceHostConverter struct {
implementationAndResourceJars android.Paths
resourceJars android.Paths
srcJarArgs []string
srcJarDeps android.Paths
combinedHeaderJar android.Path
combinedImplementationJar android.Path
}
@ -100,6 +103,10 @@ func (d *DeviceHostConverter) GenerateAndroidBuildActions(ctx android.ModuleCont
d.implementationJars = append(d.implementationJars, dep.ImplementationJars()...)
d.implementationAndResourceJars = append(d.implementationAndResourceJars, dep.ImplementationAndResourcesJars()...)
d.resourceJars = append(d.resourceJars, dep.ResourceJars()...)
srcJarArgs, srcJarDeps := dep.SrcJarArgs()
d.srcJarArgs = append(d.srcJarArgs, srcJarArgs...)
d.srcJarDeps = append(d.srcJarDeps, srcJarDeps...)
} else {
ctx.PropertyErrorf("libs", "module %q cannot be used as a dependency", ctx.OtherModuleName(m))
}
@ -157,6 +164,10 @@ func (d *DeviceHostConverter) ExportedSdkLibs() []string {
return nil
}
func (d *DeviceHostConverter) SrcJarArgs() ([]string, android.Paths) {
return d.srcJarArgs, d.srcJarDeps
}
func (d *DeviceHostConverter) AndroidMk() android.AndroidMkData {
return android.AndroidMkData{
Class: "JAVA_LIBRARIES",

46
java/java.go
View File

@ -290,6 +290,10 @@ type Module struct {
// jar file containing only resources including from static library dependencies
resourceJar android.Path
// args and dependencies to package source files into a srcjar
srcJarArgs []string
srcJarDeps android.Paths
// jar file containing implementation classes and resources including static library
// dependencies
implementationAndResourcesJar android.Path
@ -365,6 +369,7 @@ type Dependency interface {
DexJar() android.Path
AidlIncludeDirs() android.Paths
ExportedSdkLibs() []string
SrcJarArgs() ([]string, android.Paths)
}
type SdkLibraryDependency interface {
@ -1113,6 +1118,14 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path
}
}
j.srcJarArgs, j.srcJarDeps = resourcePathsToJarArgs(srcFiles), srcFiles
var includeSrcJar android.WritablePath
if Bool(j.properties.Include_srcs) {
includeSrcJar = android.PathForModuleOut(ctx, ctx.ModuleName()+".srcjar")
TransformResourcesToJar(ctx, includeSrcJar, j.srcJarArgs, j.srcJarDeps)
}
dirArgs, dirDeps := ResourceDirsToJarArgs(ctx, j.properties.Java_resource_dirs,
j.properties.Exclude_java_resource_dirs, j.properties.Exclude_java_resources)
fileArgs, fileDeps := ResourceFilesToJarArgs(ctx, j.properties.Java_resources, j.properties.Exclude_java_resources)
@ -1130,12 +1143,6 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path
resArgs = append(resArgs, extraArgs...)
resDeps = append(resDeps, extraDeps...)
if Bool(j.properties.Include_srcs) {
srcArgs, srcDeps := SourceFilesToJarArgs(ctx, j.properties.Srcs, j.properties.Exclude_srcs)
resArgs = append(resArgs, srcArgs...)
resDeps = append(resDeps, srcDeps...)
}
if len(resArgs) > 0 {
resourceJar := android.PathForModuleOut(ctx, "res", jarName)
TransformResourcesToJar(ctx, resourceJar, resArgs, resDeps)
@ -1145,17 +1152,22 @@ func (j *Module) compile(ctx android.ModuleContext, extraSrcJars ...android.Path
}
}
if len(deps.staticResourceJars) > 0 {
var jars android.Paths
if j.resourceJar != nil {
jars = append(jars, j.resourceJar)
}
jars = append(jars, deps.staticResourceJars...)
var resourceJars android.Paths
if j.resourceJar != nil {
resourceJars = append(resourceJars, j.resourceJar)
}
if Bool(j.properties.Include_srcs) {
resourceJars = append(resourceJars, includeSrcJar)
}
resourceJars = append(resourceJars, deps.staticResourceJars...)
if len(resourceJars) > 1 {
combinedJar := android.PathForModuleOut(ctx, "res-combined", jarName)
TransformJarsToJar(ctx, combinedJar, "for resources", jars, android.OptionalPath{},
TransformJarsToJar(ctx, combinedJar, "for resources", resourceJars, android.OptionalPath{},
false, nil, nil)
j.resourceJar = combinedJar
} else if len(resourceJars) == 1 {
j.resourceJar = resourceJars[0]
}
jars = append(jars, deps.staticJars...)
@ -1443,6 +1455,10 @@ func (j *Module) ExportedSdkLibs() []string {
return j.exportedSdkLibs
}
func (j *Module) SrcJarArgs() ([]string, android.Paths) {
return j.srcJarArgs, j.srcJarDeps
}
var _ logtagsProducer = (*Module)(nil)
func (j *Module) logtags() android.Paths {
@ -1920,6 +1936,10 @@ func (j *Import) ExportedSdkLibs() []string {
return j.exportedSdkLibs
}
func (j *Import) SrcJarArgs() ([]string, android.Paths) {
return nil, nil
}
// Add compile time check for interface implementation
var _ android.IDEInfo = (*Import)(nil)
var _ android.IDECustomizedModuleName = (*Import)(nil)

8
java/java_resources.go
View File

@ -85,14 +85,6 @@ func ResourceFilesToJarArgs(ctx android.ModuleContext,
return resourceFilesToJarArgs(ctx, res, exclude)
}
// Convert java_resources properties to arguments to soong_zip -jar, keeping files that should
// normally not used as resources like *.java
func SourceFilesToJarArgs(ctx android.ModuleContext,
res, exclude []string) (args []string, deps android.Paths) {
return resourceFilesToJarArgs(ctx, res, exclude)
}
func resourceFilesToJarArgs(ctx android.ModuleContext,
res, exclude []string) (args []string, deps android.Paths) {

69
java/java_test.go
View File

@ -481,12 +481,6 @@ func TestResources(t *testing.T) {
}`,
args: "-C java-res -f java-res/a/a -f java-res/b/b",
},
{
// Test that a module with "include_srcs: true" includes its source files in the resources jar
name: "include sources",
prop: `include_srcs: true`,
args: "-C . -f a.java -f b.java -f c.java",
},
{
// Test that a module with wildcards in java_resource_dirs has the correct path prefixes
name: "wildcard dirs",
@ -555,6 +549,69 @@ func TestResources(t *testing.T) {
}
}
func TestIncludeSrcs(t *testing.T) {
ctx := testJava(t, `
java_library {
name: "foo",
srcs: [
"a.java",
"b.java",
"c.java",
],
include_srcs: true,
}
java_library {
name: "bar",
srcs: [
"a.java",
"b.java",
"c.java",
],
java_resource_dirs: ["java-res"],
include_srcs: true,
}
`)
// Test a library with include_srcs: true
foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar")
if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) {
t.Errorf("foo combined jars %v does not contain %q", w, g)
}
if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
t.Errorf("foo source jar args %q is not %q", w, g)
}
// Test a library with include_srcs: true and resources
bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar")
barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar")
barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar")
if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
t.Errorf("bar combined resource jars %v does not contain %q", w, g)
}
if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
t.Errorf("bar combined resource jars %v does not contain %q", w, g)
}
if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) {
t.Errorf("bar combined jars %v does not contain %q", w, g)
}
if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
t.Errorf("bar source jar args %q is not %q", w, g)
}
if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w {
t.Errorf("bar resource jar args %q is not %q", w, g)
}
}
func TestGeneratedSources(t *testing.T) {
ctx := testJava(t, `
java_library {