// Copyright 2020 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 android import ( "fmt" "sync" "github.com/google/blueprint" ) // A SingletonModule is halfway between a Singleton and a Module. It has access to visiting // other modules via its GenerateSingletonBuildActions method, but must be defined in an Android.bp // file and can also be depended on like a module. It must be used zero or one times in an // Android.bp file, and it can only have a single variant. // // The SingletonModule's GenerateAndroidBuildActions method will be called before any normal or // singleton module that depends on it, but its GenerateSingletonBuildActions method will be called // after all modules, in registration order with other singletons and singleton modules. // GenerateAndroidBuildActions and GenerateSingletonBuildActions will not be called if the // SingletonModule was not instantiated in an Android.bp file. // // Since the SingletonModule rules likely depend on the modules visited during // GenerateSingletonBuildActions, the GenerateAndroidBuildActions is unlikely to produce any // rules directly. Instead, it will probably set some providers to paths that will later have rules // generated to produce them in GenerateSingletonBuildActions. // // The expected use case for a SingletonModule is a module that produces files that depend on all // modules in the tree and will be used by other modules. For example it could produce a text // file that lists all modules that meet a certain criteria, and that text file could be an input // to another module. Care must be taken that the ninja rules produced by the SingletonModule // don't produce a cycle by referencing output files of rules of modules that depend on the // SingletonModule. // // A SingletonModule must embed a SingletonModuleBase struct, and its factory method must be // registered with RegisterSingletonModuleType from an init() function. // // A SingletonModule can also implement SingletonMakeVarsProvider to export values to Make. type SingletonModule interface { Module GenerateSingletonBuildActions(SingletonContext) singletonModuleBase() *SingletonModuleBase } // SingletonModuleBase must be embedded into implementers of the SingletonModule interface. type SingletonModuleBase struct { ModuleBase lock sync.Mutex bp string variant string } // GenerateBuildActions wraps the ModuleBase GenerateBuildActions method, verifying it was only // called once to prevent multiple variants of a SingletonModule. func (smb *SingletonModuleBase) GenerateBuildActions(ctx blueprint.ModuleContext) { smb.lock.Lock() if smb.variant != "" { ctx.ModuleErrorf("GenerateAndroidBuildActions already called for variant %q, SingletonModules can only have one variant", smb.variant) } smb.variant = ctx.ModuleSubDir() smb.lock.Unlock() smb.ModuleBase.GenerateBuildActions(ctx) } // InitAndroidSingletonModule must be called from the SingletonModule's factory function to // initialize SingletonModuleBase. func InitAndroidSingletonModule(sm SingletonModule) { InitAndroidModule(sm) } // singletonModuleBase retrieves the embedded SingletonModuleBase from a SingletonModule. func (smb *SingletonModuleBase) singletonModuleBase() *SingletonModuleBase { return smb } // SingletonModuleFactory is a factory method that returns a SingletonModule. type SingletonModuleFactory func() SingletonModule // SingletonModuleFactoryAdaptor converts a SingletonModuleFactory into a SingletonFactory and a // ModuleFactory. func SingletonModuleFactoryAdaptor(name string, factory SingletonModuleFactory) (SingletonFactory, ModuleFactory) { // The sm variable acts as a static holder of the only SingletonModule instance. Calls to the // returned SingletonFactory and ModuleFactory lambdas will always return the same sm value. // The SingletonFactory is only expected to be called once, but the ModuleFactory may be // called multiple times if the module is replaced with a clone of itself at the end of // blueprint.ResolveDependencies. var sm SingletonModule s := func() Singleton { sm = factory() return &singletonModuleSingletonAdaptor{sm} } m := func() Module { if sm == nil { panic(fmt.Errorf("Singleton %q for SingletonModule was not instantiated", name)) } // Check for multiple uses of a SingletonModule in a LoadHook. Checking directly in the // factory would incorrectly flag when the factory was called again when the module is // replaced with a clone of itself at the end of blueprint.ResolveDependencies. AddLoadHook(sm, func(ctx LoadHookContext) { smb := sm.singletonModuleBase() smb.lock.Lock() defer smb.lock.Unlock() if smb.bp != "" { ctx.ModuleErrorf("Duplicate SingletonModule %q, previously used in %s", name, smb.bp) } smb.bp = ctx.BlueprintsFile() }) return sm } return s, m } // singletonModuleSingletonAdaptor makes a SingletonModule into a Singleton by translating the // GenerateSingletonBuildActions method to Singleton.GenerateBuildActions. type singletonModuleSingletonAdaptor struct { sm SingletonModule } // GenerateBuildActions calls the SingletonModule's GenerateSingletonBuildActions method, but only // if the module was defined in an Android.bp file. func (smsa *singletonModuleSingletonAdaptor) GenerateBuildActions(ctx SingletonContext) { if smsa.sm.singletonModuleBase().bp != "" { smsa.sm.GenerateSingletonBuildActions(ctx) } } func (smsa *singletonModuleSingletonAdaptor) MakeVars(ctx MakeVarsContext) { if smsa.sm.singletonModuleBase().bp != "" { if makeVars, ok := smsa.sm.(SingletonMakeVarsProvider); ok { makeVars.MakeVars(ctx) } } }