AudioManagerDaemon/HookEngine.h

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * AudioManangerDeamon
   5  *
   6  * \file HookEngine.h
   7  *
   8  * \date 20.05.2011
   9  * \author Christian Müller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  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
  14  *
  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.
  22  *
  23  *
  24  */
  25
  26 #ifndef HOOKENGINE_H_
  27 #define HOOKENGINE_H_
  28
  29 #include "audioManagerIncludes.h"
  30
  31 class AudioManagerCore;
  32 class Queue;
  33
  34 /**These define the different types of Hooks available in the system
  35  *
  36  */
  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
  61 } genHook_t;
  62
  63 class HookHandler;
  64
  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
  67  * BaseHook.
  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.
  71  *
  72  */
  73 class BaseHook {
  74 public:
  75         BaseHook();
  76         virtual ~BaseHook();
  77         /**This function is used to register the HookHandler in the plugin.
  78          *
  79          * @param engine pointer to the instance of the HookHandler
  80          * @return GEN_OK on success
  81          */
  82         genError_t registerHookEngine(HookHandler* engine);
  83
  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
  86          *
  87          * @return GEN_OK on success
  88          */
  89         virtual genError_t InitHook(void)=0;
  90
  91         /**Deinit function. If you need to store or cleaup -> here is the right place to do it
  92          *
  93          * @return GEN_OK on success
  94          */
  95         virtual genError_t DeinitHook(void)=0;
  96
  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
 101          */
 102         virtual genError_t returnPluginName(char* PluginName)=0;
 103
 104         void registerAudioManagerCore(AudioManagerCore* core);
 105
 106         virtual genHookResult_t hookDomainRegister(char* Name, domain_t ID) {
 107                 (void) Name;
 108                 (void) ID;
 109                 return HOOK_UNUSED;
 110         }
 111         ;
 112         virtual genHookResult_t hookDomainDeregister(domain_t ID) {
 113                 (void) ID;
 114                 return HOOK_UNUSED;
 115         }
 116         ;
 117         virtual genHookResult_t hookSinkRegister(char* Name, sink_t ID) {
 118                 (void) Name;
 119                 (void) ID;
 120                 return HOOK_UNUSED;
 121         }
 122         ;
 123         virtual genHookResult_t hookSinkDeregister(sink_t ID) {
 124                 (void) ID;
 125                 return HOOK_UNUSED;
 126         }
 127         ;
 128         virtual genHookResult_t hookSourceRegister(char* Name, source_t ID) {
 129                 (void) Name;
 130                 (void) ID;
 131                 return HOOK_UNUSED;
 132         }
 133         ;
 134         virtual genHookResult_t hookSourceDeregister(source_t ID) {
 135                 (void) ID;
 136                 return HOOK_UNUSED;
 137         }
 138         ;
 139         virtual genHookResult_t hookGatewayRegister(char* Name, gateway_t ID) {
 140                 (void) Name;
 141                 (void) ID;
 142                 return HOOK_UNUSED;
 143         }
 144         ;
 145         virtual genHookResult_t hookGatewayDeregister(gateway_t ID) {
 146                 (void) ID;
 147                 return HOOK_UNUSED;
 148         }
 149         ;
 150         virtual genHookResult_t hookSystemReady(void) {
 151                 return HOOK_UNUSED;
 152         }
 153         ;
 154         virtual genHookResult_t hookSystemDown(void) {
 155                 return HOOK_UNUSED;
 156         }
 157         ;
 158         virtual genHookResult_t hookUserConnectionRequest(Queue* queue,
 159                         source_t SourceID, sink_t SinkID) {
 160                 (void) queue;
 161                 (void) SourceID;
 162                 (void) SinkID;
 163                 return HOOK_UNUSED;
 164         }
 165         ;
 166         virtual genHookResult_t hookUserDisconnectionRequest(Queue* queue,
 167                         connection_t connID) {
 168                 (void) queue;
 169                 (void) connID;
 170                 return HOOK_UNUSED;
 171         }
 172         ;
 173         virtual genHookResult_t hookConnectionRequest(source_t SourceID,
 174                         sink_t SinkID) {
 175                 (void) SourceID;
 176                 (void) SinkID;
 177                 return HOOK_UNUSED;
 178         }
 179         ;
 180         virtual genHookResult_t hookDisconnectionRequest(connection_t ID) {
 181                 (void) ID;
 182                 return HOOK_UNUSED;
 183         }
 184         ;
 185         virtual genHookResult_t hookRoutingRequest(bool onlyfree, source_t source,
 186                         sink_t sink, std::list<genRoute_t>* ReturnList) {
 187                 (void) onlyfree;
 188                 (void) source;
 189                 (void) sink;
 190                 (void) ReturnList;
 191                 return HOOK_UNUSED;
 192         }
 193         ;
 194         virtual genHookResult_t hookRoutingComplete(genRoute_t route) {
 195                 (void) route;
 196                 return HOOK_UNUSED;
 197         }
 198         ;
 199         virtual genHookResult_t hookVolumeChange(volume_t newVolume, sink_t SinkID) {
 200                 (void) newVolume;
 201                 (void) SinkID;
 202                 return HOOK_UNUSED;
 203         }
 204         ;
 205         virtual genHookResult_t hookMuteSource(source_t ID) {
 206                 (void) ID;
 207                 return HOOK_UNUSED;
 208         }
 209         ;
 210         virtual genHookResult_t hookUnmuteSource(source_t ID) {
 211                 (void) ID;
 212                 return HOOK_UNUSED;
 213         }
 214         ;
 215         virtual genHookResult_t hookMuteSink(sink_t ID) {
 216                 (void) ID;
 217                 return HOOK_UNUSED;
 218         }
 219         ;
 220         virtual genHookResult_t hookUnmuteSink(sink_t ID) {
 221                 (void) ID;
 222                 return HOOK_UNUSED;
 223         }
 224         ;
 225         virtual genHookResult_t hookInterruptRequest(Queue* queue,
 226                         source_t interruptSource, sink_t sink, genInt_t* interruptID) {
 227                 (void) queue;
 228                 (void) interruptSource;
 229                 (void) sink;
 230                 (void) interruptID;
 231                 return HOOK_UNUSED;
 232         }
 233         ;
 234
 235 protected:
 236         HookHandler* m_hookhandler;
 237         AudioManagerCore* m_core;
 238 };
 239
 240 /**This class handles all the hooks.
 241  * It maintains a list of all registered hooks and calls them if desired.
 242  *
 243  */
 244 class HookHandler {
 245 public:
 246         HookHandler();
 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
 250          */
 251         void loadHookPlugins();
 252
 253         /**This function is used to register a hook
 254          *
 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
 259          */
 260         genError_t registerHook(hookprio_t prio, genHook_t hookType,
 261                         BaseHook* hookClass);
 262
 263         void registerAudioManagerCore(AudioManagerCore* core);
 264
 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.
 267          */
 268
 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,
 282                         sink_t SinkID);
 283         genError_t fireHookUserDisconnectionRequest(Queue* queue,
 284                         connection_t connID);
 285         genError_t fireHookRoutingRequest(bool onlyfree, source_t SourceID, sink_t SinkID, std::list<genRoute_t>* ReturnList);
 286         genError_t fireHookRoutingComplete(genRoute_t route);
 287         genError_t fireHookVolumeChange(volume_t newVolume, sink_t SinkID);
 288         genError_t fireHookMuteSource(source_t ID);
 289         genError_t fireHookUnmuteSource(source_t ID);
 290         genError_t fireHookMuteSink(sink_t ID);
 291         genError_t fireHookUnmuteSink(sink_t ID);
 292         genError_t fireHookInterruptRequest(Queue* queue, source_t interruptSource,
 293                         sink_t sink, genInt_t* interruptID);
 294
 295 private:
 296         /**Struct for managing the hookLists
 297          * This struct holds the pointer to the instance of the hook to be called and the priority after that the list ist sorted.
 298          *
 299          */
 300         struct prioList {
 301                 BaseHook* hook;
 302                 hookprio_t prio;
 303         };
 304
 305         std::list<prioList> m_domainRegisterList;
 306         std::list<prioList> m_domainDeregisterList;
 307         std::list<prioList> m_sinkRegisterList;
 308         std::list<prioList> m_sinkDeregisterList;
 309         std::list<prioList> m_sourceRegisterList;
 310         std::list<prioList> m_sourceDeregisterList;
 311         std::list<prioList> m_gatewayRegisterList;
 312         std::list<prioList> m_gatewayDeregisterList;
 313         std::list<prioList> m_systemReadyList;
 314         std::list<prioList> m_systemDownList;
 315         std::list<prioList> m_connectionRequestList;
 316         std::list<prioList> m_disconnectionReuestList;
 317         std::list<prioList> m_userConnectionRequestList;
 318         std::list<prioList> m_userDisconnectionReuestList;
 319         std::list<prioList> m_routingRequestList;
 320         std::list<prioList> m_routingCompleteList;
 321         std::list<prioList> m_volumeChangeList;
 322         std::list<prioList> m_muteSourceList;
 323         std::list<prioList> m_unmuteSourceList;
 324         std::list<prioList> m_muteSinkList;
 325         std::list<prioList> m_unmuteSinkList;
 326         std::list<prioList> m_interruptRequestList;
 327
 328         AudioManagerCore* m_core;
 329         std::list<BaseHook*> m_listofPlugins;
 330 };
 331
 332 #endif /* HOOKENGINE_H_ */