Merge "Add modules for converting java modules between host and device"

Android.bp

@@ -250,6 +250,7 @@ bootstrap_go_package {
         "java/app_builder.go",
         "java/app.go",
         "java/builder.go",
+        "java/device_host_converter.go",
         "java/dex.go",
         "java/dexpreopt.go",
         "java/dexpreopt_bootjars.go",
@@ -275,6 +276,7 @@ bootstrap_go_package {
     ],
     testSrcs: [
         "java/app_test.go",
+        "java/device_host_converter_test.go",
         "java/dexpreopt_test.go",
         "java/dexpreopt_bootjars_test.go",
         "java/java_test.go",

android/module.go

@@ -88,6 +88,7 @@ type BaseContext interface {
 type BaseModuleContext interface {
 	ModuleName() string
 	ModuleDir() string
+	ModuleType() string
 	Config() Config
 
 	ContainsProperty(name string) bool

java/device_host_converter.go

@@ -0,0 +1,131 @@
+// 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"
+
+	"github.com/google/blueprint"
+)
+
+type DeviceHostConverter struct {
+	android.ModuleBase
+	android.DefaultableModuleBase
+
+	properties DeviceHostConverterProperties
+
+	headerJars                    android.Paths
+	implementationJars            android.Paths
+	implementationAndResourceJars android.Paths
+	resourceJars                  android.Paths
+}
+
+type DeviceHostConverterProperties struct {
+	// List of modules whose contents will be visible to modules that depend on this module.
+	Libs []string
+}
+
+type DeviceForHost struct {
+	DeviceHostConverter
+}
+
+// java_device_for_host makes the classes.jar output of a device java_library module available to host
+// java_library modules.
+//
+// It is rarely necessary, and its used is restricted to a few whitelisted projects.
+func DeviceForHostFactory() android.Module {
+	module := &DeviceForHost{}
+
+	module.AddProperties(&module.properties)
+
+	InitJavaModule(module, android.HostSupported)
+	return module
+}
+
+type HostForDevice struct {
+	DeviceHostConverter
+}
+
+// java_host_for_device makes the classes.jar output of a host java_library module available to device
+// java_library modules.
+//
+// It is rarely necessary, and its used is restricted to a few whitelisted projects.
+func HostForDeviceFactory() android.Module {
+	module := &HostForDevice{}
+
+	module.AddProperties(&module.properties)
+
+	InitJavaModule(module, android.DeviceSupported)
+	return module
+}
+
+var deviceHostConverterDepTag = dependencyTag{name: "device_host_converter"}
+
+func (d *DeviceForHost) DepsMutator(ctx android.BottomUpMutatorContext) {
+	variation := []blueprint.Variation{{Mutator: "arch", Variation: "android_common"}}
+	ctx.AddFarVariationDependencies(variation, deviceHostConverterDepTag, d.properties.Libs...)
+}
+
+func (d *HostForDevice) DepsMutator(ctx android.BottomUpMutatorContext) {
+	variation := []blueprint.Variation{{Mutator: "arch", Variation: ctx.Config().BuildOsCommonVariant}}
+	ctx.AddFarVariationDependencies(variation, deviceHostConverterDepTag, d.properties.Libs...)
+}
+
+func (d *DeviceHostConverter) GenerateAndroidBuildActions(ctx android.ModuleContext) {
+	if len(d.properties.Libs) < 1 {
+		ctx.PropertyErrorf("libs", "at least one dependency is required")
+	}
+
+	ctx.VisitDirectDepsWithTag(deviceHostConverterDepTag, func(m android.Module) {
+		if dep, ok := m.(Dependency); ok {
+			d.headerJars = append(d.headerJars, dep.HeaderJars()...)
+			d.implementationJars = append(d.implementationJars, dep.ImplementationJars()...)
+			d.implementationAndResourceJars = append(d.implementationAndResourceJars, dep.ImplementationAndResourcesJars()...)
+			d.resourceJars = append(d.resourceJars, dep.ResourceJars()...)
+		} else {
+			ctx.PropertyErrorf("libs", "module %q cannot be used as a dependency", ctx.OtherModuleName(m))
+		}
+	})
+}
+
+var _ Dependency = (*DeviceHostConverter)(nil)
+
+func (d *DeviceHostConverter) HeaderJars() android.Paths {
+	return d.headerJars
+}
+
+func (d *DeviceHostConverter) ImplementationJars() android.Paths {
+	return d.implementationJars
+}
+
+func (d *DeviceHostConverter) ResourceJars() android.Paths {
+	return d.resourceJars
+}
+
+func (d *DeviceHostConverter) ImplementationAndResourcesJars() android.Paths {
+	return d.implementationAndResourceJars
+}
+
+func (d *DeviceHostConverter) DexJar() android.Path {
+	return nil
+}
+
+func (d *DeviceHostConverter) AidlIncludeDirs() android.Paths {
+	return nil
+}
+
+func (d *DeviceHostConverter) ExportedSdkLibs() []string {
+	return nil
+}

java/device_host_converter_test.go

@@ -0,0 +1,186 @@
+// 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"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDeviceForHost(t *testing.T) {
+	bp := `
+		java_library {
+			name: "device_module",
+			srcs: ["a.java"],
+			java_resources: ["java-res/a/a"],
+		}
+
+		java_import {
+			name: "device_import_module",
+			jars: ["a.jar"],
+		}
+
+		java_device_for_host {
+			name: "device_for_host_module",
+			libs: [
+				"device_module",
+				"device_import_module",
+			],
+		}
+
+		java_library_host {
+			name: "host_module",
+			srcs: ["b.java"],
+			java_resources: ["java-res/b/b"],
+			static_libs: ["device_for_host_module"],
+		}
+	`
+
+	config := testConfig(nil)
+	ctx := testContext(config, bp, nil)
+	run(t, ctx, config)
+
+	deviceModule := ctx.ModuleForTests("device_module", "android_common")
+	deviceTurbineCombined := deviceModule.Output("turbine-combined/device_module.jar")
+	deviceJavac := deviceModule.Output("javac/device_module.jar")
+	deviceRes := deviceModule.Output("res/device_module.jar")
+
+	deviceImportModule := ctx.ModuleForTests("device_import_module", "android_common")
+	deviceImportCombined := deviceImportModule.Output("combined/device_import_module.jar")
+
+	hostModule := ctx.ModuleForTests("host_module", config.BuildOsCommonVariant)
+	hostJavac := hostModule.Output("javac/host_module.jar")
+	hostRes := hostModule.Output("res/host_module.jar")
+	combined := hostModule.Output("combined/host_module.jar")
+	resCombined := hostModule.Output("res-combined/host_module.jar")
+
+	// check classpath of host module with dependency on device_for_host_module
+	expectedClasspath := "-classpath " + strings.Join(android.Paths{
+		deviceTurbineCombined.Output,
+		deviceImportCombined.Output,
+	}.Strings(), ":")
+
+	if hostJavac.Args["classpath"] != expectedClasspath {
+		t.Errorf("expected host_module javac classpath:\n%s\ngot:\n%s",
+			expectedClasspath, hostJavac.Args["classpath"])
+	}
+
+	// check host module merged with static dependency implementation jars from device_for_host module
+	expectedInputs := android.Paths{
+		hostJavac.Output,
+		deviceJavac.Output,
+		deviceImportCombined.Output,
+	}
+
+	if !reflect.DeepEqual(combined.Inputs, expectedInputs) {
+		t.Errorf("expected host_module combined inputs:\n%q\ngot:\n%q",
+			expectedInputs, combined.Inputs)
+	}
+
+	// check host module merged with static dependency resource jars from device_for_host module
+	expectedInputs = android.Paths{
+		hostRes.Output,
+		deviceRes.Output,
+	}
+
+	if !reflect.DeepEqual(resCombined.Inputs, expectedInputs) {
+		t.Errorf("expected host_module res combined inputs:\n%q\ngot:\n%q",
+			expectedInputs, resCombined.Inputs)
+	}
+}
+
+func TestHostForDevice(t *testing.T) {
+	bp := `
+		java_library_host {
+			name: "host_module",
+			srcs: ["a.java"],
+			java_resources: ["java-res/a/a"],
+		}
+
+		java_import_host {
+			name: "host_import_module",
+			jars: ["a.jar"],
+		}
+
+		java_host_for_device {
+			name: "host_for_device_module",
+			libs: [
+				"host_module",
+				"host_import_module",
+			],
+		}
+
+		java_library {
+			name: "device_module",
+			no_framework_libs: true,
+			srcs: ["b.java"],
+			java_resources: ["java-res/b/b"],
+			static_libs: ["host_for_device_module"],
+		}
+	`
+
+	config := testConfig(nil)
+	ctx := testContext(config, bp, nil)
+	run(t, ctx, config)
+
+	hostModule := ctx.ModuleForTests("host_module", config.BuildOsCommonVariant)
+	hostJavac := hostModule.Output("javac/host_module.jar")
+	hostRes := hostModule.Output("res/host_module.jar")
+
+	hostImportModule := ctx.ModuleForTests("host_import_module", config.BuildOsCommonVariant)
+	hostImportCombined := hostImportModule.Output("combined/host_import_module.jar")
+
+	deviceModule := ctx.ModuleForTests("device_module", "android_common")
+	deviceJavac := deviceModule.Output("javac/device_module.jar")
+	deviceRes := deviceModule.Output("res/device_module.jar")
+	combined := deviceModule.Output("combined/device_module.jar")
+	resCombined := deviceModule.Output("res-combined/device_module.jar")
+
+	// check classpath of device module with dependency on host_for_device_module
+	expectedClasspath := "-classpath " + strings.Join(android.Paths{
+		hostJavac.Output,
+		hostImportCombined.Output,
+	}.Strings(), ":")
+
+	if deviceJavac.Args["classpath"] != expectedClasspath {
+		t.Errorf("expected device_module javac classpath:\n%s\ngot:\n%s",
+			expectedClasspath, deviceJavac.Args["classpath"])
+	}
+
+	// check device module merged with static dependency implementation jars from host_for_device module
+	expectedInputs := android.Paths{
+		deviceJavac.Output,
+		hostJavac.Output,
+		hostImportCombined.Output,
+	}
+
+	if !reflect.DeepEqual(combined.Inputs, expectedInputs) {
+		t.Errorf("expected device_module combined inputs:\n%q\ngot:\n%q",
+			expectedInputs, combined.Inputs)
+	}
+
+	// check device module merged with static dependency resource jars from host_for_device module
+	expectedInputs = android.Paths{
+		deviceRes.Output,
+		hostRes.Output,
+	}
+
+	if !reflect.DeepEqual(resCombined.Inputs, expectedInputs) {
+		t.Errorf("expected device_module res combined inputs:\n%q\ngot:\n%q",
+			expectedInputs, resCombined.Inputs)
+	}
+}

java/java.go

@@ -44,6 +44,8 @@ func init() {
 	android.RegisterModuleType("java_test_host", TestHostFactory)
 	android.RegisterModuleType("java_import", ImportFactory)
 	android.RegisterModuleType("java_import_host", ImportFactoryHost)
+	android.RegisterModuleType("java_device_for_host", DeviceForHostFactory)
+	android.RegisterModuleType("java_host_for_device", HostForDeviceFactory)
 
 	android.RegisterSingletonType("logtags", LogtagsSingleton)
 }

java/java_test.go

@@ -68,10 +68,13 @@ func testContext(config android.Config, bp string,
 	ctx.RegisterModuleType("android_test_helper_app", android.ModuleFactoryAdaptor(AndroidTestHelperAppFactory))
 	ctx.RegisterModuleType("java_binary", android.ModuleFactoryAdaptor(BinaryFactory))
 	ctx.RegisterModuleType("java_binary_host", android.ModuleFactoryAdaptor(BinaryHostFactory))
+	ctx.RegisterModuleType("java_device_for_host", android.ModuleFactoryAdaptor(DeviceForHostFactory))
+	ctx.RegisterModuleType("java_host_for_device", android.ModuleFactoryAdaptor(HostForDeviceFactory))
 	ctx.RegisterModuleType("java_library", android.ModuleFactoryAdaptor(LibraryFactory))
 	ctx.RegisterModuleType("java_library_host", android.ModuleFactoryAdaptor(LibraryHostFactory))
 	ctx.RegisterModuleType("java_test", android.ModuleFactoryAdaptor(TestFactory))
 	ctx.RegisterModuleType("java_import", android.ModuleFactoryAdaptor(ImportFactory))
+	ctx.RegisterModuleType("java_import_host", android.ModuleFactoryAdaptor(ImportFactoryHost))
 	ctx.RegisterModuleType("java_defaults", android.ModuleFactoryAdaptor(defaultsFactory))
 	ctx.RegisterModuleType("java_system_modules", android.ModuleFactoryAdaptor(SystemModulesFactory))
 	ctx.RegisterModuleType("java_genrule", android.ModuleFactoryAdaptor(genRuleFactory))