AudioManagerDaemon/src/CAmControlSender.cpp

   1 /**
   2  * Copyright (C) 2012, BMW AG
   3  *
   4  * This file is part of GENIVI Project AudioManager.
   5  *
   6  * Contributions are licensed to the GENIVI Alliance under one or more
   7  * Contribution License Agreements.
   8  *
   9  * \copyright
  10  * This Source Code Form is subject to the terms of the
  11  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  12  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  13  *
  14  *
  15  * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
  16  *
  17  * \file CAmControlSender.cpp
  18  * For further information see http://www.genivi.org/.
  19  *
  20  */
  21
  22 #include "CAmControlSender.h"
  23 #include <cassert>
  24 #include <fstream>
  25 #include <iostream>
  26 #include <sstream>
  27 #include <stdexcept>
  28 #include "TAmPluginTemplate.h"
  29 #include "shared/CAmDltWrapper.h"
  30
  31 namespace am
  32 {
  33
  34 #define REQUIRED_INTERFACE_VERSION_MAJOR 1  //!< major interface version. All versions smaller than this will be rejected
  35 #define REQUIRED_INTERFACE_VERSION_MINOR 0 //!< minor interface version. All versions smaller than this will be rejected
  36
  37 CAmControlSender::CAmControlSender(std::string controlPluginFile) :
  38         mlibHandle(NULL), //
  39         mController(NULL)
  40 {
  41     std::ifstream isfile(controlPluginFile.c_str());
  42     if (!isfile)
  43     {
  44         logError("ControlSender::ControlSender: Controller plugin not found:", controlPluginFile);
  45     }
  46     else if (!controlPluginFile.empty())
  47     {
  48         IAmControlSend* (*createFunc)();
  49         createFunc = getCreateFunction<IAmControlSend*()>(controlPluginFile, mlibHandle);
  50         assert(createFunc!=NULL);
  51         mController = createFunc();
  52
  53         //check libversion
  54         std::string version;
  55         mController->getInterfaceVersion(version);
  56         uint16_t minorVersion, majorVersion;
  57         std::istringstream(version.substr(0, 1)) >> majorVersion;
  58         std::istringstream(version.substr(2, 1)) >> minorVersion;
  59
  60         if (majorVersion < REQUIRED_INTERFACE_VERSION_MAJOR || ((majorVersion == REQUIRED_INTERFACE_VERSION_MAJOR) && (minorVersion > REQUIRED_INTERFACE_VERSION_MINOR)))
  61         {
  62             logError("ControlSender::ControlSender: Interface Version of Controller too old, exiting now");
  63             throw std::runtime_error("Interface Version of Controller too old");
  64         }
  65     }
  66     else
  67     {
  68         logError("ControlSender::ControlSender: No controller loaded !");
  69     }
  70 }
  71
  72 CAmControlSender::~CAmControlSender()
  73 {
  74     if (mlibHandle)
  75         dlclose(mlibHandle);
  76 }
  77
  78 am_Error_e CAmControlSender::hookUserConnectionRequest(const am_sourceID_t sourceID, const am_sinkID_t sinkID, am_mainConnectionID_t & mainConnectionID)
  79 {
  80     assert(mController);
  81     return (mController->hookUserConnectionRequest(sourceID, sinkID, mainConnectionID));
  82 }
  83
  84 am_Error_e CAmControlSender::hookUserDisconnectionRequest(const am_mainConnectionID_t connectionID)
  85 {
  86     assert(mController);
  87     return (mController->hookUserDisconnectionRequest(connectionID));
  88 }
  89
  90 am_Error_e CAmControlSender::hookUserSetMainSinkSoundProperty(const am_sinkID_t sinkID, const am_MainSoundProperty_s & soundProperty)
  91 {
  92     assert(mController);
  93     return (mController->hookUserSetMainSinkSoundProperty(sinkID, soundProperty));
  94 }
  95
  96 am_Error_e CAmControlSender::hookUserSetMainSourceSoundProperty(const am_sourceID_t sourceID, const am_MainSoundProperty_s & soundProperty)
  97 {
  98     assert(mController);
  99     return (mController->hookUserSetMainSourceSoundProperty(sourceID, soundProperty));
 100 }
 101
 102 am_Error_e CAmControlSender::hookUserSetSystemProperty(const am_SystemProperty_s & property)
 103 {
 104     assert(mController);
 105     return (mController->hookUserSetSystemProperty(property));
 106 }
 107
 108 am_Error_e CAmControlSender::hookUserVolumeChange(const am_sinkID_t sinkID, const am_mainVolume_t newVolume)
 109 {
 110     assert(mController);
 111     return (mController->hookUserVolumeChange(sinkID, newVolume));
 112 }
 113
 114 am_Error_e CAmControlSender::hookUserVolumeStep(const am_sinkID_t sinkID, const int16_t increment)
 115 {
 116     assert(mController);
 117     return (mController->hookUserVolumeStep(sinkID, increment));
 118 }
 119
 120 am_Error_e CAmControlSender::hookUserSetSinkMuteState(const am_sinkID_t sinkID, const am_MuteState_e muteState)
 121 {
 122     assert(mController);
 123     return (mController->hookUserSetSinkMuteState(sinkID, muteState));
 124 }
 125
 126 am_Error_e CAmControlSender::hookSystemRegisterDomain(const am_Domain_s & domainData, am_domainID_t & domainID)
 127 {
 128     assert(mController);
 129     return (mController->hookSystemRegisterDomain(domainData, domainID));
 130 }
 131
 132 am_Error_e CAmControlSender::hookSystemDeregisterDomain(const am_domainID_t domainID)
 133 {
 134     assert(mController);
 135     return (mController->hookSystemDeregisterDomain(domainID));
 136 }
 137
 138 void CAmControlSender::hookSystemDomainRegistrationComplete(const am_domainID_t domainID)
 139 {
 140     assert(mController);
 141     return (mController->hookSystemDomainRegistrationComplete(domainID));
 142 }
 143
 144 am_Error_e CAmControlSender::hookSystemRegisterSink(const am_Sink_s & sinkData, am_sinkID_t & sinkID)
 145 {
 146     assert(mController);
 147     return (mController->hookSystemRegisterSink(sinkData, sinkID));
 148 }
 149
 150 am_Error_e CAmControlSender::hookSystemDeregisterSink(const am_sinkID_t sinkID)
 151 {
 152     assert(mController);
 153     return (mController->hookSystemDeregisterSink(sinkID));
 154 }
 155
 156 am_Error_e CAmControlSender::hookSystemRegisterSource(const am_Source_s & sourceData, am_sourceID_t & sourceID)
 157 {
 158     assert(mController);
 159     return (mController->hookSystemRegisterSource(sourceData, sourceID));
 160 }
 161
 162 am_Error_e CAmControlSender::hookSystemDeregisterSource(const am_sourceID_t sourceID)
 163 {
 164     assert(mController);
 165     return (mController->hookSystemDeregisterSource(sourceID));
 166 }
 167
 168 am_Error_e CAmControlSender::hookSystemRegisterGateway(const am_Gateway_s & gatewayData, am_gatewayID_t & gatewayID)
 169 {
 170     assert(mController);
 171     return (mController->hookSystemRegisterGateway(gatewayData, gatewayID));
 172 }
 173
 174 am_Error_e CAmControlSender::hookSystemDeregisterGateway(const am_gatewayID_t gatewayID)
 175 {
 176     assert(mController);
 177     return (mController->hookSystemDeregisterGateway(gatewayID));
 178 }
 179
 180 am_Error_e CAmControlSender::hookSystemRegisterCrossfader(const am_Crossfader_s & crossfaderData, am_crossfaderID_t & crossfaderID)
 181 {
 182     assert(mController);
 183     return (mController->hookSystemRegisterCrossfader(crossfaderData, crossfaderID));
 184 }
 185
 186 am_Error_e CAmControlSender::hookSystemDeregisterCrossfader(const am_crossfaderID_t crossfaderID)
 187 {
 188     assert(mController);
 189     return (mController->hookSystemDeregisterCrossfader(crossfaderID));
 190 }
 191
 192 void CAmControlSender::hookSystemSinkVolumeTick(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume)
 193 {
 194     assert(mController);
 195     mController->hookSystemSinkVolumeTick(handle, sinkID, volume);
 196 }
 197
 198 void CAmControlSender::hookSystemSourceVolumeTick(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume)
 199 {
 200     assert(mController);
 201     mController->hookSystemSourceVolumeTick(handle, sourceID, volume);
 202 }
 203
 204 void CAmControlSender::hookSystemInterruptStateChange(const am_sourceID_t sourceID, const am_InterruptState_e interruptState)
 205 {
 206     assert(mController);
 207     mController->hookSystemInterruptStateChange(sourceID, interruptState);
 208 }
 209
 210 void CAmControlSender::hookSystemSinkAvailablityStateChange(const am_sinkID_t sinkID, const am_Availability_s & availability)
 211 {
 212     assert(mController);
 213     mController->hookSystemSinkAvailablityStateChange(sinkID, availability);
 214 }
 215
 216 void CAmControlSender::hookSystemSourceAvailablityStateChange(const am_sourceID_t sourceID, const am_Availability_s & availability)
 217 {
 218     assert(mController);
 219     mController->hookSystemSourceAvailablityStateChange(sourceID, availability);
 220 }
 221
 222 void CAmControlSender::hookSystemDomainStateChange(const am_domainID_t domainID, const am_DomainState_e state)
 223 {
 224     assert(mController);
 225     mController->hookSystemDomainStateChange(domainID, state);
 226 }
 227
 228 void CAmControlSender::hookSystemReceiveEarlyData(const std::vector<am_EarlyData_s> & data)
 229 {
 230     assert(mController);
 231     mController->hookSystemReceiveEarlyData(data);
 232 }
 233
 234 void CAmControlSender::hookSystemSpeedChange(const am_speed_t speed)
 235 {
 236     assert(mController);
 237     mController->hookSystemSpeedChange(speed);
 238 }
 239
 240 void CAmControlSender::hookSystemTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time)
 241 {
 242     assert(mController);
 243     mController->hookSystemTimingInformationChanged(mainConnectionID, time);
 244 }
 245
 246 void CAmControlSender::cbAckConnect(const am_Handle_s handle, const am_Error_e errorID)
 247 {
 248     assert(mController);
 249     mController->cbAckConnect(handle, errorID);
 250 }
 251
 252 void CAmControlSender::cbAckDisconnect(const am_Handle_s handle, const am_Error_e errorID)
 253 {
 254     assert(mController);
 255     mController->cbAckDisconnect(handle, errorID);
 256 }
 257
 258 void CAmControlSender::cbAckCrossFade(const am_Handle_s handle, const am_HotSink_e hostsink, const am_Error_e error)
 259 {
 260     assert(mController);
 261     mController->cbAckCrossFade(handle, hostsink, error);
 262 }
 263
 264 void CAmControlSender::cbAckSetSinkVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 265 {
 266     assert(mController);
 267     mController->cbAckSetSinkVolumeChange(handle, volume, error);
 268 }
 269
 270 void CAmControlSender::cbAckSetSourceVolumeChange(const am_Handle_s handle, const am_volume_t volume, const am_Error_e error)
 271 {
 272     assert(mController);
 273     mController->cbAckSetSourceVolumeChange(handle, volume, error);
 274 }
 275
 276 void CAmControlSender::cbAckSetSourceState(const am_Handle_s handle, const am_Error_e error)
 277 {
 278     assert(mController);
 279     mController->cbAckSetSourceState(handle, error);
 280 }
 281
 282 void CAmControlSender::cbAckSetSourceSoundProperty(const am_Handle_s handle, const am_Error_e error)
 283 {
 284     assert(mController);
 285     mController->cbAckSetSourceSoundProperty(handle, error);
 286 }
 287
 288 am_Error_e CAmControlSender::startupController(IAmControlReceive *controlreceiveinterface)
 289 {
 290     if (!mController)
 291     {
 292         logError("ControlSender::startupController: no Controller to startup!");
 293         throw std::runtime_error("ControlSender::startupController: no Controller to startup! Exiting now ...");
 294         return (E_NON_EXISTENT);
 295     }
 296     return (mController->startupController(controlreceiveinterface));
 297 }
 298
 299 void CAmControlSender::cbAckSetSinkSoundProperty(const am_Handle_s handle, const am_Error_e error)
 300 {
 301     assert(mController);
 302     mController->cbAckSetSinkSoundProperty(handle, error);
 303 }
 304
 305 void CAmControlSender::cbAckSetSinkSoundProperties(const am_Handle_s handle, const am_Error_e error)
 306 {
 307     assert(mController);
 308     mController->cbAckSetSinkSoundProperties(handle, error);
 309 }
 310
 311 void CAmControlSender::cbAckSetSourceSoundProperties(const am_Handle_s handle, const am_Error_e error)
 312 {
 313     assert(mController);
 314     mController->cbAckSetSourceSoundProperties(handle, error);
 315 }
 316
 317 void CAmControlSender::setControllerReady()
 318 {
 319     assert(mController);
 320     mController->setControllerReady();
 321 }
 322
 323 void CAmControlSender::setControllerRundown()
 324 {
 325     assert(mController);
 326     mController->setControllerRundown();
 327 }
 328
 329 am_Error_e am::CAmControlSender::getConnectionFormatChoice(const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_Route_s listRoute, const std::vector<am_ConnectionFormat_e> listPossibleConnectionFormats, std::vector<am_ConnectionFormat_e> & listPrioConnectionFormats)
 330 {
 331     assert(mController);
 332     return (mController->getConnectionFormatChoice(sourceID, sinkID, listRoute, listPossibleConnectionFormats, listPrioConnectionFormats));
 333 }
 334
 335 void CAmControlSender::getInterfaceVersion(std::string & version) const
 336 {
 337     version = ControlSendVersion;
 338 }
 339
 340 void CAmControlSender::confirmCommandReady()
 341 {
 342     assert(mController);
 343     mController->confirmCommandReady();
 344 }
 345
 346 void CAmControlSender::confirmRoutingReady()
 347 {
 348     assert(mController);
 349     mController->confirmRoutingReady();
 350 }
 351
 352 void CAmControlSender::confirmCommandRundown()
 353 {
 354     assert(mController);
 355     mController->confirmCommandRundown();
 356 }
 357
 358 void CAmControlSender::confirmRoutingRundown()
 359 {
 360     assert(mController);
 361     mController->confirmRoutingRundown();
 362 }
 363 }