build/hidl_interface.go

// Copyright (C) 2017 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package hidl

import (
	"strings"
	"sync"

	"github.com/google/blueprint/proptools"

	"android/soong/android"
	"android/soong/cc"
	"android/soong/genrule"
	"android/soong/java"
)

var (
	hidlInterfaceSuffix = "_interface"
)

func init() {
	android.RegisterModuleType("hidl_interface", hidlInterfaceFactory)
}

type hidlInterfaceProperties struct {
	// Vndk properties for interface library only.
	cc.VndkProperties

	// The owner of the module
	Owner *string

	// List of .hal files which compose this interface.
	Srcs []string

	// List of hal interface packages that this library depends on.
	Interfaces []string

	// Package root for this package, must be a prefix of name
	Root string

	// List of non-TypeDef types declared in types.hal.
	Types []string

	// Whether to generate the Java library stubs.
	// Default: true
	Gen_java *bool

	// Whether to generate a Java library containing constants
	// expressed by @export annotations in the hal files.
	Gen_java_constants bool
}

type hidlInterface struct {
	android.ModuleBase

	properties hidlInterfaceProperties
}

func processSources(mctx android.LoadHookContext, srcs []string) ([]string, []string, bool) {
	var interfaces []string
	var types []string // hidl-gen only supports types.hal, but don't assume that here

	hasError := false

	for _, v := range srcs {
		if !strings.HasSuffix(v, ".hal") {
			mctx.PropertyErrorf("srcs", "Source must be a .hal file: "+v)
			hasError = true
			continue
		}

		name := strings.TrimSuffix(v, ".hal")

		if strings.HasPrefix(name, "I") {
			baseName := strings.TrimPrefix(name, "I")
			interfaces = append(interfaces, baseName)
		} else {
			types = append(types, name)
		}
	}

	return interfaces, types, !hasError
}

func processDependencies(mctx android.LoadHookContext, interfaces []string) ([]string, []string, bool) {
	var dependencies []string
	var javaDependencies []string

	hasError := false

	for _, v := range interfaces {
		name, err := parseFqName(v)
		if err != nil {
			mctx.PropertyErrorf("interfaces", err.Error())
			hasError = true
			continue
		}
		dependencies = append(dependencies, name.string())
		javaDependencies = append(javaDependencies, name.javaName())
	}

	return dependencies, javaDependencies, !hasError
}

func getRootList(mctx android.LoadHookContext, interfaces []string) ([]string, bool) {
	var roots []string
	hasError := false

	for _, i := range interfaces {
		interfaceObject := lookupInterface(i)
		if interfaceObject == nil {
			mctx.PropertyErrorf("interfaces", "Cannot find interface "+i)
			hasError = true
			continue
		}
		root := interfaceObject.properties.Root
		rootObject := lookupPackageRoot(root)
		if rootObject == nil {
			mctx.PropertyErrorf("interfaces", `Cannot find package root specification for package `+
				`root '%s' needed for module '%s'. Either this is a mispelling of the package `+
				`root, or a new hidl_package_root module needs to be added. For example, you can `+
				`fix this error by adding the following to <some path>/Android.bp:

hidl_package_root {
    name: "%s",
    path: "<some path>",
}

This corresponds to the "-r%s:<some path>" option that would be passed into hidl-gen.`, root, i, root, root)
			hasError = true
			continue
		}

		roots = append(roots, root+":"+rootObject.properties.Path)
	}

	return android.FirstUniqueStrings(roots), !hasError
}

func removeCoreDependencies(mctx android.LoadHookContext, dependencies []string) ([]string, bool) {
	var ret []string
	hasError := false

	for _, i := range dependencies {
		if !isCorePackage(i) {
			ret = append(ret, i)
		}
	}

	return ret, !hasError
}

func hidlGenCommand(lang string, roots []string, name *fqName) *string {
	cmd := "$(location hidl-gen) -p . -d $(depfile) -o $(genDir)"
	cmd += " -L" + lang
	cmd += " " + strings.Join(wrap("-r", roots, ""), " ")
	cmd += " " + name.string()
	return &cmd
}

