PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp

   1 /**
   2  *  Copyright (c) copyright 2011-2012 Aricent® Group  and its licensors
   3  *  Copyright (c) 2012 BMW
   4  *
   5  *  \author Sampreeth Ramavana
   6  *      \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
   7  *
   8  *  \copyright
   9  *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
  10  *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
  11  *  subject to the following conditions:
  12  *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  13  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  14  *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
  15  *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  16  *
  17  *  For further information see http://www.genivi.org/.
  18  */
  19
  20 #include "IAmRoutingReceiverShadow.h"
  21 #include <string.h>
  22 #include <fstream>
  23 #include <stdexcept>
  24 #include <cassert>
  25 #include "CAmRoutingSenderDbus.h"
  26 #include "shared/CAmDbusWrapper.h"
  27 #include "shared/CAmDltWrapper.h"
  28
  29 namespace am
  30 {
  31
  32 DLT_IMPORT_CONTEXT(routingDbus)
  33
  34
  35 /**
  36  * static ObjectPathTable is needed for DBus Callback handling
  37  */
  38 static DBusObjectPathVTable gObjectPathVTable;
  39
  40 IAmRoutingReceiverShadowDbus::IAmRoutingReceiverShadowDbus(CAmRoutingSenderDbus* pRoutingSenderDbus) :
  41         mRoutingReceiveInterface(NULL), //
  42         mDBusWrapper(NULL), //
  43         mpRoutingSenderDbus(pRoutingSenderDbus), //
  44         mFunctionMap(createMap()), //
  45         mDBUSMessageHandler(), //
  46         mNumberDomains(0), //
  47         mHandle(0)
  48 {
  49     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow constructed");
  50 }
  51
  52 IAmRoutingReceiverShadowDbus::~IAmRoutingReceiverShadowDbus()
  53 {
  54     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow destructed");
  55 }
  56
  57 void IAmRoutingReceiverShadowDbus::registerDomain(DBusConnection *conn, DBusMessage *msg)
  58 {
  59     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called");
  60
  61     (void) ((conn));
  62     assert(mRoutingReceiveInterface != NULL);
  63     mDBUSMessageHandler.initReceive(msg);
  64     am_Domain_s domain(mDBUSMessageHandler.getDomainData());
  65     CAmRoutingSenderDbus::rs_lookupData_s lookupData;
  66     lookupData.busname = mDBUSMessageHandler.getString();
  67     lookupData.path = mDBUSMessageHandler.getString();
  68     lookupData.interface = mDBUSMessageHandler.getString();
  69     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called, name ", domain.name, "nodename ", domain.nodename);
  70     domain.busname = "DbusRoutingPlugin";
  71     am_Error_e returnCode = mRoutingReceiveInterface->registerDomain(domain, domain.domainID);
  72     mDBUSMessageHandler.initReply(msg);
  73     mDBUSMessageHandler.append(domain.domainID);
  74     mDBUSMessageHandler.append(returnCode);
  75     mDBUSMessageHandler.sendMessage();
  76     if (returnCode != E_OK)
  77     {
  78         log(&routingDbus, DLT_LOG_INFO, "error registering domain");
  79         return;
  80     }
  81     mpRoutingSenderDbus->addDomainLookup(domain.domainID, lookupData);
  82 }
  83
  84 void IAmRoutingReceiverShadowDbus::registerSource(DBusConnection* conn, DBusMessage* msg)
  85 {
  86     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::RegisterSource called");
  87     (void) ((conn));
  88     assert(mRoutingReceiveInterface != NULL);
  89     mDBUSMessageHandler.initReceive(msg);
  90     am_Source_s sourceData(mDBUSMessageHandler.getSourceData());
  91     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSource called, name", sourceData.name, "mSource.sourceClassID", sourceData.sourceClassID, "mSource.domainID", sourceData.domainID);
  92     am_Error_e returnCode = mRoutingReceiveInterface->registerSource(sourceData, sourceData.sourceID);
  93     mDBUSMessageHandler.initReply(msg);
  94     mDBUSMessageHandler.append(sourceData.sourceID);
  95     mDBUSMessageHandler.append(returnCode);
  96     mDBUSMessageHandler.sendMessage();
  97     if (returnCode != E_OK)
  98     {
  99         log(&routingDbus, DLT_LOG_INFO, "error registering source");
 100         return;
 101     }
 102     mpRoutingSenderDbus->addSourceLookup(sourceData.sourceID, sourceData.domainID);
 103 }
 104
 105 void IAmRoutingReceiverShadowDbus::registerSink(DBusConnection* conn, DBusMessage* msg)
 106 {
 107     (void) ((conn));
 108     assert(mRoutingReceiveInterface != NULL);
 109     mDBUSMessageHandler.initReceive(msg);
 110     am_Sink_s sinkData(mDBUSMessageHandler.getSinkData());
 111     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSink called, name", sinkData.name, "mSink.sinkClassID", sinkData.sinkClassID, "mSink.domainID", sinkData.domainID);
 112     am_Error_e returnCode = mRoutingReceiveInterface->registerSink(sinkData, sinkData.sinkID);
 113     mDBUSMessageHandler.initReply(msg);
 114     mDBUSMessageHandler.append(sinkData.sinkID);
 115     mDBUSMessageHandler.append(returnCode);
 116     mDBUSMessageHandler.sendMessage();
 117     if (returnCode != E_OK)
 118     {
 119         log(&routingDbus, DLT_LOG_INFO, "error registering sink");
 120         return;
 121     }
 122     mpRoutingSenderDbus->addSinkLookup(sinkData.sinkID, sinkData.domainID);
 123 }
 124
 125 void IAmRoutingReceiverShadowDbus::registerGateway(DBusConnection* conn, DBusMessage* msg)
 126 {
 127     (void) ((conn));
 128     assert(mRoutingReceiveInterface != NULL);
 129     mDBUSMessageHandler.initReceive(msg);
 130     am_Gateway_s gatewayData(mDBUSMessageHandler.getGatewayData());
 131     am_Error_e returnCode = mRoutingReceiveInterface->registerGateway(gatewayData, gatewayData.gatewayID);
 132     mDBUSMessageHandler.initReply(msg);
 133     mDBUSMessageHandler.append(gatewayData.gatewayID);
 134     mDBUSMessageHandler.append(returnCode);
 135     mDBUSMessageHandler.sendMessage();
 136     if (returnCode != E_OK)
 137     {
 138         log(&routingDbus, DLT_LOG_INFO, "error registering gateway");
 139         return;
 140     }
 141 }
 142
 143 void IAmRoutingReceiverShadowDbus::hookDomainRegistrationComplete(DBusConnection* conn, DBusMessage* msg)
 144 {
 145     (void) ((conn));
 146     assert(mRoutingReceiveInterface != NULL);
 147     mDBUSMessageHandler.initReceive(msg);
 148     am_domainID_t domainID(mDBUSMessageHandler.getInt());
 149     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainRegistrationComplete called, domainID", domainID);
 150     mRoutingReceiveInterface->hookDomainRegistrationComplete((am_domainID_t)((domainID)));
 151 }
 152
 153 void IAmRoutingReceiverShadowDbus::ackConnect(DBusConnection* conn, DBusMessage* msg)
 154 {
 155     (void) ((conn));
 156     assert(mRoutingReceiveInterface != NULL);
 157     mDBUSMessageHandler.initReceive(msg);
 158     uint16_t handle(mDBUSMessageHandler.getUInt());
 159     am_connectionID_t connectionID(mDBUSMessageHandler.getUInt());
 160     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 161     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackConnect called, handle", handle, "connectionID", connectionID, "error", error);
 162     am_Handle_s myhandle;
 163     myhandle.handleType = H_CONNECT;
 164     myhandle.handle = handle;
 165     mRoutingReceiveInterface->ackConnect(myhandle, connectionID, error);
 166     mpRoutingSenderDbus->removeHandle(handle);
 167 }
 168
 169 void IAmRoutingReceiverShadowDbus::ackDisconnect(DBusConnection* conn, DBusMessage* msg)
 170 {
 171     (void) ((conn));
 172     assert(mRoutingReceiveInterface != NULL);
 173     mDBUSMessageHandler.initReceive(msg);
 174     uint16_t handle(mDBUSMessageHandler.getUInt());
 175     am_connectionID_t connectionID(mDBUSMessageHandler.getUInt());
 176     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 177     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackDisconnect called, handle", handle, "connectionID", connectionID, "error", error);
 178     am_Handle_s myhandle;
 179     myhandle.handleType = H_DISCONNECT;
 180     myhandle.handle = handle;
 181     mRoutingReceiveInterface->ackDisconnect(myhandle, connectionID, error);
 182     mpRoutingSenderDbus->removeHandle(handle);
 183 }
 184
 185 void IAmRoutingReceiverShadowDbus::ackSetSinkVolume(DBusConnection* conn, DBusMessage* msg)
 186 {
 187     (void) ((conn));
 188     assert(mRoutingReceiveInterface != NULL);
 189     mDBUSMessageHandler.initReceive(msg);
 190     uint16_t handle(mDBUSMessageHandler.getUInt());
 191     am_volume_t volume(mDBUSMessageHandler.getInt());
 192     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 193     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkVolume called, handle", handle, "error", error, "volume", volume);
 194     am_Handle_s myhandle;
 195     myhandle.handleType = H_SETSINKVOLUME;
 196     myhandle.handle = handle;
 197     mRoutingReceiveInterface->ackSetSinkVolumeChange(myhandle, volume, error);
 198     mpRoutingSenderDbus->removeHandle(handle);
 199 }
 200
 201 void IAmRoutingReceiverShadowDbus::ackSetSourceState(DBusConnection* conn, DBusMessage* msg)
 202 {
 203     (void) ((conn));
 204     assert(mRoutingReceiveInterface != NULL);
 205     mDBUSMessageHandler.initReceive(msg);
 206     uint16_t handle(mDBUSMessageHandler.getUInt());
 207     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 208     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceState called, handle", handle, "error", error);
 209     am_Handle_s myhandle;
 210     myhandle.handleType = H_SETSOURCESTATE;
 211     myhandle.handle = handle;
 212     mRoutingReceiveInterface->ackSetSourceState(myhandle, error);
 213     mpRoutingSenderDbus->removeHandle(handle);
 214 }
 215
 216 void IAmRoutingReceiverShadowDbus::ackSinkVolumeTick(DBusConnection* conn, DBusMessage* msg)
 217 {
 218     (void) ((conn));
 219     assert(mRoutingReceiveInterface != NULL);
 220     mDBUSMessageHandler.initReceive(msg);
 221     uint16_t handle(mDBUSMessageHandler.getUInt());
 222     am_sinkID_t sinkID(mDBUSMessageHandler.getUInt());
 223     am_volume_t volume(mDBUSMessageHandler.getInt());
 224     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSinkVolumeTick called, handle", handle, "sinkID", sinkID, "volume", volume);
 225     am_Handle_s myhandle;
 226     myhandle.handleType = H_SETSINKVOLUME;
 227     myhandle.handle = handle;
 228     mRoutingReceiveInterface->ackSinkVolumeTick(myhandle, sinkID, volume);
 229 }
 230
 231 void IAmRoutingReceiverShadowDbus::ackSourceVolumeTick(DBusConnection* conn, DBusMessage* msg)
 232 {
 233     (void) ((conn));
 234     assert(mRoutingReceiveInterface != NULL);
 235     mDBUSMessageHandler.initReceive(msg);
 236     uint16_t handle(mDBUSMessageHandler.getUInt());
 237     am_sourceID_t sourceID(mDBUSMessageHandler.getUInt());
 238     am_volume_t volume(mDBUSMessageHandler.getInt());
 239     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSourceVolumeTick called, handle", handle, "sourceID", sourceID, "volume", volume);
 240     am_Handle_s myhandle;
 241     myhandle.handleType = H_SETSINKVOLUME;
 242     myhandle.handle = handle;
 243     mRoutingReceiveInterface->ackSourceVolumeTick(myhandle, sourceID, volume);
 244 }
 245
 246 void IAmRoutingReceiverShadowDbus::ackSetSourceVolume(DBusConnection* conn, DBusMessage* msg)
 247 {
 248     (void) ((conn));
 249     assert(mRoutingReceiveInterface != NULL);
 250     mDBUSMessageHandler.initReceive(msg);
 251     uint16_t handle(mDBUSMessageHandler.getUInt());
 252     am_volume_t volume(mDBUSMessageHandler.getInt());
 253     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 254     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceVolume called, handle", handle, "volume", volume, "error", error);
 255     am_Handle_s myhandle;
 256     myhandle.handleType = H_SETSOURCEVOLUME;
 257     myhandle.handle = handle;
 258     mRoutingReceiveInterface->ackSetSourceVolumeChange(myhandle, volume, error);
 259     mpRoutingSenderDbus->removeHandle(handle);
 260 }
 261
 262 void IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperty(DBusConnection* conn, DBusMessage* msg)
 263 {
 264     (void) ((conn));
 265     assert(mRoutingReceiveInterface != NULL);
 266     mDBUSMessageHandler.initReceive(msg);
 267     uint16_t handle(mDBUSMessageHandler.getUInt());
 268     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 269     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error);
 270     am_Handle_s myhandle;
 271     myhandle.handleType = H_SETSINKSOUNDPROPERTY;
 272     myhandle.handle = handle;
 273     mRoutingReceiveInterface->ackSetSinkSoundProperty(myhandle, error);
 274     mpRoutingSenderDbus->removeHandle(handle);
 275 }
 276
 277 void IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperty(DBusConnection* conn, DBusMessage* msg)
 278 {
 279     (void) ((conn));
 280     assert(mRoutingReceiveInterface != NULL);
 281     mDBUSMessageHandler.initReceive(msg);
 282     uint16_t handle(mDBUSMessageHandler.getUInt());
 283     am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt())));
 284     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error);
 285     am_Handle_s myhandle;
 286     myhandle.handleType = H_SETSOURCESOUNDPROPERTY;
 287     myhandle.handle = handle;
 288     mRoutingReceiveInterface->ackSetSourceSoundProperty(myhandle, error);
 289     mpRoutingSenderDbus->removeHandle(handle);
 290 }
 291
 292 void IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperties(DBusConnection* conn, DBusMessage* msg)
 293 {
 294     (void) ((conn));
 295     assert(mRoutingReceiveInterface != NULL);
 296     mDBUSMessageHandler.initReceive(msg);
 297     uint16_t handle = mDBUSMessageHandler.getUInt();
 298     am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt()));
 299     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperties called, handle", handle, "error", error);
 300     am_Handle_s myhandle;
 301     myhandle.handleType = H_SETSINKSOUNDPROPERTIES;
 302     myhandle.handle = handle;
 303     mRoutingReceiveInterface->ackSetSinkSoundProperties(myhandle, error);
 304     mpRoutingSenderDbus->removeHandle(handle);
 305 }
 306
 307 void IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperties(DBusConnection* conn, DBusMessage* msg)
 308 {
 309     (void) ((conn));
 310     assert(mRoutingReceiveInterface != NULL);
 311     mDBUSMessageHandler.initReceive(msg);
 312     uint16_t handle = mDBUSMessageHandler.getUInt();
 313     am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt()));
 314     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceSoundProperties called, handle", handle, "error", error);
 315     am_Handle_s myhandle;
 316     myhandle.handleType = H_SETSOURCESOUNDPROPERTIES;
 317     myhandle.handle = handle;
 318     mRoutingReceiveInterface->ackSetSourceSoundProperties(myhandle, error);
 319     mpRoutingSenderDbus->removeHandle(handle);
 320 }
 321
 322 void IAmRoutingReceiverShadowDbus::ackCrossFading(DBusConnection* conn, DBusMessage* msg)
 323 {
 324     (void) ((conn));
 325     assert(mRoutingReceiveInterface != NULL);
 326     mDBUSMessageHandler.initReceive(msg);
 327     uint16_t handle = mDBUSMessageHandler.getUInt();
 328     am_HotSink_e hotsink = (am_HotSink_e)((mDBUSMessageHandler.getInt()));
 329     am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt()));
 330     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackCrossFading called, handle", handle, "error", error);
 331     am_Handle_s myhandle;
 332     myhandle.handleType = H_CROSSFADE;
 333     myhandle.handle = handle;
 334     mRoutingReceiveInterface->ackCrossFading(myhandle, hotsink, error);
 335     mpRoutingSenderDbus->removeHandle(handle);
 336 }
 337
 338 void IAmRoutingReceiverShadowDbus::peekDomain(DBusConnection* conn, DBusMessage* msg)
 339 {
 340     (void) ((conn));
 341     assert(mRoutingReceiveInterface != NULL);
 342     mDBUSMessageHandler.initReceive(msg);
 343     std::string name = std::string(mDBUSMessageHandler.getString());
 344     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekDomain called, name", name);
 345     am_domainID_t domainID;
 346     am_Error_e returnCode = mRoutingReceiveInterface->peekDomain(name, domainID);
 347     mDBUSMessageHandler.initReply(msg);
 348     mDBUSMessageHandler.append(domainID);
 349     mDBUSMessageHandler.append(returnCode);
 350     mDBUSMessageHandler.sendMessage();
 351 }
 352
 353 void IAmRoutingReceiverShadowDbus::deregisterDomain(DBusConnection* conn, DBusMessage* msg)
 354 {
 355     (void) ((conn));
 356     assert(mRoutingReceiveInterface != NULL);
 357     mDBUSMessageHandler.initReceive(msg);
 358     am_domainID_t domainID = mDBUSMessageHandler.getUInt();
 359     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterDomain called, id", domainID);
 360     am_Error_e returnCode = mRoutingReceiveInterface->deregisterDomain(domainID);
 361     mDBUSMessageHandler.initReply(msg);
 362     mDBUSMessageHandler.append(returnCode);
 363     mDBUSMessageHandler.sendMessage();
 364     mpRoutingSenderDbus->removeDomainLookup(domainID);
 365 }
 366
 367 void IAmRoutingReceiverShadowDbus::deregisterGateway(DBusConnection* conn, DBusMessage* msg)
 368 {
 369     (void) ((conn));
 370     assert(mRoutingReceiveInterface != NULL);
 371     mDBUSMessageHandler.initReceive(msg);
 372     am_gatewayID_t gatewayID = mDBUSMessageHandler.getUInt();
 373     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterGateway called, id", gatewayID);
 374     am_Error_e returnCode = mRoutingReceiveInterface->deregisterGateway(gatewayID);
 375     mDBUSMessageHandler.initReply(msg);
 376     mDBUSMessageHandler.append(returnCode);
 377     mDBUSMessageHandler.sendMessage();
 378 }
 379
 380 void IAmRoutingReceiverShadowDbus::peekSink(DBusConnection* conn, DBusMessage* msg)
 381 {
 382     (void) ((conn));
 383     assert(mRoutingReceiveInterface != NULL);
 384     mDBUSMessageHandler.initReceive(msg);
 385     std::string name = std::string(mDBUSMessageHandler.getString());
 386     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSink called, name", name);
 387     am_sinkID_t sinkID;
 388     am_Error_e returnCode = mRoutingReceiveInterface->peekSink(name, sinkID);
 389     mDBUSMessageHandler.initReply(msg);
 390     mDBUSMessageHandler.append(sinkID);
 391     mDBUSMessageHandler.append(returnCode);
 392     mDBUSMessageHandler.sendMessage();
 393 }
 394
 395 void IAmRoutingReceiverShadowDbus::deregisterSink(DBusConnection* conn, DBusMessage* msg)
 396 {
 397     (void) ((conn));
 398     assert(mRoutingReceiveInterface != NULL);
 399     mDBUSMessageHandler.initReceive(msg);
 400     am_sinkID_t sinkID = mDBUSMessageHandler.getInt();
 401     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterSink called, id", sinkID);
 402     am_Error_e returnCode = mRoutingReceiveInterface->deregisterSink(sinkID);
 403     mDBUSMessageHandler.initReply(msg);
 404     mDBUSMessageHandler.append(returnCode);
 405     mDBUSMessageHandler.sendMessage();
 406     mpRoutingSenderDbus->removeSinkLookup(sinkID);
 407 }
 408
 409 void IAmRoutingReceiverShadowDbus::peekSource(DBusConnection* conn, DBusMessage* msg)
 410 {
 411     (void) ((conn));
 412     assert(mRoutingReceiveInterface != NULL);
 413     mDBUSMessageHandler.initReceive(msg);
 414     std::string name = std::string(mDBUSMessageHandler.getString());
 415     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSource called, name", name);
 416     am_sourceID_t sourceID;
 417     am_Error_e returnCode = mRoutingReceiveInterface->peekSource(name, sourceID);
 418     mDBUSMessageHandler.initReply(msg);
 419     mDBUSMessageHandler.append(sourceID);
 420     mDBUSMessageHandler.append(returnCode);
 421     mDBUSMessageHandler.sendMessage();
 422 }
 423
 424 void IAmRoutingReceiverShadowDbus::deregisterSource(DBusConnection* conn, DBusMessage* msg)
 425 {
 426     (void) ((conn));
 427     assert(mRoutingReceiveInterface != NULL);
 428     mDBUSMessageHandler.initReceive(msg);
 429     am_sourceID_t sourceID = mDBUSMessageHandler.getInt();
 430     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterSource called, id", sourceID);
 431     am_Error_e returnCode = mRoutingReceiveInterface->deregisterSource(sourceID);
 432     mDBUSMessageHandler.initReply(msg);
 433     mDBUSMessageHandler.append(returnCode);
 434     mDBUSMessageHandler.sendMessage();
 435     mpRoutingSenderDbus->removeSourceLookup(sourceID);
 436 }
 437
 438 void IAmRoutingReceiverShadowDbus::registerCrossfader(DBusConnection* conn, DBusMessage* msg)
 439 {
 440     (void) ((conn));
 441     assert(mRoutingReceiveInterface != NULL);
 442     mDBUSMessageHandler.initReceive(msg);
 443     am_Crossfader_s crossfader;
 444     crossfader.crossfaderID = mDBUSMessageHandler.getInt();
 445     crossfader.name = std::string(mDBUSMessageHandler.getString());
 446     crossfader.sinkID_A = mDBUSMessageHandler.getInt();
 447     crossfader.sinkID_B = mDBUSMessageHandler.getInt();
 448     crossfader.sourceID = mDBUSMessageHandler.getInt();
 449     crossfader.hotSink = (am_HotSink_e)((mDBUSMessageHandler.getInt()));
 450     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerCrossfader called, name", crossfader.name);
 451     am_Error_e returnCode = mRoutingReceiveInterface->registerCrossfader(crossfader, crossfader.crossfaderID);
 452     mDBUSMessageHandler.initReply(msg);
 453     mDBUSMessageHandler.append(crossfader.crossfaderID);
 454     mDBUSMessageHandler.append(returnCode);
 455     mDBUSMessageHandler.sendMessage();
 456     if (returnCode != E_OK)
 457     {
 458         log(&routingDbus, DLT_LOG_INFO, "error registering crossfader");
 459         return;
 460     }
 461     //todo: add Crossfader lookup
 462 }
 463
 464 void IAmRoutingReceiverShadowDbus::deregisterCrossfader(DBusConnection* conn, DBusMessage* msg)
 465 {
 466     (void) ((conn));
 467     assert(mRoutingReceiveInterface != NULL);
 468     mDBUSMessageHandler.initReceive(msg);
 469     am_crossfaderID_t crossfaderID = mDBUSMessageHandler.getInt();
 470     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterCrossfader called, id", crossfaderID);
 471     am_Error_e returnCode = mRoutingReceiveInterface->deregisterCrossfader(crossfaderID);
 472     mDBUSMessageHandler.initReply(msg);
 473     mDBUSMessageHandler.append(returnCode);
 474     mDBUSMessageHandler.sendMessage();
 475     //todo: remove Crossfader lookup
 476 }
 477
 478 void IAmRoutingReceiverShadowDbus::peekSourceClassID(DBusConnection* conn, DBusMessage* msg)
 479 {
 480     (void) ((conn));
 481     assert(mRoutingReceiveInterface != NULL);
 482     mDBUSMessageHandler.initReceive(msg);
 483     std::string name = std::string(mDBUSMessageHandler.getString());
 484     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSourceClassID called, name", name);
 485     am_sourceClass_t sourceClassID;
 486     am_Error_e returnCode = mRoutingReceiveInterface->peekSourceClassID(name, sourceClassID);
 487     mDBUSMessageHandler.initReply(msg);
 488     mDBUSMessageHandler.append(sourceClassID);
 489     mDBUSMessageHandler.append(returnCode);
 490     mDBUSMessageHandler.sendMessage();
 491 }
 492
 493 void IAmRoutingReceiverShadowDbus::peekSinkClassID(DBusConnection* conn, DBusMessage* msg)
 494 {
 495     (void) ((conn));
 496     assert(mRoutingReceiveInterface != NULL);
 497     mDBUSMessageHandler.initReceive(msg);
 498     std::string name = std::string(mDBUSMessageHandler.getString());
 499     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSinkClassID called, name", name);
 500     am_sinkClass_t sinkClassID;
 501     am_Error_e returnCode = mRoutingReceiveInterface->peekSinkClassID(name, sinkClassID);
 502     mDBUSMessageHandler.initReply(msg);
 503     mDBUSMessageHandler.append(sinkClassID);
 504     mDBUSMessageHandler.append(returnCode);
 505     mDBUSMessageHandler.sendMessage();
 506 }
 507
 508 void IAmRoutingReceiverShadowDbus::hookInterruptStatusChange(DBusConnection* conn, DBusMessage* msg)
 509 {
 510     (void) ((conn));
 511     assert(mRoutingReceiveInterface != NULL);
 512     mDBUSMessageHandler.initReceive(msg);
 513     am_sourceID_t sourceID = mDBUSMessageHandler.getInt();
 514     am_InterruptState_e interruptState = (am_InterruptState_e)((mDBUSMessageHandler.getInt()));
 515     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookInterruptStatusChange called, sourceID", sourceID);
 516     mRoutingReceiveInterface->hookInterruptStatusChange(sourceID, interruptState);
 517 }
 518
 519 void IAmRoutingReceiverShadowDbus::hookSinkAvailablityStatusChange(DBusConnection* conn, DBusMessage* msg)
 520 {
 521     (void) ((conn));
 522     assert(mRoutingReceiveInterface != NULL);
 523     mDBUSMessageHandler.initReceive(msg);
 524     am_sinkID_t sinkID = mDBUSMessageHandler.getInt();
 525     am_Availability_s avialabilty = mDBUSMessageHandler.getAvailability();
 526     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSinkAvailablityStatusChange called, sinkID", sinkID);
 527     mRoutingReceiveInterface->hookSinkAvailablityStatusChange(sinkID, avialabilty);
 528 }
 529
 530 void IAmRoutingReceiverShadowDbus::hookSourceAvailablityStatusChange(DBusConnection* conn, DBusMessage* msg)
 531 {
 532     (void) ((conn));
 533     assert(mRoutingReceiveInterface != NULL);
 534     mDBUSMessageHandler.initReceive(msg);
 535     am_sourceID_t sourceID = mDBUSMessageHandler.getInt();
 536     am_Availability_s avialabilty = mDBUSMessageHandler.getAvailability();
 537     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSourceAvailablityStatusChange called, sourceID", sourceID);
 538     mRoutingReceiveInterface->hookSourceAvailablityStatusChange(sourceID, avialabilty);
 539 }
 540
 541 void IAmRoutingReceiverShadowDbus::hookDomainStateChange(DBusConnection* conn, DBusMessage* msg)
 542 {
 543     (void) ((conn));
 544     assert(mRoutingReceiveInterface != NULL);
 545     mDBUSMessageHandler.initReceive(msg);
 546     am_domainID_t domainID = mDBUSMessageHandler.getInt();
 547     am_DomainState_e domainState = (am_DomainState_e)((mDBUSMessageHandler.getInt()));
 548     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainStateChange called, hookDomainStateChange", domainID);
 549     mRoutingReceiveInterface->hookDomainStateChange(domainID, domainState);
 550 }
 551
 552 void IAmRoutingReceiverShadowDbus::hookTimingInformationChanged(DBusConnection* conn, DBusMessage* msg)
 553 {
 554     (void) ((conn));
 555     assert(mRoutingReceiveInterface != NULL);
 556     mDBUSMessageHandler.initReceive(msg);
 557     am_connectionID_t connectionID(mDBUSMessageHandler.getInt());
 558     am_timeSync_t time(mDBUSMessageHandler.getInt());
 559     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookTimingInformationChanged called, connectionID", connectionID);
 560     mRoutingReceiveInterface->hookTimingInformationChanged(connectionID, time);
 561 }
 562
 563 void IAmRoutingReceiverShadowDbus::sendChangedData(DBusConnection* conn, DBusMessage* msg)
 564 {
 565     (void) ((conn));
 566     assert(mRoutingReceiveInterface != NULL);
 567     mDBUSMessageHandler.initReceive(msg);
 568     std::vector < am_EarlyData_s > listEarlyData(mDBUSMessageHandler.getEarlyData());
 569     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookTimingInformationChanged called, sendChangedData");
 570     mRoutingReceiveInterface->sendChangedData(listEarlyData);
 571 }
 572
 573 DBusHandlerResult IAmRoutingReceiverShadowDbus::receiveCallback(DBusConnection* conn, DBusMessage* msg, void* user_data)
 574 {
 575     assert(conn != NULL);
 576     assert(msg != NULL);
 577     assert(user_data != NULL);
 578     IAmRoutingReceiverShadowDbus* reference = (IAmRoutingReceiverShadowDbus*) ((user_data));
 579     return (reference->receiveCallbackDelegate(conn, msg));
 580 }
 581
 582 void IAmRoutingReceiverShadowDbus::sendIntrospection(DBusConnection* conn, DBusMessage* msg)
 583 {
 584     assert(conn != NULL);
 585     assert(msg != NULL);
 586     DBusMessage* reply;
 587     DBusMessageIter args;
 588     dbus_uint32_t serial = 0;
 589
 590     // create a reply from the message
 591     reply = dbus_message_new_method_return(msg);
 592     std::ifstream in("RoutingReceiver.xml", std::ifstream::in);
 593     if (!in)
 594     {
 595         logError("IAmCommandReceiverShadow::sendIntrospection could not load xml file");
 596         throw std::runtime_error("IAmCommandReceiverShadow::sendIntrospection Could not load introspecton XML");
 597     }
 598     std::string introspect((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
 599     const char* string = introspect.c_str();
 600     log(&routingDbus, DLT_LOG_INFO, introspect.c_str());
 601
 602     // add the arguments to the reply
 603     dbus_message_iter_init_append(reply, &args);
 604     if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &string))
 605     {
 606         log(&routingDbus, DLT_LOG_INFO, "DBUS handler Out Of Memory!");
 607     }
 608
 609     // send the reply && flush the connection
 610     if (!dbus_connection_send(conn, reply, &serial))
 611     {
 612         log(&routingDbus, DLT_LOG_INFO, "DBUS handler Out Of Memory!");
 613     }
 614     dbus_connection_flush(conn);
 615
 616     // free the reply
 617     dbus_message_unref(reply);
 618 }
 619
 620 DBusHandlerResult IAmRoutingReceiverShadowDbus::receiveCallbackDelegate(DBusConnection* conn, DBusMessage* msg)
 621 {
 622     if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
 623     {
 624         sendIntrospection(conn, msg);
 625         return (DBUS_HANDLER_RESULT_HANDLED);
 626     }
 627     functionMap_t::iterator iter = mFunctionMap.begin();
 628     std::string k(dbus_message_get_member(msg));
 629     log(&routingDbus, DLT_LOG_INFO, k.c_str());
 630     iter = mFunctionMap.find(k);
 631     if (iter != mFunctionMap.end())
 632     {
 633         std::string p(iter->first);
 634         CallBackMethod cb = iter->second;
 635         (this->*cb)(conn, msg);
 636         return (DBUS_HANDLER_RESULT_HANDLED);
 637     }
 638     return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 639 }
 640
 641 void IAmRoutingReceiverShadowDbus::setRoutingReceiver(IAmRoutingReceive*& receiver)
 642 {
 643     assert(receiver != NULL);
 644     mRoutingReceiveInterface = receiver;
 645     gObjectPathVTable.message_function = IAmRoutingReceiverShadowDbus::receiveCallback;
 646     DBusConnection* connection;
 647     mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper);
 648     assert(mDBusWrapper != NULL);
 649     mDBusWrapper->getDBusConnection(connection);
 650     assert(connection != NULL);
 651     mDBUSMessageHandler.setDBusConnection(connection);
 652     std::string path(ROUTING_NODE);
 653     {
 654         assert(receiver != NULL);
 655     }
 656     mDBusWrapper->registerCallback(&gObjectPathVTable, path, this);
 657 }
 658
 659 void IAmRoutingReceiverShadowDbus::confirmRoutingReady(DBusConnection* conn, DBusMessage* msg)
 660 {
 661     (void) ((conn));
 662     assert(mRoutingReceiveInterface != NULL);
 663     mDBUSMessageHandler.initReceive(msg);
 664     am_domainID_t domainID(mDBUSMessageHandler.getInt());
 665     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadowDbus::confirmRoutingReady called, domainID", domainID);
 666
 667     mNumberDomains--;
 668     if(mNumberDomains==0)
 669         mRoutingReceiveInterface->confirmRoutingRundown(mHandle);
 670 }
 671
 672 void IAmRoutingReceiverShadowDbus::confirmRoutingRundown(DBusConnection* conn, DBusMessage* msg)
 673 {
 674     (void) ((conn));
 675     assert(mRoutingReceiveInterface != NULL);
 676     mDBUSMessageHandler.initReceive(msg);
 677     am_domainID_t domainID(mDBUSMessageHandler.getInt());
 678     log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadowDbus::confirmRoutingRundown called, domainID", domainID);
 679
 680     mNumberDomains--;
 681     if(mNumberDomains==0)
 682         mRoutingReceiveInterface->confirmRoutingReady(mHandle);
 683 }
 684
 685 void IAmRoutingReceiverShadowDbus::gotReady(int16_t numberDomains, uint16_t handle)
 686 {
 687     mNumberDomains=numberDomains;
 688     mHandle=handle;
 689 }
 690 void IAmRoutingReceiverShadowDbus::gotRundown(int16_t numberDomains, uint16_t handle)
 691 {
 692     mNumberDomains=numberDomains;
 693     mHandle=handle;
 694 }
 695
 696 IAmRoutingReceiverShadowDbus::functionMap_t IAmRoutingReceiverShadowDbus::createMap()
 697 {
 698     functionMap_t m;
 699     m["ackConnect"] = &IAmRoutingReceiverShadowDbus::ackConnect;
 700     m["ackDisconnect"] = &IAmRoutingReceiverShadowDbus::ackDisconnect;
 701     m["ackSetSinkVolume"] = &IAmRoutingReceiverShadowDbus::ackSetSinkVolume;
 702     m["ackSetSourceVolume"] = &IAmRoutingReceiverShadowDbus::ackSetSourceVolume;
 703     m["ackSetSourceState"] = &IAmRoutingReceiverShadowDbus::ackSetSourceState;
 704     m["ackSinkVolumeTick"] = &IAmRoutingReceiverShadowDbus::ackSinkVolumeTick;
 705     m["ackSourceVolumeTick"] = &IAmRoutingReceiverShadowDbus::ackSourceVolumeTick;
 706     m["ackSetSinkSoundProperty"] = &IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperty;
 707     m["ackSetSourceSoundProperty"] = &IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperty;
 708     m["ackSetSinkSoundProperties"] = &IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperties;
 709     m["ackSetSourceSoundProperties"] = &IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperties;
 710     m["ackCrossFading"] = &IAmRoutingReceiverShadowDbus::ackCrossFading;
 711     m["registerDomain"] = &IAmRoutingReceiverShadowDbus::registerDomain;
 712     m["registerSource"] = &IAmRoutingReceiverShadowDbus::registerSource;
 713     m["registerSink"] = &IAmRoutingReceiverShadowDbus::registerSink;
 714     m["registerGateway"] = &IAmRoutingReceiverShadowDbus::registerGateway;
 715     m["peekDomain"] = &IAmRoutingReceiverShadowDbus::peekDomain;
 716     m["deregisterDomain"] = &IAmRoutingReceiverShadowDbus::deregisterDomain;
 717     m["deregisterGateway"] = &IAmRoutingReceiverShadowDbus::deregisterGateway;
 718     m["peekSink"] = &IAmRoutingReceiverShadowDbus::peekSink;
 719     m["deregisterSink"] = &IAmRoutingReceiverShadowDbus::deregisterSink;
 720     m["peekSource"] = &IAmRoutingReceiverShadowDbus::peekSource;
 721     m["deregisterSource"] = &IAmRoutingReceiverShadowDbus::deregisterSource;
 722     m["registerCrossfader"] = &IAmRoutingReceiverShadowDbus::registerCrossfader;
 723     m["deregisterCrossfader"] = &IAmRoutingReceiverShadowDbus::deregisterCrossfader;
 724     m["peekSourceClassID"] = &IAmRoutingReceiverShadowDbus::peekSourceClassID;
 725     m["peekSinkClassID"] = &IAmRoutingReceiverShadowDbus::peekSinkClassID;
 726     m["hookInterruptStatusChange"] = &IAmRoutingReceiverShadowDbus::hookInterruptStatusChange;
 727     m["hookDomainRegistrationComplete"] = &IAmRoutingReceiverShadowDbus::hookDomainRegistrationComplete;
 728     m["hookSinkAvailablityStatusChange"] = &IAmRoutingReceiverShadowDbus::hookSinkAvailablityStatusChange;
 729     m["hookSourceAvailablityStatusChange"] = &IAmRoutingReceiverShadowDbus::hookSourceAvailablityStatusChange;
 730     m["hookDomainStateChange"] = &IAmRoutingReceiverShadowDbus::hookDomainStateChange;
 731     m["hookTimingInformationChanged"] = &IAmRoutingReceiverShadowDbus::hookTimingInformationChanged;
 732     m["sendChangedData"] = &IAmRoutingReceiverShadowDbus::sendChangedData;
 733     m["confirmRoutingReady"] =  &IAmRoutingReceiverShadowDbus::confirmRoutingReady;
 734     m["confirmRoutingRundown"] =  &IAmRoutingReceiverShadowDbus::confirmRoutingRundown;
 735     return (m);
 736 }
 737 }