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