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