Add modules for converting java modules between host and device
java_device_for_host and java_host_for_device allow treating a
device module as a host module and vice versa. They will be useful
for converting layoutlib and robolectric to Soong, as these modules
run device java code on the host.
Bug: 117920228
Test: device_host_converter_test.go
Change-Id: Ia9a371fb41a97bc16338097f3ce8b40099744167
diff --git a/java/device_host_converter.go b/java/device_host_converter.go
new file mode 100644
index 0000000..9f40a6c
--- /dev/null
+++ b/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
+}
diff --git a/java/device_host_converter_test.go b/java/device_host_converter_test.go
new file mode 100644
index 0000000..146bf6f
--- /dev/null
+++ b/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)
+ }
+}
diff --git a/java/java.go b/java/java.go
index 52d97c9..0e1ae23 100644
--- a/java/java.go
+++ b/java/java.go
@@ -44,6 +44,8 @@
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)
}
diff --git a/java/java_test.go b/java/java_test.go
index 817955c..952da11 100644
--- a/java/java_test.go
+++ b/java/java_test.go
@@ -68,10 +68,13 @@
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))