func hidlInterfaceMutator(mctx android.LoadHookContext, i *hidlInterface) {
	name, err := parseFqName(i.ModuleBase.Name())
	if err != nil {
		mctx.PropertyErrorf("name", err.Error())
	}

	if !name.inPackage(i.properties.Root) {
		mctx.PropertyErrorf("root", "Root, "+i.properties.Root+", for "+name.string()+" must be a prefix.")
	}

	interfaces, types, _ := processSources(mctx, i.properties.Srcs)

	if len(interfaces) == 0 && len(types) == 0 {
		mctx.PropertyErrorf("srcs", "No sources provided.")
	}

	dependencies, javaDependencies, _ := processDependencies(mctx, i.properties.Interfaces)
	roots, _ := getRootList(mctx, append(dependencies, name.string()))
	cppDependencies, _ := removeCoreDependencies(mctx, dependencies)

	if mctx.Failed() {
		return
	}

	shouldGenerateLibrary := !isCorePackage(name.string())
	// explicitly true if not specified to give early warning to devs
	shouldGenerateJava := i.properties.Gen_java == nil || *i.properties.Gen_java
	shouldGenerateJavaConstants := i.properties.Gen_java_constants

	var libraryIfExists []string
	if shouldGenerateLibrary {
		libraryIfExists = []string{name.string()}
	}

	// TODO(b/69002743): remove filegroups
	mctx.CreateModule(android.ModuleFactoryAdaptor(android.FileGroupFactory), &fileGroupProperties{
		Name:  proptools.StringPtr(name.fileGroupName()),
		Owner: i.properties.Owner,
		Srcs:  i.properties.Srcs,
	})

	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
		Name:    proptools.StringPtr(name.sourcesName()),
		Depfile: proptools.BoolPtr(true),
		Owner:   i.properties.Owner,
		Tools:   []string{"hidl-gen"},
		Cmd:     hidlGenCommand("c++-sources", roots, name),
		Srcs:    i.properties.Srcs,
		Out: concat(wrap(name.dir(), interfaces, "All.cpp"),
			wrap(name.dir(), types, ".cpp")),
	})
	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
		Name:    proptools.StringPtr(name.headersName()),
		Depfile: proptools.BoolPtr(true),
		Owner:   i.properties.Owner,
		Tools:   []string{"hidl-gen"},
		Cmd:     hidlGenCommand("c++-headers", roots, name),
		Srcs:    i.properties.Srcs,
		Out: concat(wrap(name.dir()+"I", interfaces, ".h"),
			wrap(name.dir()+"Bs", interfaces, ".h"),
			wrap(name.dir()+"BnHw", interfaces, ".h"),
			wrap(name.dir()+"BpHw", interfaces, ".h"),
			wrap(name.dir()+"IHw", interfaces, ".h"),
			wrap(name.dir(), types, ".h"),
			wrap(name.dir()+"hw", types, ".h")),
	})

	if shouldGenerateLibrary {
		mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
			Name:               proptools.StringPtr(name.string()),
			Owner:              i.properties.Owner,
			Recovery_available: proptools.BoolPtr(true),
			Vendor_available:   proptools.BoolPtr(true),
			Double_loadable:    proptools.BoolPtr(isDoubleLoadable(name.string())),
			Defaults:           []string{"hidl-module-defaults"},
			Generated_sources:  []string{name.sourcesName()},
			Generated_headers:  []string{name.headersName()},
			Shared_libs: concat(cppDependencies, []string{
				"libhidlbase",
				"libhidltransport",
				"libhwbinder",
				"liblog",
				"libutils",
				"libcutils",
			}),
			Export_shared_lib_headers: concat(cppDependencies, []string{
				"libhidlbase",
				"libhidltransport",
				"libhwbinder",
				"libutils",
			}),
			Export_generated_headers: []string{name.headersName()},
		}, &i.properties.VndkProperties)
	}

	if shouldGenerateJava {
		mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
			Name:    proptools.StringPtr(name.javaSourcesName()),
			Depfile: proptools.BoolPtr(true),
			Owner:   i.properties.Owner,
			Tools:   []string{"hidl-gen"},
			Cmd:     hidlGenCommand("java", roots, name),
			Srcs:    i.properties.Srcs,
			Out: concat(wrap(name.sanitizedDir()+"I", interfaces, ".java"),
				wrap(name.sanitizedDir(), i.properties.Types, ".java")),
		})
		mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory), &javaProperties{
			Name:              proptools.StringPtr(name.javaName()),
			Owner:             i.properties.Owner,
			Defaults:          []string{"hidl-java-module-defaults"},
			No_framework_libs: proptools.BoolPtr(true),
			Installable:       proptools.BoolPtr(true),
			Srcs:              []string{":" + name.javaSourcesName()},
			Static_libs:       javaDependencies,

			// This should ideally be system_current, but android.hidl.base-V1.0-java is used
			// to build framework, which is used to build system_current.  Use core_current
			// plus hwbinder.stubs, which together form a subset of system_current that does
			// not depend on framework.
			Sdk_version: proptools.StringPtr("core_current"),
			Libs:        []string{"hwbinder.stubs"},
		})
	}

	if shouldGenerateJavaConstants {
		mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
			Name:    proptools.StringPtr(name.javaConstantsSourcesName()),
			Depfile: proptools.BoolPtr(true),
			Owner:   i.properties.Owner,
			Tools:   []string{"hidl-gen"},
			Cmd:     hidlGenCommand("java-constants", roots, name),
			Srcs:    i.properties.Srcs,
			Out:     []string{name.sanitizedDir() + "Constants.java"},
		})
		mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory), &javaProperties{
			Name:              proptools.StringPtr(name.javaConstantsName()),
			Owner:             i.properties.Owner,
			Defaults:          []string{"hidl-java-module-defaults"},
			No_framework_libs: proptools.BoolPtr(true),
			Srcs:              []string{":" + name.javaConstantsSourcesName()},
		})
	}

	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
		Name:    proptools.StringPtr(name.adapterHelperSourcesName()),
		Depfile: proptools.BoolPtr(true),
		Owner:   i.properties.Owner,
		Tools:   []string{"hidl-gen"},
		Cmd:     hidlGenCommand("c++-adapter-sources", roots, name),
		Srcs:    i.properties.Srcs,
		Out:     wrap(name.dir()+"A", concat(interfaces, types), ".cpp"),
	})
	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
		Name:    proptools.StringPtr(name.adapterHelperHeadersName()),
		Depfile: proptools.BoolPtr(true),
		Owner:   i.properties.Owner,
		Tools:   []string{"hidl-gen"},
		Cmd:     hidlGenCommand("c++-adapter-headers", roots, name),
		Srcs:    i.properties.Srcs,
		Out:     wrap(name.dir()+"A", concat(interfaces, types), ".h"),
	})

	mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
		Name:              proptools.StringPtr(name.adapterHelperName()),
		Owner:             i.properties.Owner,
		Vendor_available:  proptools.BoolPtr(true),
		Defaults:          []string{"hidl-module-defaults"},
		Generated_sources: []string{name.adapterHelperSourcesName()},
		Generated_headers: []string{name.adapterHelperHeadersName()},
		Shared_libs: []string{
			"libbase",
			"libcutils",
			"libhidlbase",
			"libhidltransport",
			"libhwbinder",
			"liblog",
			"libutils",
		},
		Static_libs: concat([]string{
			"libhidladapter",
		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
		Export_shared_lib_headers: []string{
			"libhidlbase",
			"libhidltransport",
		},
		Export_static_lib_headers: concat([]string{
			"libhidladapter",
		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
		Export_generated_headers: []string{name.adapterHelperHeadersName()},
		Group_static_libs:        proptools.BoolPtr(true),
	})
	mctx.CreateModule(android.ModuleFactoryAdaptor(genrule.GenRuleFactory), &genruleProperties{
		Name:    proptools.StringPtr(name.adapterSourcesName()),
		Depfile: proptools.BoolPtr(true),
		Owner:   i.properties.Owner,
		Tools:   []string{"hidl-gen"},
		Cmd:     hidlGenCommand("c++-adapter-main", roots, name),
		Srcs:    i.properties.Srcs,
		Out:     []string{"main.cpp"},
	})
	mctx.CreateModule(android.ModuleFactoryAdaptor(cc.TestFactory), &ccProperties{
		Name:              proptools.StringPtr(name.adapterName()),
		Owner:             i.properties.Owner,
		Generated_sources: []string{name.adapterSourcesName()},
		Shared_libs: []string{
			"libbase",
			"libcutils",
			"libhidlbase",
			"libhidltransport",
			"libhwbinder",
			"liblog",
			"libutils",
		},
		Static_libs: concat([]string{
			"libhidladapter",
			name.adapterHelperName(),
		}, wrap("", dependencies, "-adapter-helper"), cppDependencies, libraryIfExists),
		Group_static_libs: proptools.BoolPtr(true),
	})
}

func (h *hidlInterface) Name() string {
	return h.ModuleBase.Name() + hidlInterfaceSuffix
}
func (h *hidlInterface) GenerateAndroidBuildActions(ctx android.ModuleContext) {
}
func (h *hidlInterface) DepsMutator(ctx android.BottomUpMutatorContext) {
}

var hidlInterfaceMutex sync.Mutex
var hidlInterfaces []*hidlInterface

func hidlInterfaceFactory() android.Module {
	i := &hidlInterface{}
	i.AddProperties(&i.properties)
	android.InitAndroidModule(i)
	android.AddLoadHook(i, func(ctx android.LoadHookContext) { hidlInterfaceMutator(ctx, i) })

	hidlInterfaceMutex.Lock()
	hidlInterfaces = append(hidlInterfaces, i)
	hidlInterfaceMutex.Unlock()

	return i
}

func lookupInterface(name string) *hidlInterface {
	for _, i := range hidlInterfaces {
		if i.ModuleBase.Name() == name {
			return i
		}
	}
	return nil
}

var doubleLoadablePackageNames = []string{
	"android.hardware.configstore@",
	"android.hardware.graphics.allocator@",
	"android.hardware.graphics.bufferqueue@",
	"android.hardware.media.omx@",
	"android.hardware.media@",
	"android.hardware.neuralnetworks@",
	"android.hidl.allocator@",
	"android.hidl.token@",
}

func isDoubleLoadable(name string) bool {
	for _, pkgname := range doubleLoadablePackageNames {
		if strings.HasPrefix(name, pkgname) {
			return true
		}
	}
	return false
}

// packages in libhidltransport
var coreDependencyPackageNames = []string{
	"android.hidl.base@",
	"android.hidl.manager@",
}

func isCorePackage(name string) bool {
	for _, pkgname := range coreDependencyPackageNames {
		if strings.HasPrefix(name, pkgname) {
			return true
		}
	}
	return false
}