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