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