AudioManagerDaemon/src/ControlSender.cpp

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