PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.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 "CAmDbusMessageHandler.h"
  21 #include "config.h"
  22 #include <cstdlib>
  23 #include <cassert>
  24 #include <vector>
  25 #include "CAmRoutingSenderDbus.h"
  26 #include "shared/CAmDltWrapper.h"
  27
  28 namespace am
  29 {
  30
  31 DLT_IMPORT_CONTEXT(routingDbus)
  32
  33 CAmRoutingDbusMessageHandler::CAmRoutingDbusMessageHandler() :
  34         mDBusMessageIter(), //
  35         mDBusError(), //
  36         mSerial(0), //
  37         mErrorName(""), //
  38         mErrorMsg(""), //
  39         mpDBusMessage(NULL), //
  40         mpReveiveMessage(NULL), //
  41         mpDBusConnection(NULL)
  42 {
  43     log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler constructed");
  44 }
  45
  46 CAmRoutingDbusMessageHandler::~CAmRoutingDbusMessageHandler()
  47 {
  48     log(&routingDbus, DLT_LOG_INFO, "DBUSMessageHandler destructed");
  49 }
  50
  51 void CAmRoutingDbusMessageHandler::initReceive(DBusMessage* msg)
  52 {
  53     assert(msg!=NULL);
  54     mpReveiveMessage = msg;
  55     if (!dbus_message_iter_init(msg, &mDBusMessageIter))
  56     {
  57         log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler::initReceive DBus Message has no arguments!");
  58         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
  59         mErrorMsg = "DBUS Message has no arguments!";
  60     }
  61 }
  62
  63 void CAmRoutingDbusMessageHandler::initReply(DBusMessage* msg)
  64 {
  65     assert(msg!=NULL);
  66     mpDBusMessage = dbus_message_new_method_return(msg);
  67     if (mpDBusMessage == NULL)
  68     {
  69         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initReply Cannot allocate DBus message!");
  70         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
  71         mErrorMsg = "Cannot create reply!";
  72     }
  73     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  74 }
  75
  76 void CAmRoutingDbusMessageHandler::initSignal(std::string path, std::string signalName)
  77 {
  78     assert(!path.empty());
  79     assert(!signalName.empty());
  80     std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
  81     mpDBusMessage = dbus_message_new_signal(completePath.c_str(), DBUS_SERVICE_PREFIX, signalName.c_str());
  82
  83     if (mpDBusMessage == NULL)
  84     {
  85         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initSignal Cannot allocate DBus message!");
  86     }
  87     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  88 }
  89
  90 void CAmRoutingDbusMessageHandler::sendMessage()
  91 {
  92     assert(mpDBusConnection!=NULL);
  93     if (mpReveiveMessage != 0)
  94     {
  95         mSerial = dbus_message_get_serial(mpReveiveMessage);
  96     }
  97     else
  98     {
  99         mSerial = 1;
 100     }
 101     if (!mErrorName.empty())
 102     {
 103         mpDBusMessage = dbus_message_new_error(mpReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
 104     }
 105     if (!dbus_connection_send(mpDBusConnection, mpDBusMessage, &mSerial))
 106     {
 107         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::sendMessage cannot send message!");
 108     }
 109     dbus_connection_flush(mpDBusConnection);
 110     dbus_message_unref(mpDBusMessage);
 111     mpDBusMessage = NULL;
 112 }
 113
 114 char* CAmRoutingDbusMessageHandler::getString(DBusMessageIter& iter, bool next)
 115 {
 116     char* param = NULL;
 117
 118     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&iter))
 119     {
 120         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getString DBUS handler argument is no String!");
 121         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 122         mErrorMsg = "DBus argument is no string";
 123     }
 124     else
 125     {
 126         dbus_message_iter_get_basic(&iter, &param);
 127         if (next)
 128             dbus_message_iter_next(&iter);
 129     }
 130     return (param);
 131 }
 132
 133 char* CAmRoutingDbusMessageHandler::getString()
 134 {
 135     return (getString(mDBusMessageIter, true));
 136 }
 137
 138 dbus_bool_t CAmRoutingDbusMessageHandler::getBool(DBusMessageIter& iter, bool next)
 139 {
 140     dbus_bool_t boolparam = false;
 141
 142     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&iter))
 143     {
 144         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no bool!");
 145         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 146         mErrorMsg = "DBus argument is no bool";
 147     }
 148     else
 149     {
 150         dbus_message_iter_get_basic(&iter, &boolparam);
 151         if (next)
 152             dbus_message_iter_next(&iter);
 153     }
 154     return (boolparam);
 155 }
 156
 157 dbus_bool_t CAmRoutingDbusMessageHandler::getBool()
 158 {
 159     return (getBool(mDBusMessageIter, true));
 160 }
 161
 162 char CAmRoutingDbusMessageHandler::getByte(DBusMessageIter& iter, bool next)
 163 {
 164     char param;
 165
 166     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&iter))
 167     {
 168         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getByte DBUS handler argument is no byte!");
 169         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 170         mErrorMsg = "DBus argument is no byte";
 171     }
 172     else
 173     {
 174         dbus_message_iter_get_basic(&iter, &param);
 175         if (next)
 176             dbus_message_iter_next(&iter);
 177     }
 178     return (param);
 179 }
 180
 181 char CAmRoutingDbusMessageHandler::getByte()
 182 {
 183     return (getByte(mDBusMessageIter, true));
 184 }
 185
 186 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt(DBusMessageIter& iter, bool next)
 187 {
 188     dbus_uint16_t param;
 189 #ifdef GLIB_DBUS_TYPES_TOLERANT
 190     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&iter))
 191 #else
 192     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter))
 193 #endif
 194     {
 195         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!");
 196         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 197         mErrorMsg = "DBus argument is no uint16_t";
 198     }
 199     else
 200     {
 201         dbus_message_iter_get_basic(&iter, &param);
 202         if (next)
 203             dbus_message_iter_next(&iter);
 204     }
 205     return (param);
 206 }
 207
 208 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt()
 209 {
 210     return (getUInt(mDBusMessageIter, true));
 211 }
 212
 213 dbus_int16_t CAmRoutingDbusMessageHandler::getInt(DBusMessageIter& iter, bool next)
 214 {
 215     dbus_int16_t param;
 216 #ifdef GLIB_DBUS_TYPES_TOLERANT
 217     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
 218 #else
 219     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter))
 220 #endif
 221     {
 222         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int16_t!");
 223         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 224         mErrorMsg = "DBus argument is no int16_t";
 225     }
 226     else
 227     {
 228         dbus_message_iter_get_basic(&iter, &param);
 229         if (next)
 230             dbus_message_iter_next(&iter);
 231     }
 232     return (param);
 233 }
 234
 235 dbus_int16_t CAmRoutingDbusMessageHandler::getInt()
 236 {
 237     return (getInt(mDBusMessageIter, true));
 238 }
 239
 240 double CAmRoutingDbusMessageHandler::getDouble(DBusMessageIter& iter, bool next)
 241 {
 242     double param;
 243     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&iter))
 244     {
 245         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getDouble DBUS handler argument is no double!");
 246         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 247         mErrorMsg = "DBus argument is no double";
 248     }
 249     else
 250     {
 251         dbus_message_iter_get_basic(&iter, &param);
 252         if (next)
 253             dbus_message_iter_next(&iter);
 254     }
 255     return (param);
 256 }
 257
 258 double CAmRoutingDbusMessageHandler::getDouble()
 259 {
 260     return (getDouble(mDBusMessageIter, true));
 261 }
 262
 263 am::am_Availability_s CAmRoutingDbusMessageHandler::getAvailability()
 264 {
 265     am::am_Availability_s availability;
 266     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 267     {
 268         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getAvailability DBUS handler argument is no struct!");
 269         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 270         mErrorMsg = "DBus argument is no struct";
 271     }
 272     else
 273     {
 274         DBusMessageIter structIter;
 275         dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
 276         availability.availability = static_cast<am_Availablility_e>(getInt(structIter, true));
 277         availability.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(structIter, false));
 278         dbus_message_iter_next(&mDBusMessageIter);
 279     }
 280     return (availability);
 281 }
 282
 283 std::vector<am_EarlyData_s> CAmRoutingDbusMessageHandler::getEarlyData()
 284 {
 285     std::vector<am_EarlyData_s> listEarlyData;
 286     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 287     {
 288         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getProperty DBUS handler argument is no array!");
 289         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 290         mErrorMsg = "DBus argument is no array";
 291     }
 292     else
 293     {
 294         DBusMessageIter arrayIter, structIter, soundpropIter;
 295         am_EarlyData_s earlyData;
 296
 297         //first the volume array
 298         do
 299         {
 300             dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 301             dbus_message_iter_recurse(&arrayIter, &structIter);
 302             earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
 303             if (earlyData.type==ED_SINK_VOLUME)
 304                 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
 305             else
 306                 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
 307             earlyData.data.volume = static_cast<am_volume_t>(getInt(structIter, false));
 308             listEarlyData.push_back(earlyData);
 309         } while (dbus_message_iter_next(&arrayIter));
 310         dbus_message_iter_next(&mDBusMessageIter);
 311
 312         //then the soundproperty array
 313         do
 314         {
 315             dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 316             dbus_message_iter_recurse(&arrayIter, &structIter);
 317             earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
 318             if (earlyData.type==ED_SINK_PROPERTY)
 319                 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
 320             else
 321                 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
 322             dbus_message_iter_recurse(&structIter, &soundpropIter);
 323             earlyData.data.soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(soundpropIter, true));
 324             earlyData.data.soundProperty.value = (getInt(soundpropIter, false));
 325             listEarlyData.push_back(earlyData);
 326         } while (dbus_message_iter_next(&arrayIter));
 327     }
 328     return (listEarlyData);
 329 }
 330
 331 am_Domain_s CAmRoutingDbusMessageHandler::getDomainData()
 332 {
 333     am_Domain_s domainData;
 334     domainData.domainID = static_cast<am_domainID_t>(getUInt());
 335     domainData.name = getString();
 336     domainData.busname = getString();
 337     domainData.nodename = getString();
 338     domainData.early = getBool();
 339     domainData.complete = getBool();
 340     domainData.state = static_cast<am_DomainState_e>(getUInt());
 341     return (domainData);
 342 }
 343
 344 am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
 345 {
 346     am_Source_s sourceData;
 347     DBusMessageIter availIter, arrayIter, structIter;
 348     am_SoundProperty_s soundProperty;
 349     am_ConnectionFormat_e connectionFormat;
 350     am_MainSoundProperty_s mainSoundProperty;
 351     sourceData.sourceID = static_cast<am_sourceID_t>(getUInt());
 352     sourceData.domainID = static_cast<am_domainID_t>(getUInt());
 353     sourceData.name = getString();
 354     sourceData.sourceClassID = static_cast<am_sourceClass_t>(getUInt());
 355     sourceData.sourceState = static_cast<am_SourceState_e>(getUInt());
 356     sourceData.volume = static_cast<am_volume_t>(getInt());
 357     sourceData.visible = getBool();
 358     dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
 359     sourceData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
 360     sourceData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
 361     dbus_message_iter_next(&mDBusMessageIter);
 362     sourceData.interruptState = static_cast<am_InterruptState_e>(getUInt());
 363     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 364     do
 365     {
 366         dbus_message_iter_recurse(&arrayIter, &structIter);
 367         soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
 368         soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 369         sourceData.listSoundProperties.push_back(soundProperty);
 370     } while (dbus_message_iter_next(&arrayIter));
 371     dbus_message_iter_next(&mDBusMessageIter);
 372     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 373     do
 374     {
 375         connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
 376         sourceData.listConnectionFormats.push_back(connectionFormat);
 377     } while (dbus_message_iter_next(&arrayIter));
 378     dbus_message_iter_next(&mDBusMessageIter);
 379
 380     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 381     do
 382     {
 383         dbus_message_iter_recurse(&arrayIter, &structIter);
 384         mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
 385         mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 386         sourceData.listMainSoundProperties.push_back(mainSoundProperty);
 387     } while (dbus_message_iter_next(&arrayIter));
 388     return (sourceData);
 389 }
 390
 391 am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
 392 {
 393     am_Sink_s sinkData;
 394     DBusMessageIter structIter, availIter, arrayIter;
 395     am_SoundProperty_s soundProperty;
 396     am_ConnectionFormat_e connectionFormat;
 397     am_MainSoundProperty_s mainSoundProperty;
 398     sinkData.sinkID = static_cast<am_sinkID_t>(getUInt());
 399     sinkData.name = getString();
 400     sinkData.domainID = static_cast<am_domainID_t>(getUInt());
 401     sinkData.sinkClassID = static_cast<am_sinkClass_t>(getUInt());
 402     sinkData.volume = static_cast<am_volume_t>(getInt());
 403     sinkData.visible = getBool();
 404     dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
 405     sinkData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
 406     sinkData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
 407     dbus_message_iter_next(&mDBusMessageIter);
 408     sinkData.muteState = static_cast<am_MuteState_e>(getInt());
 409     sinkData.mainVolume = static_cast<am_mainVolume_t>(getInt());
 410
 411     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 412     do
 413     {
 414         dbus_message_iter_recurse(&arrayIter, &structIter);
 415         soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
 416         soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 417         sinkData.listSoundProperties.push_back(soundProperty);
 418     } while (dbus_message_iter_next(&arrayIter));
 419
 420     dbus_message_iter_next(&mDBusMessageIter);
 421
 422     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 423     do
 424     {
 425         connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
 426         sinkData.listConnectionFormats.push_back(connectionFormat);
 427     } while (dbus_message_iter_next(&arrayIter));
 428     dbus_message_iter_next(&mDBusMessageIter);
 429
 430     dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 431     do
 432     {
 433         dbus_message_iter_recurse(&arrayIter, &structIter);
 434         mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
 435         mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 436         sinkData.listMainSoundProperties.push_back(mainSoundProperty);
 437     } while (dbus_message_iter_next(&arrayIter));
 438     return (sinkData);
 439 }
 440
 441 am_Gateway_s CAmRoutingDbusMessageHandler::getGatewayData()
 442 {
 443     am_Gateway_s gatewayData;
 444     DBusMessageIter arrayIter;
 445     am_ConnectionFormat_e connectionFormat;
 446     bool convertion;
 447     gatewayData.gatewayID = static_cast<am_gatewayID_t>(getUInt());
 448     gatewayData.name = getString();
 449     gatewayData.sinkID = static_cast<am_sinkID_t>(getUInt());
 450     gatewayData.sourceID = static_cast<am_sourceID_t>(getUInt());
 451     gatewayData.domainSinkID = static_cast<am_domainID_t>(getUInt());
 452     gatewayData.domainSourceID = static_cast<am_domainID_t>(getUInt());
 453     gatewayData.controlDomainID = static_cast<am_domainID_t>(getUInt());
 454     do
 455     {
 456         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 457         connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
 458         gatewayData.listSourceFormats.push_back(connectionFormat);
 459     } while (dbus_message_iter_next(&arrayIter));
 460     dbus_message_iter_next(&mDBusMessageIter);
 461     do
 462     {
 463         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 464         connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
 465         gatewayData.listSinkFormats.push_back(connectionFormat);
 466     } while (dbus_message_iter_next(&arrayIter));
 467     dbus_message_iter_next(&mDBusMessageIter);
 468     do
 469     {
 470         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 471         convertion = getBool(arrayIter, false);
 472         gatewayData.convertionMatrix.push_back(connectionFormat);
 473     } while (dbus_message_iter_next(&arrayIter));
 474     return (gatewayData);
 475 }
 476
 477 am_MainSoundProperty_s CAmRoutingDbusMessageHandler::getMainSoundProperty()
 478 {
 479     am_MainSoundProperty_s mainSoundProperty;
 480     DBusMessageIter structIter;
 481
 482     dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
 483     mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
 484     mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 485     dbus_message_iter_next(&mDBusMessageIter);
 486
 487     return (mainSoundProperty);
 488 }
 489
 490 void CAmRoutingDbusMessageHandler::append(bool toAppend)
 491 {
 492     dbus_bool_t mybool = toAppend;
 493     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 494     {
 495         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 496         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 497         mErrorMsg = "Cannot create reply!";
 498     }
 499 }
 500
 501 void CAmRoutingDbusMessageHandler::append(double toAppend)
 502 {
 503     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 504     {
 505         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 506         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 507         mErrorMsg = "Cannot create reply!";
 508     }
 509 }
 510
 511 void CAmRoutingDbusMessageHandler::append(char toAppend)
 512 {
 513     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 514     {
 515         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 516         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 517         mErrorMsg = "Cannot create reply!";
 518     }
 519 }
 520
 521 void CAmRoutingDbusMessageHandler::append(dbus_int16_t toAppend)
 522 {
 523     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
 524     {
 525         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 526         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 527         mErrorMsg = "Cannot create reply!";
 528     }
 529 }
 530
 531 void CAmRoutingDbusMessageHandler::append(dbus_uint16_t toAppend)
 532 {
 533     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 534     {
 535         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 536         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 537         mErrorMsg = "Cannot create reply!";
 538     }
 539 }
 540
 541 void CAmRoutingDbusMessageHandler::setDBusConnection(DBusConnection*& connection)
 542 {
 543     assert(connection != NULL);
 544     mpDBusConnection = connection;
 545 }
 546
 547 void CAmRoutingDbusMessageHandler::append(const am::am_SinkType_s& sinkType)
 548 {
 549     DBusMessageIter structIter;
 550     DBusMessageIter structAvailIter;
 551     dbus_bool_t success = true;
 552     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 553     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 554     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 555     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 556     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 557     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 558     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 559     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 560     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 561     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 562     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 563     if (!success)
 564     {
 565         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 566         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 567         mErrorMsg = "Cannot create reply!";
 568     }
 569 }
 570
 571 void CAmRoutingDbusMessageHandler::append(const am::am_SourceType_s& sourceType)
 572 {
 573     DBusMessageIter structIter;
 574     DBusMessageIter structAvailIter;
 575     dbus_bool_t success = true;
 576     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 577     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 578     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 579     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 580     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 581     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 582     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 583     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 584     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 585     if (!success)
 586     {
 587         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 588         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 589         mErrorMsg = "Cannot create reply!";
 590     }
 591 }
 592
 593 void CAmRoutingDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 594 {
 595     DBusMessageIter structIter;
 596     dbus_bool_t success = true;
 597     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 598     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 599     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 600     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 601     if (!success)
 602     {
 603         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 604         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 605         mErrorMsg = "Cannot create reply!";
 606     }
 607 }
 608
 609 void CAmRoutingDbusMessageHandler::append(const am::am_Availability_s& availability)
 610 {
 611     DBusMessageIter structAvailIter;
 612     dbus_bool_t success = true;
 613     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 614     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 615     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 616     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 617     if (!success)
 618     {
 619         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 620         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 621         mErrorMsg = "Cannot create reply!";
 622     }
 623 }
 624
 625 void CAmRoutingDbusMessageHandler::append(const am::am_SystemProperty_s& SystemProperty)
 626 {
 627     DBusMessageIter structIter;
 628     dbus_bool_t success = true;
 629     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 630     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 631     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 632     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 633     if (!success)
 634     {
 635         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 636         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 637         mErrorMsg = "Cannot create reply!";
 638     }
 639 }
 640
 641 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 642 {
 643     DBusMessageIter arrayIter;
 644     DBusMessageIter structIter;
 645     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator = listMainConnections.begin();
 646     dbus_bool_t success = true;
 647     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 648     for (; listIterator < listMainConnections.end(); ++listIterator)
 649     {
 650         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 651         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 652         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 653         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 654         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 655         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 656         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 657     }
 658     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 659     if (!success)
 660     {
 661         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 662         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 663         mErrorMsg = "Cannot create reply!";
 664     }
 665 }
 666
 667 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkType_s>& listMainSinks)
 668 {
 669     DBusMessageIter arrayIter;
 670     DBusMessageIter structIter;
 671     DBusMessageIter availIter;
 672     std::vector<am::am_SinkType_s>::const_iterator listIterator = listMainSinks.begin();
 673     dbus_bool_t success = true;
 674     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 675     for (; listIterator < listMainSinks.end(); ++listIterator)
 676     {
 677         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 678         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 679         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 680         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 681         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 682         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 683         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 684         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 685         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 686         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 687         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 688     }
 689     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 690     if (!success)
 691     {
 692         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 693         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 694         mErrorMsg = "Cannot create reply!";
 695     }
 696 }
 697
 698 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceType_s>& listMainSources)
 699 {
 700     DBusMessageIter arrayIter;
 701     DBusMessageIter structIter;
 702     DBusMessageIter availIter;
 703     std::vector<am::am_SourceType_s>::const_iterator listIterator = listMainSources.begin();
 704     dbus_bool_t success = true;
 705     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 706     for (; listIterator < listMainSources.end(); ++listIterator)
 707     {
 708         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 709         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 710         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 711         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 712         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 713         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 714         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 715         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 716         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 717     }
 718     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 719     if (!success)
 720     {
 721         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 722         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 723         mErrorMsg = "Cannot create reply!";
 724     }
 725 }
 726
 727 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s>& listMainSoundProperties)
 728 {
 729     DBusMessageIter arrayIter;
 730     DBusMessageIter structIter;
 731     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator = listMainSoundProperties.begin();
 732     dbus_bool_t success = true;
 733     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 734     for (; listIterator < listMainSoundProperties.end(); ++listIterator)
 735     {
 736         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 737         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 738         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 739         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 740     }
 741     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 742     if (!success)
 743     {
 744         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 745         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 746         mErrorMsg = "Cannot create reply!";
 747     }
 748 }
 749
 750 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceClass_s>& listSourceClasses)
 751 {
 752     DBusMessageIter arrayIter;
 753     DBusMessageIter structIter;
 754     DBusMessageIter propIter;
 755     DBusMessageIter innerIter;
 756     std::vector<am::am_SourceClass_s>::const_iterator listIterator = listSourceClasses.begin();
 757     dbus_bool_t success = true;
 758     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 759     for (; listIterator < listSourceClasses.end(); ++listIterator)
 760     {
 761         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 762         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 763         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 764         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 765
 766         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 767         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 768         {
 769             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 770             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 771             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 772             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 773         }
 774         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 775         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 776     }
 777     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 778     if (!success)
 779     {
 780         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 781         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 782         mErrorMsg = "Cannot create reply!";
 783     }
 784 }
 785
 786 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkClass_s>& listSinkClasses)
 787 {
 788     DBusMessageIter arrayIter;
 789     DBusMessageIter structIter;
 790     DBusMessageIter propIter;
 791     DBusMessageIter innerIter;
 792     std::vector<am::am_SinkClass_s>::const_iterator listIterator = listSinkClasses.begin();
 793     dbus_bool_t success = true;
 794     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 795     for (; listIterator < listSinkClasses.end(); ++listIterator)
 796     {
 797         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 798         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 799         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 800         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 801
 802         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 803         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 804         {
 805             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 806             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 807             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 808             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 809         }
 810         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 811         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 812     }
 813     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 814     if (!success)
 815     {
 816         {
 817             log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 818             mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 819             mErrorMsg = "Cannot create reply!";
 820         }
 821     }
 822 }
 823
 824 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s>& listSystemProperties)
 825 {
 826     DBusMessageIter arrayIter;
 827     DBusMessageIter structIter;
 828     std::vector<am::am_SystemProperty_s>::const_iterator listIterator = listSystemProperties.begin();
 829     dbus_bool_t success = true;
 830     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 831     for (; listIterator < listSystemProperties.end(); ++listIterator)
 832     {
 833         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 834         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 835         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 836         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 837     }
 838     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 839     if (!success)
 840     {
 841         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 842         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 843         mErrorMsg = "Cannot create reply!";
 844     }
 845 }
 846
 847 void CAmRoutingDbusMessageHandler::append(const am::am_Error_e error)
 848 {
 849     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &error))
 850     {
 851         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 852         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 853         mErrorMsg = "Cannot create reply!";
 854     }
 855 }
 856
 857 }
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870