AudioManagerDaemon/src/ControlSender.cpp

   1 /*
   2  * ControlSender.cpp
   3  *
   4  *  Created on: Dec 9, 2011
   5  *      Author: christian
   6  */
   7
   8 #include "ControlSender.h"
   9 #include "control/ControlSendInterface.h"
  10 #include "control/ControlReceiveInterface.h"
  11 #include "pluginTemplate.h"
  12 #include <assert.h>
  13
  14 std::string controlPluginFile= "/home/christian/workspace/gitserver/build/plugins/control/libPluginControlInterface.so";
  15
  16 ControlSender::ControlSender()
  17 {
  18         ControlSendInterface* (*createFunc)();
  19         createFunc = getCreateFunction<ControlSendInterface*()>(controlPluginFile,mlibHandle);
  20
  21         assert(createFunc!=NULL);
  22
  23         mController = createFunc();
  24 }
  25
  26 ControlSender::~ControlSender()
  27 {
  28         dlclose(mlibHandle);
  29 }
  30
  31 void ControlSender::hookAllPluginsLoaded()
  32 {
  33         mController->hookAllPluginsLoaded();
  34 }
  35
  36
  37
  38 am_Error_e ControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
  39 {
  40         return mController->hookUserConnectionRequest(sourceID,sinkID,mainConnectionID);
  41 }
  42
  43
  44
  45 am_Error_e ControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
  46 {
  47         return mController->hookUserDisconnectionRequest(connectionID);
  48 }
  49
  50
  51
  52 am_Error_e ControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
  53 {
  54         return mController->hookUserSetMainSinkSoundProperty(sinkID,soundProperty);
  55 }
  56
  57
  58
  59 am_Error_e ControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
  60 {
  61         return mController->hookUserSetMainSourceSoundProperty(sourceID,soundProperty);
  62 }
  63
  64
  65
  66 am_Error_e ControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
  67 {
  68         return mController->hookUserSetSystemProperty(property);
  69 }
  70
  71
  72
  73 am_Error_e ControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
  74 {
  75         return mController->hookUserVolumeChange(sinkID,newVolume);
  76 }
  77
  78
  79
  80 am_Error_e ControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
  81 {
  82         return mController->hookUserVolumeStep(sinkID,increment);
  83 }
  84
  85
  86
  87 am_Error_e ControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
  88 {
  89         return mController->hookUserSetSinkMuteState(sinkID,muteState);
  90 }
  91
  92
  93
  94 am_Error_e ControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
  95 {
  96         return mController->hookSystemRegisterDomain(domainData,domainID);
  97 }
  98
  99
 100
 101 am_Error_e ControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
 102 {
 103         return mController->hookSystemDeregisterDomain(domainID);
 104 }
 105
 106
 107
 108 void ControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
 109 {
 110         return mController->hookSystemDomainRegistrationComplete(domainID);
 111 }
 112
 113
 114
 115 am_Error_e ControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 116 {
 117         return mController->hookSystemRegisterSink(sinkData,sinkID);
 118 }
 119
 120
 121
 122 am_Error_e ControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
 123 {
 124         return mController->hookSystemDeregisterSink(sinkID);
 125 }
 126
 127
 128
 129 am_Error_e ControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 130 {
 131         return mController->hookSystemRegisterSource(sourceData,sourceID);
 132 }
 133
 134
 135
 136 am_Error_e ControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
 137 {
 138         return mController->hookSystemDeregisterSource(sourceID);
 139 }
 140
 141
 142
 143 am_Error_e ControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 144 {
 145         return mController->hookSystemRegisterGateway(gatewayData,gatewayID);
 146 }
 147
 148
 149
 150 am_Error_e ControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
 151 {
 152         return mController->hookSystemDeregisterGateway(gatewayID);
 153 }
 154
 155
 156
 157 am_Error_e ControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 158 {
 159         return mController->hookSystemRegisterCrossfader(crossfaderData,crossfaderID);
 160 }
 161
 162
 163
 164 am_Error_e ControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
 165 {
 166         return mController->hookSystemDeregisterCrossfader(crossfaderID);
 167 }
 168
 169
 170
 171 void ControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 172 {
 173         return mController->hookSystemSinkVolumeTick(handle,sinkID,volume);
 174 }
 175
 176
 177
 178 void ControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 179 {
 180         return mController->hookSystemSourceVolumeTick(handle,sourceID,volume);
 181 }
 182
 183
 184
 185 void ControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 186 {
 187         return mController->hookSystemInterruptStateChange(sourceID,interruptState);
 188 }
 189
 190
 191
 192 void ControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 193 {
 194         return mController->hookSystemSinkAvailablityStateChange(sinkID,availability);
 195 }
 196
 197
 198
 199 void ControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 200 {
 201         return mController->hookSystemSourceAvailablityStateChange(sourceID,availability);
 202 }
 203
 204
 205
 206 void ControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
 207 {
 208         return mController->hookSystemDomainStateChange(domainID,state);
 209 }
 210
 211
 212
 213 void ControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
 214 {
 215         return mController->hookSystemReceiveEarlyData(data);
 216 }
 217
 218
 219
 220 void ControlSender::hookSystemSpeedChange(const am_speed_t speed)
 221 {
 222         return mController->hookSystemSpeedChange(speed);
 223 }
 224
 225
 226
 227 void ControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
 228 {
 229         return mController->hookSystemTimingInformationChanged(mainConnectionID,time);
 230 }
 231
 232
 233
 234 void ControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
 235 {
 236         return mController->cbAckConnect(handle,errorID);
 237 }
 238
 239
 240
 241 void ControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
 242 {
 243         return mController->cbAckDisconnect(handle,errorID);
 244 }
 245
 246
 247
 248 void ControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
 249 {
 250         return mController->cbAckCrossFade(handle,hostsink,error);
 251 }
 252
 253
 254
 255 void ControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 256 {
 257         return mController->cbAckSetSinkVolumeChange(handle,volume,error);
 258 }
 259
 260
 261
 262 void ControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t voulme, const am_Error_e error)
 263 {
 264         return mController->cbAckSetSourceVolumeChange(handle,voulme,error);
 265 }
 266
 267
 268
 269 void ControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
 270 {
 271         return mController->cbAckSetSourceState(handle,error);
 272 }
 273
 274
 275
 276 void ControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 277 {
 278         return mController->cbAckSetSourceSoundProperty(handle,error);
 279 }
 280
 281
 282
 283 am_Error_e ControlSender::startupController(ControlReceiveInterface *controlreceiveinterface)
 284 {
 285         return mController->startupController(controlreceiveinterface);
 286 }
 287
 288 am_Error_e ControlSender::stopController()
 289 {
 290         return mController->stopController();
 291 }
 292
 293 void ControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 294 {
 295         return mController->cbAckSetSinkSoundProperty(handle,error);
 296 }
 297
 298
 299