// 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 (
"fmt"
"sort"
"strings"
"sync"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
"android/soong/android"
"android/soong/cc"
"android/soong/genrule"
"android/soong/java"
)
var (
hidlInterfaceSuffix = "_interface"
pctx = android.NewPackageContext("android/hidl")
hidl = pctx.HostBinToolVariable("hidl", "hidl-gen")
vtsc = pctx.HostBinToolVariable("vtsc", "vtsc")
soong_zip = pctx.HostBinToolVariable("soong_zip", "soong_zip")
hidlRule = pctx.StaticRule("hidlRule", blueprint.RuleParams{
Depfile: "${depfile}",
Deps: blueprint.DepsGCC,
Command: "rm -rf ${genDir} && ${hidl} -R -p . -d ${depfile} -o ${genDir} -L ${language} ${roots} ${fqName}",
CommandDeps: []string{"${hidl}"},
Description: "HIDL ${language}: ${in} => ${out}",
}, "depfile", "fqName", "genDir", "language", "roots")
hidlSrcJarRule = pctx.StaticRule("hidlSrcJarRule", blueprint.RuleParams{
Depfile: "${depfile}",
Deps: blueprint.DepsGCC,
Command: "rm -rf ${genDir} && " +
"${hidl} -R -p . -d ${depfile} -o ${genDir}/srcs -L ${language} ${roots} ${fqName} && " +
"${soong_zip} -o ${genDir}/srcs.srcjar -C ${genDir}/srcs -D ${genDir}/srcs",
CommandDeps: []string{"${hidl}", "${soong_zip}"},
Description: "HIDL ${language}: ${in} => srcs.srcjar",
}, "depfile", "fqName", "genDir", "language", "roots")
vtsRule = pctx.StaticRule("vtsRule", blueprint.RuleParams{
Command: "rm -rf ${genDir} && ${vtsc} -m${mode} -t${type} ${inputDir}/${packagePath} ${genDir}/${packagePath}",
CommandDeps: []string{"${vtsc}"},
Description: "VTS ${mode} ${type}: ${in} => ${out}",
}, "mode", "type", "inputDir", "genDir", "packagePath")
)
func init() {
android.RegisterModuleType("hidl_interface", hidlInterfaceFactory)
android.RegisterMakeVarsProvider(pctx, makeVarsProvider)
}
type hidlGenProperties struct {
Language string
FqName string
Root string
Interfaces []string
Inputs []string
Outputs []string
}
type hidlGenRule struct {
android.ModuleBase
properties hidlGenProperties
genOutputDir android.Path
genInputs android.Paths
genOutputs android.WritablePaths
}
var _ android.SourceFileProducer = (*hidlGenRule)(nil)
var _ genrule.SourceFileGenerator = (*hidlGenRule)(nil)
func (g *hidlGenRule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
g.genOutputDir = android.PathForModuleGen(ctx)
for _, input := range g.properties.Inputs {
g.genInputs = append(g.genInputs, android.PathForModuleSrc(ctx, input))
}
for _, output := range g.properties.Outputs {
g.genOutputs = append(g.genOutputs, android.PathForModuleGen(ctx, output))
}
if g.properties.Language == "vts" && isVtsSpecPackage(ctx.ModuleName()) {
vtsList := vtsList(ctx.AConfig())
vtsListMutex.Lock()
*vtsList = append(*vtsList, g.genOutputs.Paths()...)
vtsListMutex.Unlock()
}
var fullRootOptions []string
var currentPath android.OptionalPath
ctx.VisitDirectDeps(func(dep android.Module) {
switch t := dep.(type) {
case *hidlInterface:
fullRootOptions = append(fullRootOptions, t.properties.Full_root_option)
case *hidlPackageRoot:
if currentPath.Valid() {
panic(fmt.Sprintf("Expecting only one path, but found %v %v", currentPath, t.getCurrentPath()))
}
currentPath = t.getCurrentPath()
default:
panic(fmt.Sprintf("Unrecognized hidlGenProperties dependency: %T", t))
}
})
fullRootOptions = android.FirstUniqueStrings(fullRootOptions)
inputs := g.genInputs
if currentPath.Valid() {
inputs = append(inputs, currentPath.Path())
}
rule := hidlRule
if g.properties.Language == "java" {
rule = hidlSrcJarRule
}
ctx.ModuleBuild(pctx, android.ModuleBuildParams{
Rule: rule,
Inputs: inputs,
Output: g.genOutputs[0],
ImplicitOutputs: g.genOutputs[1:],
Args: map[string]string{
"depfile": g.genOutputs[0].String() + ".d",
"genDir": g.genOutputDir.String(),
"fqName": g.properties.FqName,
"language": g.properties.Language,
"roots": strings.Join(fullRootOptions, " "),
},
})
}
func (g *hidlGenRule) GeneratedSourceFiles() android.Paths {
return g.genOutputs.Paths()
}
func (g *hidlGenRule) Srcs() android.Paths {
return g.genOutputs.Paths()
}
func (g *hidlGenRule) GeneratedDeps() android.Paths {
return g.genOutputs.Paths()
}
func (g *hidlGenRule) GeneratedHeaderDirs() android.Paths {
return android.Paths{g.genOutputDir}
}
func (g *hidlGenRule) DepsMutator(ctx android.BottomUpMutatorContext) {
ctx.AddDependency(ctx.Module(), nil, g.properties.FqName+hidlInterfaceSuffix)
ctx.AddDependency(ctx.Module(), nil, wrap("", g.properties.Interfaces, hidlInterfaceSuffix)...)
ctx.AddDependency(ctx.Module(), nil, g.properties.Root)
}
func hidlGenFactory() android.Module {
g := &hidlGenRule{}
g.AddProperties(&g.properties)
android.InitAndroidModule(g)
return g
}
type vtscProperties struct {
Mode string
Type string
SpecName string // e.g. foo-vts.spec
Outputs []string
PackagePath string // e.g. android/hardware/foo/1.0/
}
type vtscRule struct {
android.ModuleBase
properties vtscProperties
genOutputDir android.Path
genInputDir android.Path
genInputs android.Paths
genOutputs android.WritablePaths
}
var _ android.SourceFileProducer = (*vtscRule)(nil)
var _ genrule.SourceFileGenerator = (*vtscRule)(nil)
func (g *vtscRule) GenerateAndroidBuildActions(ctx android.ModuleContext) {
g.genOutputDir = android.PathForModuleGen(ctx)
ctx.VisitDirectDeps(func(dep android.Module) {
if specs, ok := dep.(*hidlGenRule); ok {
g.genInputDir = specs.genOutputDir
g.genInputs = specs.genOutputs.Paths()
}
})
for _, output := range g.properties.Outputs {
g.genOutputs = append(g.genOutputs, android.PathForModuleGen(ctx, output))
}
ctx.ModuleBuild(pctx, android.ModuleBuildParams{
Rule: vtsRule,
Inputs: g.genInputs,
Outputs: g.genOutputs,
Args: map[string]string{
"mode": g.properties.Mode,
"type": g.properties.Type,
"inputDir": g.genInputDir.String(),
"genDir": g.genOutputDir.String(),
"packagePath": g.properties.PackagePath,
},
})
}
func (g *vtscRule) GeneratedSourceFiles() android.Paths {
return g.genOutputs.Paths()
}
func (g *vtscRule) Srcs() android.Paths {
return g.genOutputs.Paths()
}
func (g *vtscRule) GeneratedDeps() android.Paths {
return g.genOutputs.Paths()
}
func (g *vtscRule) GeneratedHeaderDirs() android.Paths {
return android.Paths{g.genOutputDir}
}
func (g *vtscRule) DepsMutator(ctx android.BottomUpMutatorContext) {
ctx.AddDependency(ctx.Module(), nil, g.properties.SpecName)
}
func vtscFactory() android.Module {
g := &vtscRule{}
g.AddProperties(&g.properties)
android.InitAndroidModule(g)
return g
}
type hidlInterfaceProperties struct {
// Vndk properties for interface library only.
cc.VndkProperties
// 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
// Unused/deprecated: 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
// Whether to generate VTS-related testing libraries.
Gen_vts *bool
// example: -randroid.hardware:hardware/interfaces
Full_root_option string `blueprint:"mutated"`
}
// TODO(b/119771576): These properties are shared by all Android modules, and we are specifically
// calling these out to be copied to every create module. However, if a new property is added, it
// could break things because this code has no way to know about that.
type manuallyInheritCommonProperties struct {
Enabled *bool
Compile_multilib *string
Target struct {
Host struct {
Compile_multilib *string
}
Android struct {
Compile_multilib *string
}
}
Proprietary *bool
Owner *string
Vendor *bool
Soc_specific *bool
Device_specific *bool
Product_specific *bool
Product_services_specific *bool
Recovery *bool
Init_rc []string
Vintf_fragments []string
Required []string
Notice *string
Dist struct {
Targets []string
Dest *string
Dir *string
Suffix *string
}
}
type hidlInterface struct {
android.ModuleBase
properties hidlInterfaceProperties
inheritCommonProperties manuallyInheritCommonProperties
}
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 removeCoreDependencies(mctx android.LoadHookContext, dependencies []string) []string {
var ret []string
for _, i := range dependencies {
if !isCorePackage(i) {
ret = append(ret, i)
}
}
return ret
}
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", i.properties.Root+" must be a prefix of "+name.string()+".")
}
if lookupPackageRoot(i.properties.Root) == 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.`,
i.properties.Root, name, i.properties.Root, i.properties.Root)
}
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)
cppDependencies := removeCoreDependencies(mctx, dependencies)
if mctx.Failed() {
return
}
shouldGenerateLibrary := !isCorePackage(name.string())
// explicitly true if not specified to give early warning to devs
shouldGenerateJava := proptools.BoolDefault(i.properties.Gen_java, true)
shouldGenerateJavaConstants := i.properties.Gen_java_constants
shouldGenerateVts := shouldGenerateLibrary && proptools.BoolDefault(i.properties.Gen_vts, true)
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()),
Srcs: i.properties.Srcs,
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.sourcesName()),
}, &hidlGenProperties{
Language: "c++-sources",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: concat(wrap(name.dir(), interfaces, "All.cpp"), wrap(name.dir(), types, ".cpp")),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.headersName()),
}, &hidlGenProperties{
Language: "c++-headers",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: 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")),
}, &i.inheritCommonProperties)
if shouldGenerateLibrary {
mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
Name: proptools.StringPtr(name.string()),
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, &i.inheritCommonProperties)
}
if shouldGenerateJava {
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.javaSourcesName()),
}, &hidlGenProperties{
Language: "java",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: []string{"srcs.srcjar"},
}, &i.inheritCommonProperties)
commonJavaProperties := javaProperties{
Defaults: []string{"hidl-java-module-defaults"},
No_framework_libs: proptools.BoolPtr(true),
Installable: proptools.BoolPtr(true),
Srcs: []string{":" + name.javaSourcesName()},
// 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"},
}
mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory), &javaProperties{
Name: proptools.StringPtr(name.javaName()),
Static_libs: javaDependencies,
}, &i.inheritCommonProperties, &commonJavaProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory), &javaProperties{
Name: proptools.StringPtr(name.javaSharedName()),
Libs: javaDependencies,
}, &i.inheritCommonProperties, &commonJavaProperties)
}
if shouldGenerateJavaConstants {
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.javaConstantsSourcesName()),
}, &hidlGenProperties{
Language: "java-constants",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: []string{name.sanitizedDir() + "Constants.java"},
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(java.LibraryFactory), &javaProperties{
Name: proptools.StringPtr(name.javaConstantsName()),
Defaults: []string{"hidl-java-module-defaults"},
No_framework_libs: proptools.BoolPtr(true),
Srcs: []string{":" + name.javaConstantsSourcesName()},
}, &i.inheritCommonProperties)
}
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.adapterHelperSourcesName()),
}, &hidlGenProperties{
Language: "c++-adapter-sources",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: wrap(name.dir()+"A", concat(interfaces, types), ".cpp"),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.adapterHelperHeadersName()),
}, &hidlGenProperties{
Language: "c++-adapter-headers",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: wrap(name.dir()+"A", concat(interfaces, types), ".h"),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
Name: proptools.StringPtr(name.adapterHelperName()),
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),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.adapterSourcesName()),
}, &hidlGenProperties{
Language: "c++-adapter-main",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: []string{"main.cpp"},
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(cc.TestFactory), &ccProperties{
Name: proptools.StringPtr(name.adapterName()),
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),
}, &i.inheritCommonProperties)
if shouldGenerateVts {
vtsSpecs := concat(wrap(name.dir(), interfaces, ".vts"), wrap(name.dir(), types, ".vts"))
mctx.CreateModule(android.ModuleFactoryAdaptor(hidlGenFactory), &nameProperties{
Name: proptools.StringPtr(name.vtsSpecName()),
}, &hidlGenProperties{
Language: "vts",
FqName: name.string(),
Root: i.properties.Root,
Interfaces: i.properties.Interfaces,
Inputs: i.properties.Srcs,
Outputs: vtsSpecs,
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(vtscFactory), &nameProperties{
Name: proptools.StringPtr(name.vtsDriverSourcesName()),
}, &vtscProperties{
Mode: "DRIVER",
Type: "SOURCE",
SpecName: name.vtsSpecName(),
Outputs: wrap("", vtsSpecs, ".cpp"),
PackagePath: name.dir(),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(vtscFactory), &nameProperties{
Name: proptools.StringPtr(name.vtsDriverHeadersName()),
}, &vtscProperties{
Mode: "DRIVER",
Type: "HEADER",
SpecName: name.vtsSpecName(),
Outputs: wrap("", vtsSpecs, ".h"),
PackagePath: name.dir(),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
Name: proptools.StringPtr(name.vtsDriverName()),
Defaults: []string{"VtsHalDriverDefaults"},
Generated_sources: []string{name.vtsDriverSourcesName()},
Generated_headers: []string{name.vtsDriverHeadersName()},
Export_generated_headers: []string{name.vtsDriverHeadersName()},
Shared_libs: wrap("", cppDependencies, "-vts.driver"),
Export_shared_lib_headers: wrap("", cppDependencies, "-vts.driver"),
Static_libs: concat(cppDependencies, libraryIfExists),
// TODO(b/126244142)
Cflags: []string{"-Wno-unused-variable"},
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(vtscFactory), &nameProperties{
Name: proptools.StringPtr(name.vtsProfilerSourcesName()),
}, &vtscProperties{
Mode: "PROFILER",
Type: "SOURCE",
SpecName: name.vtsSpecName(),
Outputs: wrap("", vtsSpecs, ".cpp"),
PackagePath: name.dir(),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(vtscFactory), &nameProperties{
Name: proptools.StringPtr(name.vtsProfilerHeadersName()),
}, &vtscProperties{
Mode: "PROFILER",
Type: "HEADER",
SpecName: name.vtsSpecName(),
Outputs: wrap("", vtsSpecs, ".h"),
PackagePath: name.dir(),
}, &i.inheritCommonProperties)
mctx.CreateModule(android.ModuleFactoryAdaptor(cc.LibraryFactory), &ccProperties{
Name: proptools.StringPtr(name.vtsProfilerName()),
Defaults: []string{"VtsHalProfilerDefaults"},
Generated_sources: []string{name.vtsProfilerSourcesName()},
Generated_headers: []string{name.vtsProfilerHeadersName()},
Export_generated_headers: []string{name.vtsProfilerHeadersName()},
Shared_libs: wrap("", cppDependencies, "-vts.profiler"),
Export_shared_lib_headers: wrap("", cppDependencies, "-vts.profiler"),
Static_libs: concat(cppDependencies, libraryIfExists),
// TODO(b/126244142)
Cflags: []string{"-Wno-unused-variable"},
}, &i.inheritCommonProperties)
}
}
func (h *hidlInterface) Name() string {
return h.ModuleBase.Name() + hidlInterfaceSuffix
}
func (h *hidlInterface) GenerateAndroidBuildActions(ctx android.ModuleContext) {
visited := false
ctx.VisitDirectDeps(func(dep android.Module) {
if visited {
panic("internal error, multiple dependencies found but only one added")
}
visited = true
h.properties.Full_root_option = dep.(*hidlPackageRoot).getFullPackageRoot()
})
if !visited {
panic("internal error, no dependencies found but dependency added")
}
}
func (h *hidlInterface) DepsMutator(ctx android.BottomUpMutatorContext) {
ctx.AddDependency(ctx.Module(), nil, h.properties.Root)
}
func hidlInterfaceFactory() android.Module {
i := &hidlInterface{}
i.AddProperties(&i.properties)
i.AddProperties(&i.inheritCommonProperties)
android.InitAndroidModule(i)
android.AddLoadHook(i, func(ctx android.LoadHookContext) { hidlInterfaceMutator(ctx, i) })
return i
}
var doubleLoadablePackageNames = []string{
"android.frameworks.bufferhub@1.0",
"android.hardware.cas@1.0",
"android.hardware.cas.native@1.0",
"android.hardware.configstore@",
"android.hardware.drm@1.0",
"android.hardware.drm@1.1",
"android.hardware.drm@1.2",
"android.hardware.graphics.allocator@",
"android.hardware.graphics.bufferqueue@",
"android.hardware.media@",
"android.hardware.media.omx@",
"android.hardware.memtrack@1.0",
"android.hardware.neuralnetworks@",
"android.hidl.allocator@",
"android.hidl.token@",
"android.system.suspend@1.0",
}
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
}
// TODO(b/126383715): centralize this logic/support filtering in core VTS build
var coreVtsSpecs = []string{
"android.frameworks.",
"android.hardware.",
"android.hidl.",
"android.system.",
}
func isVtsSpecPackage(name string) bool {
for _, pkgname := range coreVtsSpecs {
if strings.HasPrefix(name, pkgname) {
return true
}
}
return false
}
var vtsListKey = android.NewOnceKey("vtsList")
func vtsList(config android.Config) *android.Paths {
return config.Once(vtsListKey, func() interface{} {
return &android.Paths{}
}).(*android.Paths)
}
var vtsListMutex sync.Mutex
func makeVarsProvider(ctx android.MakeVarsContext) {
vtsList := vtsList(ctx.Config()).Strings()
sort.Strings(vtsList)
ctx.Strict("VTS_SPEC_FILE_LIST", strings.Join(vtsList, " "))
}