2 * Copyright (C) 2011, BMW AG
9 * \author Christian Müller (christian.ei.mueller@bmw.de)
12 * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
13 * Copyright (C) 2011, BMW AG – Christian Müller Christian.ei.mueller@bmw.de
15 * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
16 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
17 * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
18 * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
19 * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
20 * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
21 * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
29 #include "audioManagerIncludes.h"
31 class AudioManagerCore;
34 /**These define the different types of Hooks available in the system
37 typedef enum genHook {
38 HOOK_DOMAIN_REGISTER, //!< HOOK_DOMAIN_REGISTER
39 HOOK_DOMAIN_DEREGISTER, //!< HOOK_DOMAIN_DEREGISTER
40 HOOK_SOURCE_REGISTER, //!< HOOK_SOURCE_REGISTER
41 HOOK_SOURCE_DEREGISTER, //!< HOOK_SOURCE_DEREGISTER
42 HOOK_SINK_REGISTER, //!< HOOK_SINK_REGISTER
43 HOOK_SINK_DEREGISTER, //!< HOOK_SINK_DEREGISTER
44 HOOK_GATEWAY_REGISTER, //!< HOOK_GATEWAY_REGISTER
45 HOOK_GATEWAY_DERGISTER, //!< HOOK_GATEWAY_DERGISTER
46 HOOK_SYSTEM_READY, //!< HOOK_SYSTEM_READY
47 HOOK_SYSTEM_DOWN, //!< HOOK_SYSTEM_DOWN
48 HOOK_USER_CONNECTION_REQUEST, //!< HOOK_USER_CONNECTION_REQUEST
49 HOOK_USER_DISCONNECTION_REQUEST, //!< HOOK_USER_DISCONNECTION_REQUEST
50 HOOK_CONNECTION_REQUEST, //!< HOOK_CONNECTION_REQUEST
51 HOOK_DISCONNECTION_REQUEST, //!< HOOK_DISCONNECTION_REQUEST
52 HOOK_ROUTING_REQUEST, //!< HOOK_ROUTING_REQUEST
53 HOOK_ROUTING_COMPLETE, //!< HOOK_ROUTING_COMPLETE
54 HOOK_VOLUME_CHANGE, //!< HOOK_VOLUME_CHANGE
55 HOOK_MUTE_SOURCE, //!< HOOK_MUTE_SOURCEDataBaseHandler
56 HOOK_UNMUTE_SOURCE, //!< HOOK_UNMUTE_SOURCE
57 HOOK_MUTE_SINK, //!< HOOK_MUTE_SINK
58 HOOK_UNMUTE_SINK, //!< HOOK_UNMUTE_SINK
59 HOOK_INTERRUPT_REQUEST
60 //!< HOOK_INTERRUPT_REQUEST
65 /**This is the base class for all HookPlugins
66 * To implement a HookPlugin, a QTPlugin HookPluginFactory Class needs to be created which factors an instance of a class that is derived from
68 * All Hooks that are possible are implemented here as virtual functions. To use a hook, the derived class needs simply to overwrite the
69 * virtual hook functions. This means a plugin can only have one hook function for each hook (more than one does not make sense anyway).
70 * Each plugin need to implement a Init function. Within this function the hooks that the plugin wants to use need to be registered.
77 /**This function is used to register the HookHandler in the plugin.
79 * @param engine pointer to the instance of the HookHandler
80 * @return GEN_OK on success
82 genError_t registerHookEngine(HookHandler* engine);
84 /**This is the init function. Register your hooks here, like for example register to the domainregisterhook with prio 10:
85 * @code m_hookhandler->registerHook(10,HOOK_DOMAIN_REGISTER,this); @endcode
87 * @return GEN_OK on success
89 virtual genError_t InitHook(void)=0;
91 /**Deinit function. If you need to store or cleaup -> here is the right place to do it
93 * @return GEN_OK on success
95 virtual genError_t DeinitHook(void)=0;
97 /**Retrieve the name of the plugin
98 * max length of the name: 40 chars
99 * @param PluginName buffer to write the name to
100 * @return GEN_OK on success
102 virtual genError_t returnPluginName(char* PluginName)=0;
104 void registerAudioManagerCore(AudioManagerCore* core);
106 virtual genHookResult_t hookDomainRegister(char* Name, domain_t ID) {
112 virtual genHookResult_t hookDomainDeregister(domain_t ID) {
117 virtual genHookResult_t hookSinkRegister(char* Name, sink_t ID) {
123 virtual genHookResult_t hookSinkDeregister(sink_t ID) {
128 virtual genHookResult_t hookSourceRegister(char* Name, source_t ID) {
134 virtual genHookResult_t hookSourceDeregister(source_t ID) {
139 virtual genHookResult_t hookGatewayRegister(char* Name, gateway_t ID) {
145 virtual genHookResult_t hookGatewayDeregister(gateway_t ID) {
150 virtual genHookResult_t hookSystemReady(void) {
154 virtual genHookResult_t hookSystemDown(void) {
158 virtual genHookResult_t hookUserConnectionRequest(Queue* queue,
159 source_t SourceID, sink_t SinkID) {
166 virtual genHookResult_t hookUserDisconnectionRequest(Queue* queue,
167 connection_t connID) {
173 virtual genHookResult_t hookConnectionRequest(source_t SourceID,
180 virtual genHookResult_t hookDisconnectionRequest(connection_t ID) {
185 virtual genHookResult_t hookRoutingRequest(bool onlyfree, source_t source,
186 sink_t sink, QList<genRoute_t>* ReturnList) {
194 virtual genHookResult_t hookRoutingComplete(genRoute_t route) {
199 virtual genHookResult_t hookVolumeChange(volume_t newVolume, sink_t SinkID) {
205 virtual genHookResult_t hookMuteSource(source_t ID) {
210 virtual genHookResult_t hookUnmuteSource(source_t ID) {
215 virtual genHookResult_t hookMuteSink(sink_t ID) {
220 virtual genHookResult_t hookUnmuteSink(sink_t ID) {
225 virtual genHookResult_t hookInterruptRequest(Queue* queue,
226 source_t interruptSource, sink_t sink, genInt_t* interruptID) {
228 (void) interruptSource;
236 HookHandler* m_hookhandler;
237 AudioManagerCore* m_core;
240 /**This class handles all the hooks.
241 * It maintains a list of all registered hooks and calls them if desired.
247 virtual ~HookHandler();
248 /**By calling this functions, all Plugins that are related to hooks are automatically loaded
249 * The init function is called as well, so that the plugins can register their hooks
251 void loadHookPlugins();
253 /**This function is used to register a hook
255 * @param prio the prio (between 0 and 100, 100 is max)
256 * @param hookType gives the type of the hook. Must match the hook callback of course !
257 * @param hookClass This is a pointer to the Class registering the hook. Usually this.
258 * @return GEN_OK on success
260 genError_t registerHook(hookprio_t prio, genHook_t hookType,
261 BaseHook* hookClass);
263 void registerAudioManagerCore(AudioManagerCore* core);
265 /**All functions starting with fire are called to execute the hook. They will go throDataBaseHandler::ugh the list
266 * of registered hooks and call them after the priorities.
269 genError_t fireHookDomainRegister(char* Name, domain_t ID);
270 genError_t fireHookDomainDeregister(domain_t ID);
271 genError_t fireHookSinkRegister(char* Name, sink_t ID);
272 genError_t fireHookSinkDeregister(sink_t ID);
273 genError_t fireHookSourceRegister(char* Name, source_t ID);
274 genError_t fireHookSourceDeregister(source_t ID);
275 genError_t fireHookGatewayRegister(char* Name, gateway_t ID);
276 genError_t fireHookGatewayDeregister(gateway_t ID);
277 genError_t fireHookSystemReady(void);
278 genError_t fireHookSystemDown(void);
279 genError_t fireHookConnectionRequest(source_t SourceID, sink_t SinkID);
280 genError_t fireHookDisconnectionRequest(connection_t ID);
281 genError_t fireHookUserConnectionRequest(Queue* queue, source_t SourceID,
283 genError_t fireHookUserDisconnectionRequest(Queue* queue,
284 connection_t connID);
285 genError_t fireHookRoutingRequest(bool onlyfree, source_t SourceID,
286 sink_t SinkID, QList<genRoute_t>* ReturnList);
287 genError_t fireHookRoutingComplete(genRoute_t route);
288 genError_t fireHookVolumeChange(volume_t newVolume, sink_t SinkID);
289 genError_t fireHookMuteSource(source_t ID);
290 genError_t fireHookUnmuteSource(source_t ID);
291 genError_t fireHookMuteSink(sink_t ID);
292 genError_t fireHookUnmuteSink(sink_t ID);
293 genError_t fireHookInterruptRequest(Queue* queue, source_t interruptSource,
294 sink_t sink, genInt_t* interruptID);
297 /**Struct for managing the hookLists
298 * This struct holds the pointer to the instance of the hook to be called and the priority after that the list ist sorted.
306 QList<prioList> m_domainRegisterList;
307 QList<prioList> m_domainDeregisterList;
308 QList<prioList> m_sinkRegisterList;
309 QList<prioList> m_sinkDeregisterList;
310 QList<prioList> m_sourceRegisterList;
311 QList<prioList> m_sourceDeregisterList;
312 QList<prioList> m_gatewayRegisterList;
313 QList<prioList> m_gatewayDeregisterList;
314 QList<prioList> m_systemReadyList;
315 QList<prioList> m_systemDownList;
316 QList<prioList> m_connectionRequestList;
317 QList<prioList> m_disconnectionReuestList;
318 QList<prioList> m_userConnectionRequestList;
319 QList<prioList> m_userDisconnectionReuestList;
320 QList<prioList> m_routingRequestList;
321 QList<prioList> m_routingCompleteList;
322 QList<prioList> m_volumeChangeList;
323 QList<prioList> m_muteSourceList;
324 QList<prioList> m_unmuteSourceList;
325 QList<prioList> m_muteSinkList;
326 QList<prioList> m_unmuteSinkList;
327 QList<prioList> m_interruptRequestList;
329 AudioManagerCore* m_core;
332 /**Factory class for plugin. Needs just to return an instance of the class that the plugin implements.
335 class HookPluginFactory {
337 virtual ~HookPluginFactory() {
339 virtual BaseHook* returnInstance()=0;
342 Q_DECLARE_INTERFACE(HookPluginFactory,"HookPluginFactory/1.0")
345 #endif /* HOOKENGINE_H_ */