PluginCommandInterfaceDbus/src/CommandReceiverShadow.cpp

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * GeniviAudioMananger DbusPlugin
   5  *
   6  * \file CommandReceiverShadow.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  * THIS CODE HAS BEEN GENERATED BY ENTERPRISE ARCHITECT GENIVI MODEL. PLEASE CHANGE ONLY IN ENTERPRISE ARCHITECT AND GENERATE AGAIN
  24  */
  25
  26 #include <audiomanagertypes.h>
  27 #include <string>
  28 #include <fstream>
  29 #include <assert.h>
  30 #include "CommandReceiverShadow.h"
  31 #include "DBusCommandSender.h"
  32 #include "DLTWrapper.h"
  33
  34 using namespace am;
  35
  36 DLT_IMPORT_CONTEXT(commandDbus)
  37
  38 /**
  39  * static ObjectPathTable is needed for DBus Callback handling
  40  */
  41 static DBusObjectPathVTable gObjectPathVTable;
  42
  43 CommandReceiverShadow::CommandReceiverShadow() :
  44         mCommandReceiveInterface(NULL), //
  45         mDBusWrapper(NULL), //
  46         mFunctionMap(createMap()), //
  47         mDBUSMessageHandler()
  48 {
  49     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow constructed");
  50 }
  51
  52 CommandReceiverShadow::~CommandReceiverShadow()
  53 {
  54     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow destructed");
  55 }
  56
  57 void CommandReceiverShadow::connect(DBusConnection *conn, DBusMessage *msg)
  58 {
  59     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::connect called");
  60
  61     (void) conn;
  62     assert(mCommandReceiveInterface!=NULL);
  63
  64     mDBUSMessageHandler.initReceive(msg);
  65     am_sourceID_t sourceID = (am_sourceID_t) mDBUSMessageHandler.getUInt();
  66     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
  67     am_mainConnectionID_t mainConnectionID = 0;
  68     am_Error_e returnCode = mCommandReceiveInterface->connect(sourceID, sinkID, mainConnectionID);
  69     mDBUSMessageHandler.initReply(msg);
  70     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
  71     mDBUSMessageHandler.append((dbus_uint16_t) mainConnectionID);
  72     mDBUSMessageHandler.sendMessage();
  73 }
  74
  75 void CommandReceiverShadow::disconnect(DBusConnection *conn, DBusMessage *msg)
  76 {
  77     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::disconnect called");
  78
  79     (void) conn;
  80     assert(mCommandReceiveInterface!=NULL);
  81
  82     mDBUSMessageHandler.initReceive(msg);
  83     am_mainConnectionID_t mainConnnectionID = (am_mainConnectionID_t) mDBUSMessageHandler.getUInt();
  84     am_Error_e returnCode = mCommandReceiveInterface->disconnect(mainConnnectionID);
  85     mDBUSMessageHandler.initReply(msg);
  86     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
  87     mDBUSMessageHandler.sendMessage();
  88 }
  89
  90 void CommandReceiverShadow::setVolume(DBusConnection *conn, DBusMessage *msg)
  91 {
  92     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::setVolume called");
  93
  94     (void) conn;
  95     assert(mCommandReceiveInterface!=NULL);
  96
  97     mDBUSMessageHandler.initReceive(msg);
  98     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
  99     am_volume_t volume = (am_volume_t) mDBUSMessageHandler.getInt();
 100     am_Error_e returnCode = mCommandReceiveInterface->setVolume(sinkID, volume);
 101     mDBUSMessageHandler.initReply(msg);
 102     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 103     mDBUSMessageHandler.sendMessage();
 104 }
 105
 106 void CommandReceiverShadow::volumeStep(DBusConnection *conn, DBusMessage *msg)
 107 {
 108     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::volumeStep called");
 109
 110     (void) conn;
 111     assert(mCommandReceiveInterface!=NULL);
 112
 113     mDBUSMessageHandler.initReceive(msg);
 114     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
 115     int16_t volumeStep = (int16_t) mDBUSMessageHandler.getInt();
 116     am_Error_e returnCode = mCommandReceiveInterface->volumeStep(sinkID, volumeStep);
 117     mDBUSMessageHandler.initReply(msg);
 118     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 119     mDBUSMessageHandler.sendMessage();
 120 }
 121
 122 void CommandReceiverShadow::setSinkMuteState(DBusConnection *conn, DBusMessage *msg)
 123 {
 124     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::setSinkMuteState called");
 125
 126     (void) conn;
 127     assert(mCommandReceiveInterface!=NULL);
 128
 129     mDBUSMessageHandler.initReceive(msg);
 130     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
 131     am_MuteState_e muteState = (am_MuteState_e) mDBUSMessageHandler.getInt();
 132     am_Error_e returnCode = mCommandReceiveInterface->setSinkMuteState(sinkID, muteState);
 133     mDBUSMessageHandler.initReply(msg);
 134     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 135     mDBUSMessageHandler.sendMessage();
 136 }
 137
 138 void CommandReceiverShadow::setMainSinkSoundProperty(DBusConnection *conn, DBusMessage *msg)
 139 {
 140     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::setMainSinkSoundProperty called");
 141
 142     (void) conn;
 143     assert(mCommandReceiveInterface!=NULL);
 144
 145     mDBUSMessageHandler.initReceive(msg);
 146     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
 147     dbus_int16_t type = 0;
 148     dbus_int16_t value = 0;
 149     mDBUSMessageHandler.getProperty(type, value);
 150     am_MainSoundProperty_s mainSoundProperty;
 151     mainSoundProperty.type = (am_MainSoundPropertyType_e) type;
 152     mainSoundProperty.value = (int32_t) value;
 153     am_Error_e returnCode = mCommandReceiveInterface->setMainSinkSoundProperty(mainSoundProperty, sinkID);
 154     mDBUSMessageHandler.initReply(msg);
 155     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 156     mDBUSMessageHandler.sendMessage();
 157 }
 158
 159 void CommandReceiverShadow::setMainSourceSoundProperty(DBusConnection *conn, DBusMessage *msg)
 160 {
 161     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::setMainSourceSoundProperty called");
 162
 163     (void) conn;
 164     assert(mCommandReceiveInterface!=NULL);
 165
 166     mDBUSMessageHandler.initReceive(msg);
 167     am_sourceID_t sourceID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
 168     dbus_int16_t type = 0;
 169     dbus_int16_t value = 0;
 170     mDBUSMessageHandler.getProperty(type, value);
 171     am_MainSoundProperty_s mainSoundProperty;
 172     mainSoundProperty.type = (am_MainSoundPropertyType_e) type;
 173     mainSoundProperty.value = (int32_t) value;
 174     am_Error_e returnCode = mCommandReceiveInterface->setMainSourceSoundProperty(mainSoundProperty, sourceID);
 175     mDBUSMessageHandler.initReply(msg);
 176     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 177     mDBUSMessageHandler.sendMessage();
 178 }
 179
 180 void CommandReceiverShadow::setSystemProperty(DBusConnection *conn, DBusMessage *msg)
 181 {
 182     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::setSystemProperty called");
 183
 184     (void) conn;
 185     assert(mCommandReceiveInterface!=NULL);
 186
 187     mDBUSMessageHandler.initReceive(msg);
 188     dbus_int16_t type = 0;
 189     dbus_int16_t value = 0;
 190     mDBUSMessageHandler.getProperty(type, value);
 191     am_SystemProperty_s systemProperty;
 192     systemProperty.type = (am_SystemPropertyType_e) type;
 193     systemProperty.value = (int32_t) value;
 194     am_Error_e returnCode = mCommandReceiveInterface->setSystemProperty(systemProperty);
 195     mDBUSMessageHandler.initReply(msg);
 196     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 197     mDBUSMessageHandler.sendMessage();
 198 }
 199
 200 void CommandReceiverShadow::getListMainConnections(DBusConnection *conn, DBusMessage *msg)
 201 {
 202     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListMainConnections called");
 203
 204     (void) conn;
 205     assert(mCommandReceiveInterface!=NULL);
 206     std::vector<am_MainConnectionType_s> listMainConnections;
 207     am_Error_e returnCode = mCommandReceiveInterface->getListMainConnections(listMainConnections);
 208     mDBUSMessageHandler.initReply(msg);
 209     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 210     mDBUSMessageHandler.append(listMainConnections);
 211     mDBUSMessageHandler.sendMessage();
 212 }
 213
 214 void CommandReceiverShadow::getListMainSinks(DBusConnection *conn, DBusMessage *msg)
 215 {
 216     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListMainSinks called");
 217
 218     (void) conn;
 219     assert(mCommandReceiveInterface!=NULL);
 220     std::vector<am_SinkType_s> listSinks;
 221     am_Error_e returnCode = mCommandReceiveInterface->getListMainSinks(listSinks);
 222     mDBUSMessageHandler.initReply(msg);
 223     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 224     mDBUSMessageHandler.append(listSinks);
 225     mDBUSMessageHandler.sendMessage();
 226 }
 227
 228 void CommandReceiverShadow::getListMainSources(DBusConnection *conn, DBusMessage *msg)
 229 {
 230     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListMainSources called");
 231
 232     (void) conn;
 233     assert(mCommandReceiveInterface!=NULL);
 234     std::vector<am_SourceType_s> listSources;
 235     am_Error_e returnCode = mCommandReceiveInterface->getListMainSources(listSources);
 236     mDBUSMessageHandler.initReply(msg);
 237     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 238     mDBUSMessageHandler.append(listSources);
 239     mDBUSMessageHandler.sendMessage();
 240 }
 241
 242 void CommandReceiverShadow::getListMainSinkSoundProperties(DBusConnection *conn, DBusMessage *msg)
 243 {
 244     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListMainSinkSoundProperties called");
 245
 246     (void) conn;
 247     assert(mCommandReceiveInterface!=NULL);
 248
 249     mDBUSMessageHandler.initReceive(msg);
 250     am_sinkID_t sinkID = (am_sinkID_t) mDBUSMessageHandler.getUInt();
 251     std::vector<am_MainSoundProperty_s> listSinkSoundProperties;
 252     am_Error_e returnCode = mCommandReceiveInterface->getListMainSinkSoundProperties(sinkID, listSinkSoundProperties);
 253     mDBUSMessageHandler.initReply(msg);
 254     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 255     mDBUSMessageHandler.append(listSinkSoundProperties);
 256     mDBUSMessageHandler.sendMessage();
 257 }
 258
 259 void CommandReceiverShadow::getListMainSourceSoundProperties(DBusConnection *conn, DBusMessage *msg)
 260 {
 261     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListMainSourceSoundProperties called");
 262
 263     (void) conn;
 264     assert(mCommandReceiveInterface!=NULL);
 265
 266     mDBUSMessageHandler.initReceive(msg);
 267     am_sourceID_t sourceID = (am_sourceID_t) mDBUSMessageHandler.getUInt();
 268     std::vector<am_MainSoundProperty_s> listSinkSoundProperties;
 269     am_Error_e returnCode = mCommandReceiveInterface->getListMainSourceSoundProperties(sourceID, listSinkSoundProperties);
 270     mDBUSMessageHandler.initReply(msg);
 271     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 272     mDBUSMessageHandler.append(listSinkSoundProperties);
 273     mDBUSMessageHandler.sendMessage();
 274 }
 275
 276 void CommandReceiverShadow::getListSourceClasses(DBusConnection *conn, DBusMessage *msg)
 277 {
 278     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListSourceClasses called");
 279
 280     (void) conn;
 281     assert(mCommandReceiveInterface!=NULL);
 282     std::vector<am_SourceClass_s> listSourceClasses;
 283     am_Error_e returnCode = mCommandReceiveInterface->getListSourceClasses(listSourceClasses);
 284     mDBUSMessageHandler.initReply(msg);
 285     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 286     mDBUSMessageHandler.append(listSourceClasses);
 287     mDBUSMessageHandler.sendMessage();
 288 }
 289
 290 void CommandReceiverShadow::getListSinkClasses(DBusConnection *conn, DBusMessage *msg)
 291 {
 292     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListSinkClasses called");
 293
 294     (void) conn;
 295     assert(mCommandReceiveInterface!=NULL);
 296     std::vector<am_SinkClass_s> listSinkClasses;
 297     am_Error_e returnCode = mCommandReceiveInterface->getListSinkClasses(listSinkClasses);
 298     mDBUSMessageHandler.initReply(msg);
 299     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 300     mDBUSMessageHandler.append(listSinkClasses);
 301     mDBUSMessageHandler.sendMessage();
 302 }
 303
 304 void CommandReceiverShadow::getListSystemProperties(DBusConnection *conn, DBusMessage *msg)
 305 {
 306     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getListSystemProperties called");
 307
 308     (void) conn;
 309     assert(mCommandReceiveInterface!=NULL);
 310     std::vector<am_SystemProperty_s> listSystemProperties;
 311     am_Error_e returnCode = mCommandReceiveInterface->getListSystemProperties(listSystemProperties);
 312     mDBUSMessageHandler.initReply(msg);
 313     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 314     mDBUSMessageHandler.append(listSystemProperties);
 315     mDBUSMessageHandler.sendMessage();
 316 }
 317
 318 void CommandReceiverShadow::getTimingInformation(DBusConnection *conn, DBusMessage *msg)
 319 {
 320     log(&commandDbus,DLT_LOG_INFO,"CommandReceiverShadow::getTimingInformation called");
 321
 322     (void) conn;
 323     assert(mCommandReceiveInterface!=NULL);
 324
 325     mDBUSMessageHandler.initReceive(msg);
 326     am_mainConnectionID_t mainConnectionID = (am_mainConnectionID_t) mDBUSMessageHandler.getUInt();
 327     am_timeSync_t delay = 0;
 328     am_Error_e returnCode = mCommandReceiveInterface->getTimingInformation(mainConnectionID, delay);
 329     mDBUSMessageHandler.initReply(msg);
 330     mDBUSMessageHandler.append((dbus_int16_t) returnCode);
 331     mDBUSMessageHandler.append((dbus_int16_t) delay);
 332     mDBUSMessageHandler.sendMessage();
 333 }
 334
 335 DBusHandlerResult CommandReceiverShadow::receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data)
 336 {
 337     assert(conn!=NULL);
 338     assert(msg!=NULL);
 339     assert(user_data!=NULL);
 340     CommandReceiverShadow* reference = (CommandReceiverShadow*) user_data;
 341     return (reference->receiveCallbackDelegate(conn, msg));
 342 }
 343
 344 void CommandReceiverShadow::sendIntrospection(DBusConnection *conn, DBusMessage *msg)
 345 {
 346     assert(conn!=NULL);
 347     assert(msg!=NULL);
 348     DBusMessage* reply;
 349     DBusMessageIter args;
 350     dbus_uint32_t serial = 0;
 351
 352     // create a reply from the message
 353     reply = dbus_message_new_method_return(msg);
 354     std::ifstream in(INTROSPECTION_COMMAND_XML_FILE);
 355     assert(in!=NULL);
 356     std::string introspect((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
 357     const char* string = introspect.c_str();
 358
 359     // add the arguments to the reply
 360     dbus_message_iter_init_append(reply, &args);
 361     if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &string))
 362     {
 363         //      DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBUS handler Out Of Memory!"));
 364     }
 365
 366     // send the reply && flush the connection
 367     if (!dbus_connection_send(conn, reply, &serial))
 368     {
 369         //      DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBUS handler Out Of Memory!"));
 370     }
 371     dbus_connection_flush(conn);
 372
 373     // free the reply
 374     dbus_message_unref(reply);
 375 }
 376
 377 DBusHandlerResult CommandReceiverShadow::receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg)
 378 {
 379     //DLT_LOG(dMain, DLT_LOG_INFO, DLT_STRING("message received"));
 380
 381     if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
 382     {
 383         sendIntrospection(conn, msg);
 384         return (DBUS_HANDLER_RESULT_HANDLED);
 385     }
 386
 387     functionMap_t::iterator iter = mFunctionMap.begin();
 388     std::string k(dbus_message_get_member(msg));
 389     iter = mFunctionMap.find(k);
 390     if (iter != mFunctionMap.end())
 391     {
 392         std::string p(iter->first);
 393         CallBackMethod cb = iter->second;
 394         (this->*cb)(conn, msg);
 395         return (DBUS_HANDLER_RESULT_HANDLED);
 396     }
 397
 398     return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
 399 }
 400
 401 void CommandReceiverShadow::setCommandReceiver(CommandReceiveInterface*& receiver)
 402 {
 403     assert(receiver!=NULL);
 404     mCommandReceiveInterface = receiver;
 405
 406     gObjectPathVTable.message_function = CommandReceiverShadow::receiveCallback;
 407
 408     DBusConnection* connection;
 409     mCommandReceiveInterface->getDBusConnectionWrapper(mDBusWrapper);
 410     assert(mDBusWrapper!=NULL);
 411
 412     mDBusWrapper->getDBusConnection(connection);
 413     assert(connection!=NULL);
 414     mDBUSMessageHandler.setDBusConnection(connection);
 415
 416     std::string path(MY_NODE);
 417     mDBusWrapper->registerCallback(&gObjectPathVTable, path, this);
 418 }
 419
 420 CommandReceiverShadow::functionMap_t CommandReceiverShadow::createMap()
 421 {
 422     functionMap_t m;
 423     m["Connect"] = &CommandReceiverShadow::connect;
 424     m["Disconnect"] = &CommandReceiverShadow::disconnect;
 425     m["SetVolume"] = &CommandReceiverShadow::setVolume;
 426     m["VolumeStep"] = &CommandReceiverShadow::volumeStep;
 427     m["SetSinkMuteState"] = &CommandReceiverShadow::setSinkMuteState;
 428     m["SetMainSinkSoundProperty"] = &CommandReceiverShadow::setMainSinkSoundProperty;
 429     m["SetMainSourceSoundProperty"] = &CommandReceiverShadow::setMainSourceSoundProperty;
 430     m["GetListMainConnections"] = &CommandReceiverShadow::getListMainConnections;
 431     m["GetListMainSinks"] = &CommandReceiverShadow::getListMainSinks;
 432     m["GetListMainSources"] = &CommandReceiverShadow::getListMainSources;
 433     m["GetListMainSinkSoundProperties"] = &CommandReceiverShadow::getListMainSinkSoundProperties;
 434     m["GetListMainSourceSoundProperties"] = &CommandReceiverShadow::getListMainSourceSoundProperties;
 435     m["GetListSourceClasses"] = &CommandReceiverShadow::getListSourceClasses;
 436     m["GetListSinkClasses"] = &CommandReceiverShadow::getListSinkClasses;
 437     m["GetListSystemProperties"] = &CommandReceiverShadow::getListSystemProperties;
 438     m["GetTimingInformation"] = &CommandReceiverShadow::getTimingInformation;
 439     m["SetSystemProperty"] = &CommandReceiverShadow::setSystemProperty;
 440     return (m);
 441 }
 442