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