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     //CAmDltWrapper::instance()->registerContext(routingDbus, "DRS", "DBus Plugin");
  44     log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler constructed");
  45 }
  46
  47 CAmRoutingDbusMessageHandler::~CAmRoutingDbusMessageHandler()
  48 {
  49     log(&routingDbus, DLT_LOG_INFO, "DBUSMessageHandler destructed");
  50 }
  51
  52 void CAmRoutingDbusMessageHandler::initReceive(DBusMessage* msg)
  53 {
  54     assert(msg!=NULL);
  55     mpReveiveMessage = msg;
  56     if (!dbus_message_iter_init(msg, &mDBusMessageIter))
  57     {
  58         log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler::initReceive DBus Message has no arguments!");
  59         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
  60         mErrorMsg = "DBUS Message has no arguments!";
  61     }
  62 }
  63
  64 void CAmRoutingDbusMessageHandler::initReply(DBusMessage* msg)
  65 {
  66     assert(msg!=NULL);
  67     mpDBusMessage = dbus_message_new_method_return(msg);
  68     if (mpDBusMessage == NULL)
  69     {
  70         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initReply Cannot allocate DBus message!");
  71         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
  72         mErrorMsg = "Cannot create reply!";
  73     }
  74     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  75 }
  76
  77 void CAmRoutingDbusMessageHandler::initSignal(std::string path, std::string signalName)
  78 {
  79     assert(!path.empty());
  80     assert(!signalName.empty());
  81     std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
  82         std::string completeInterface = std::string(DBUS_SERVICE_PREFIX) + "." + ROUTING_NODE;
  83     mpDBusMessage = dbus_message_new_signal(completePath.c_str(), completeInterface.c_str(), signalName.c_str());
  84
  85     if (mpDBusMessage == NULL)
  86     {
  87         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initSignal Cannot allocate DBus message!");
  88     }
  89     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  90 }
  91
  92 void CAmRoutingDbusMessageHandler::sendMessage()
  93 {
  94     assert(mpDBusConnection!=NULL);
  95     if (mpReveiveMessage != 0)
  96     {
  97         mSerial = dbus_message_get_serial(mpReveiveMessage);
  98     }
  99     else
 100     {
 101         mSerial = 1;
 102     }
 103     if (!mErrorName.empty())
 104     {
 105         mpDBusMessage = dbus_message_new_error(mpReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
 106     }
 107     if (!dbus_connection_send(mpDBusConnection, mpDBusMessage, &mSerial))
 108     {
 109         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::sendMessage cannot send message!");
 110     }
 111     dbus_connection_flush(mpDBusConnection);
 112     dbus_message_unref(mpDBusMessage);
 113     mpDBusMessage = NULL;
 114 }
 115
 116 char* CAmRoutingDbusMessageHandler::getString(DBusMessageIter& iter, bool next)
 117 {
 118     char* param = NULL;
 119
 120     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&iter))
 121     {
 122         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getString DBUS handler argument is no String!");
 123         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 124         mErrorMsg = "DBus argument is no string";
 125     }
 126     else
 127     {
 128         dbus_message_iter_get_basic(&iter, &param);
 129         if (next)
 130             dbus_message_iter_next(&iter);
 131     }
 132     return (param);
 133 }
 134
 135 char* CAmRoutingDbusMessageHandler::getString()
 136 {
 137     return (getString(mDBusMessageIter, true));
 138 }
 139
 140 dbus_bool_t CAmRoutingDbusMessageHandler::getBool(DBusMessageIter& iter, bool next)
 141 {
 142     dbus_bool_t boolparam = false;
 143
 144     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&iter))
 145     {
 146         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no bool!");
 147         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 148         mErrorMsg = "DBus argument is no bool";
 149     }
 150     else
 151     {
 152         dbus_message_iter_get_basic(&iter, &boolparam);
 153         if (next)
 154             dbus_message_iter_next(&iter);
 155     }
 156     return (boolparam);
 157 }
 158
 159 dbus_bool_t CAmRoutingDbusMessageHandler::getBool()
 160 {
 161     return (getBool(mDBusMessageIter, true));
 162 }
 163
 164 char CAmRoutingDbusMessageHandler::getByte(DBusMessageIter& iter, bool next)
 165 {
 166     char param(0);
 167
 168     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&iter))
 169     {
 170         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getByte DBUS handler argument is no byte!");
 171         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 172         mErrorMsg = "DBus argument is no byte";
 173     }
 174     else
 175     {
 176         dbus_message_iter_get_basic(&iter, &param);
 177         if (next)
 178             dbus_message_iter_next(&iter);
 179     }
 180     return (param);
 181 }
 182
 183 char CAmRoutingDbusMessageHandler::getByte()
 184 {
 185     return (getByte(mDBusMessageIter, true));
 186 }
 187
 188 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt(DBusMessageIter& iter, bool next)
 189 {
 190     dbus_uint16_t param(0);
 191 #ifdef GLIB_DBUS_TYPES_TOLERANT
 192     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&iter))
 193 #else
 194     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter))
 195 #endif
 196     {
 197         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!");
 198         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 199         mErrorMsg = "DBus argument is no uint16_t";
 200     }
 201     else
 202     {
 203         dbus_message_iter_get_basic(&iter, &param);
 204         if (next)
 205             dbus_message_iter_next(&iter);
 206     }
 207     return (param);
 208 }
 209
 210 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt()
 211 {
 212     return (getUInt(mDBusMessageIter, true));
 213 }
 214
 215 dbus_int16_t CAmRoutingDbusMessageHandler::getInt(DBusMessageIter& iter, bool next)
 216 {
 217     dbus_int16_t param(0);
 218 #ifdef GLIB_DBUS_TYPES_TOLERANT
 219     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
 220 #else
 221     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter))
 222 #endif
 223     {
 224         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int16_t!");
 225         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 226         mErrorMsg = "DBus argument is no int16_t";
 227     }
 228     else
 229     {
 230         dbus_message_iter_get_basic(&iter, &param);
 231         if (next)
 232             dbus_message_iter_next(&iter);
 233     }
 234     return (param);
 235 }
 236
 237 dbus_int16_t CAmRoutingDbusMessageHandler::getInt()
 238 {
 239     return (getInt(mDBusMessageIter, true));
 240 }
 241
 242 double CAmRoutingDbusMessageHandler::getDouble(DBusMessageIter& iter, bool next)
 243 {
 244     double param(0);
 245     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&iter))
 246     {
 247         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getDouble DBUS handler argument is no double!");
 248         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 249         mErrorMsg = "DBus argument is no double";
 250     }
 251     else
 252     {
 253         dbus_message_iter_get_basic(&iter, &param);
 254         if (next)
 255             dbus_message_iter_next(&iter);
 256     }
 257     return (param);
 258 }
 259
 260 double CAmRoutingDbusMessageHandler::getDouble()
 261 {
 262     return (getDouble(mDBusMessageIter, true));
 263 }
 264
 265 am_Availability_s CAmRoutingDbusMessageHandler::getAvailability()
 266 {
 267     am::am_Availability_s availability;
 268     availability.availability=A_UNKNOWN;
 269     availability.availabilityReason=AR_UNKNOWN;
 270     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 271     {
 272         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getAvailability DBUS handler argument is no struct!");
 273         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 274         mErrorMsg = "DBus argument is no struct";
 275     }
 276     else
 277     {
 278         DBusMessageIter structIter;
 279         dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
 280         availability.availability = static_cast<am_Availability_e>(getInt(structIter, true));
 281         availability.availabilityReason = static_cast<am_CustomAvailabilityReason_t>(getInt(structIter, false));
 282         dbus_message_iter_next(&mDBusMessageIter);
 283     }
 284     return (availability);
 285 }
 286
 287 std::vector<am_EarlyData_s> CAmRoutingDbusMessageHandler::getEarlyData()
 288 {
 289     std::vector<am_EarlyData_s> listEarlyData;
 290     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 291     {
 292         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getProperty DBUS handler argument is no array!");
 293         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 294         mErrorMsg = "DBus argument is no array";
 295     }
 296     else
 297     {
 298         DBusMessageIter arrayIter, structIter, soundpropIter;
 299         am_EarlyData_s earlyData;
 300
 301         //first the volume array
 302         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 303         do
 304         {
 305             dbus_message_iter_recurse(&arrayIter, &structIter);
 306             earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
 307             if (earlyData.type==ED_SINK_VOLUME)
 308                 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
 309             else
 310                 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
 311             earlyData.data.volume = static_cast<am_volume_t>(getInt(structIter, false));
 312             listEarlyData.push_back(earlyData);
 313         } while (dbus_message_iter_next(&arrayIter));
 314         dbus_message_iter_next(&mDBusMessageIter);
 315
 316         //then the soundproperty array
 317         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 318         do
 319         {
 320             dbus_message_iter_recurse(&arrayIter, &structIter);
 321             earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
 322             if (earlyData.type==ED_SINK_PROPERTY)
 323                 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
 324             else
 325                 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
 326             dbus_message_iter_recurse(&structIter, &soundpropIter);
 327             earlyData.data.soundProperty.type = static_cast<am_CustomSoundPropertyType_t>(getInt(soundpropIter, true));
 328             earlyData.data.soundProperty.value = (getInt(soundpropIter, false));
 329             listEarlyData.push_back(earlyData);
 330         } while (dbus_message_iter_next(&arrayIter));
 331     }
 332     return (listEarlyData);
 333 }
 334
 335 am_Domain_s CAmRoutingDbusMessageHandler::getDomainData()
 336 {
 337     am_Domain_s domainData;
 338     DBusMessageIter domainDataIter;
 339
 340     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 341     {
 342         log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getDomainData DBUS handler argument is no struct!");
 343         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 344         mErrorMsg = "DBus argument is no struct";
 345     }
 346     else
 347     {
 348         dbus_message_iter_recurse(&mDBusMessageIter, &domainDataIter);
 349         domainData.domainID = static_cast<am_domainID_t>(getUInt(domainDataIter, true));
 350         domainData.name = getString(domainDataIter, true);
 351         domainData.busname = getString(domainDataIter, true);
 352         domainData.nodename = getString(domainDataIter, true);
 353         domainData.early = getBool(domainDataIter, true);
 354         domainData.complete = getBool(domainDataIter, true);
 355         domainData.state = static_cast<am_DomainState_e>(getInt(domainDataIter, false));
 356         dbus_message_iter_next(&mDBusMessageIter);
 357     }
 358     return (domainData);
 359 }
 360
 361 am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
 362 {
 363     am_Source_s sourceData;
 364     DBusMessageIter sourceDataIter, availIter, arrayIter, structIter;
 365     am_SoundProperty_s soundProperty;
 366     am_CustomAvailabilityReason_t connectionFormat;
 367     am_MainSoundProperty_s mainSoundProperty;
 368     am_NotificationConfiguration_s notificationConfiguration;
 369     am_NotificationConfiguration_s MainnotificationConfiguration;
 370
 371     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 372     {
 373         log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getSourceData DBUS handler argument is no struct!");
 374         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 375         mErrorMsg = "DBus argument is no struct";
 376     }
 377     else
 378     {
 379         dbus_message_iter_recurse(&mDBusMessageIter, &sourceDataIter);
 380         sourceData.sourceID = static_cast<am_sourceID_t>(getUInt(sourceDataIter, true));
 381         sourceData.domainID = static_cast<am_domainID_t>(getUInt(sourceDataIter, true));
 382         sourceData.name = getString(sourceDataIter, true);
 383         sourceData.sourceClassID = static_cast<am_sourceClass_t>(getUInt(sourceDataIter, true));
 384         sourceData.sourceState = static_cast<am_SourceState_e>(getInt32(sourceDataIter, true));
 385         sourceData.volume = static_cast<am_volume_t>(getInt(sourceDataIter, true));
 386         sourceData.visible = getBool(sourceDataIter, true);
 387         dbus_message_iter_recurse(&sourceDataIter, &availIter);
 388         sourceData.available.availability = static_cast<am_Availability_e>(getInt32(availIter, true));
 389         sourceData.available.availabilityReason = static_cast<am_CustomAvailabilityReason_t>(getInt32(availIter, false));
 390         dbus_message_iter_next(&sourceDataIter);
 391         sourceData.interruptState = static_cast<am_InterruptState_e>(getUInt(sourceDataIter, true));
 392         dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
 393         do
 394         {
 395             dbus_message_iter_recurse(&arrayIter, &structIter);
 396             soundProperty.type = static_cast<am_CustomSoundPropertyType_t>(getInt32(structIter, true));
 397             soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 398             sourceData.listSoundProperties.push_back(soundProperty);
 399         } while (dbus_message_iter_next(&arrayIter));
 400         dbus_message_iter_next(&sourceDataIter);
 401         dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
 402         do
 403         {
 404             connectionFormat = static_cast<am_CustomAvailabilityReason_t>(getInt32(arrayIter, false));
 405             sourceData.listConnectionFormats.push_back(connectionFormat);
 406         } while (dbus_message_iter_next(&arrayIter));
 407         dbus_message_iter_next(&sourceDataIter);
 408
 409         dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
 410         do
 411         {
 412             dbus_message_iter_recurse(&arrayIter, &structIter);
 413             mainSoundProperty.type = static_cast<am_CustomMainSoundPropertyType_t>(getInt32(structIter, true));
 414             mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 415             sourceData.listMainSoundProperties.push_back(mainSoundProperty);
 416         } while (dbus_message_iter_next(&arrayIter));
 417         dbus_message_iter_next(&sourceDataIter);
 418
 419     dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
 420     do
 421     {
 422         dbus_message_iter_recurse(&arrayIter, &structIter);
 423         MainnotificationConfiguration.type = static_cast<am_CustomNotificationType_t>(getInt32(structIter, true));
 424         MainnotificationConfiguration.parameter = static_cast<int16_t>(getInt32(structIter, false));
 425         MainnotificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt(structIter, true));
 426         sourceData.listMainNotificationConfigurations.push_back(MainnotificationConfiguration);
 427     } while (dbus_message_iter_next(&arrayIter));
 428         dbus_message_iter_next(&sourceDataIter);
 429
 430     dbus_message_iter_recurse(&sourceDataIter, &arrayIter);
 431     do
 432     {
 433         dbus_message_iter_recurse(&arrayIter, &structIter);
 434         notificationConfiguration.type = static_cast<am_CustomNotificationType_t>(getInt32(structIter, true));
 435         notificationConfiguration.parameter = static_cast<int16_t>(getInt32(structIter, false));
 436         notificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt(structIter, true));
 437         sourceData.listNotificationConfigurations.push_back(notificationConfiguration);
 438     } while (dbus_message_iter_next(&arrayIter));
 439         dbus_message_iter_next(&mDBusMessageIter);
 440     }
 441     return (sourceData);
 442 }
 443
 444 am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
 445 {
 446     am_Sink_s sinkData;
 447     DBusMessageIter sinkDataIter, structIter, availIter, arrayIter;
 448     am_SoundProperty_s soundProperty;
 449     am_CustomAvailabilityReason_t connectionFormat;
 450     am_MainSoundProperty_s mainSoundProperty;
 451     am_NotificationConfiguration_s notificationConfiguration;
 452     am_NotificationConfiguration_s MainnotificationConfiguration;
 453
 454     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 455     {
 456         log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getSinkData DBUS handler argument is no struct!");
 457         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 458         mErrorMsg = "DBus argument is no struct";
 459     }
 460     else
 461     {
 462         dbus_message_iter_recurse(&mDBusMessageIter, &sinkDataIter);
 463         sinkData.sinkID = static_cast<am_sinkID_t>(getUInt(sinkDataIter, true));
 464         sinkData.name = getString(sinkDataIter, true);
 465         sinkData.domainID = static_cast<am_domainID_t>(getUInt(sinkDataIter, true));
 466         sinkData.sinkClassID = static_cast<am_sinkClass_t>(getInt32(sinkDataIter, true));
 467         sinkData.volume = static_cast<am_volume_t>(getInt(sinkDataIter, true));
 468         sinkData.visible = getBool(sinkDataIter, true);
 469         dbus_message_iter_recurse(&sinkDataIter, &availIter);
 470         sinkData.available.availability = static_cast<am_Availability_e>(getInt32(availIter, true));
 471         sinkData.available.availabilityReason = static_cast<am_CustomAvailabilityReason_t>(getInt32(availIter, false));
 472         dbus_message_iter_next(&sinkDataIter);
 473         sinkData.muteState = static_cast<am_MuteState_e>(getInt(sinkDataIter, true));
 474         sinkData.mainVolume = static_cast<am_mainVolume_t>(getInt(sinkDataIter, true));
 475
 476         dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
 477         do
 478         {
 479             dbus_message_iter_recurse(&arrayIter, &structIter);
 480             soundProperty.type = static_cast<am_CustomSoundPropertyType_t>(getInt32(structIter, true));
 481             soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 482             sinkData.listSoundProperties.push_back(soundProperty);
 483         } while (dbus_message_iter_next(&arrayIter));
 484
 485         dbus_message_iter_next(&sinkDataIter);
 486
 487         dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
 488         do
 489         {
 490             connectionFormat = static_cast<am_CustomAvailabilityReason_t>(getInt32(arrayIter, false));
 491             sinkData.listConnectionFormats.push_back(connectionFormat);
 492         } while (dbus_message_iter_next(&arrayIter));
 493         dbus_message_iter_next(&sinkDataIter);
 494
 495     dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
 496     do
 497     {
 498         dbus_message_iter_recurse(&arrayIter, &structIter);
 499         mainSoundProperty.type = static_cast<am_CustomMainSoundPropertyType_t>(getInt32(structIter, true));
 500         mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 501         sinkData.listMainSoundProperties.push_back(mainSoundProperty);
 502     } while (dbus_message_iter_next(&arrayIter));
 503         dbus_message_iter_next(&sinkDataIter);
 504
 505     dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
 506     do
 507     {
 508         dbus_message_iter_recurse(&arrayIter, &structIter);
 509         MainnotificationConfiguration.type = static_cast<am_CustomNotificationType_t>(getInt32(structIter, true));
 510         MainnotificationConfiguration.parameter = static_cast<int16_t>(getInt32(structIter, false));
 511         MainnotificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt(structIter, true));
 512         sinkData.listMainNotificationConfigurations.push_back(MainnotificationConfiguration);
 513     } while (dbus_message_iter_next(&arrayIter));
 514         dbus_message_iter_next(&sinkDataIter);
 515
 516     dbus_message_iter_recurse(&sinkDataIter, &arrayIter);
 517     do
 518     {
 519         dbus_message_iter_recurse(&arrayIter, &structIter);
 520         notificationConfiguration.type = static_cast<am_CustomNotificationType_t>(getInt32(structIter, true));
 521         notificationConfiguration.parameter = static_cast<int16_t>(getInt32(structIter, false));
 522         notificationConfiguration.status = static_cast<am_NotificationStatus_e>(getInt(structIter, true));
 523         sinkData.listNotificationConfigurations.push_back(notificationConfiguration);
 524     } while (dbus_message_iter_next(&arrayIter));
 525         dbus_message_iter_next(&mDBusMessageIter);
 526     }
 527     return (sinkData);
 528 }
 529
 530 am_Gateway_s CAmRoutingDbusMessageHandler::getGatewayData()
 531 {
 532     am_Gateway_s gatewayData;
 533     DBusMessageIter gatewayDataIter, arrayIter;
 534     am_CustomAvailabilityReason_t connectionFormat;
 535     bool convertion;
 536     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 537     {
 538         log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getDomainData DBUS handler argument is no struct!");
 539         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 540         mErrorMsg = "DBus argument is no struct";
 541     }
 542     else
 543     {
 544         dbus_message_iter_recurse(&mDBusMessageIter, &gatewayDataIter);
 545         gatewayData.gatewayID = static_cast<am_gatewayID_t>(getUInt(gatewayDataIter, true));
 546         gatewayData.name = getString(gatewayDataIter, true);
 547         gatewayData.sinkID = static_cast<am_sinkID_t>(getUInt(gatewayDataIter, true));
 548         gatewayData.sourceID = static_cast<am_sourceID_t>(getUInt(gatewayDataIter, true));
 549         gatewayData.domainSinkID = static_cast<am_domainID_t>(getUInt(gatewayDataIter, true));
 550         gatewayData.domainSourceID = static_cast<am_domainID_t>(getUInt(gatewayDataIter, true));
 551         gatewayData.controlDomainID = static_cast<am_domainID_t>(getUInt(gatewayDataIter, true));
 552     dbus_message_iter_recurse(&gatewayDataIter, &arrayIter);
 553         do
 554         {
 555             connectionFormat = static_cast<am_CustomAvailabilityReason_t>(getInt32(arrayIter, false));
 556             gatewayData.listSourceFormats.push_back(connectionFormat);
 557         } while (dbus_message_iter_next(&arrayIter));
 558         dbus_message_iter_next(&gatewayDataIter);
 559     dbus_message_iter_recurse(&gatewayDataIter, &arrayIter);
 560         do
 561         {
 562             connectionFormat = static_cast<am_CustomAvailabilityReason_t>(getInt32(arrayIter, false));
 563             gatewayData.listSinkFormats.push_back(connectionFormat);
 564         } while (dbus_message_iter_next(&arrayIter));
 565         dbus_message_iter_next(&gatewayDataIter);
 566     dbus_message_iter_recurse(&gatewayDataIter, &arrayIter);
 567         do
 568         {
 569             convertion = getBool(arrayIter, false);
 570             gatewayData.convertionMatrix.push_back(convertion);
 571         } while (dbus_message_iter_next(&arrayIter));
 572         dbus_message_iter_next(&mDBusMessageIter);
 573     }
 574     return (gatewayData);
 575 }
 576
 577 am_Crossfader_s CAmRoutingDbusMessageHandler::getCrossfaderData()
 578 {
 579     am_Crossfader_s crossfaderData;
 580     DBusMessageIter crossfaderDataIter;
 581
 582     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 583     {
 584         log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getCrossfaderData DBUS handler argument is no struct!");
 585         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 586         mErrorMsg = "DBus argument is no struct";
 587     }
 588     else
 589     {
 590         dbus_message_iter_recurse(&mDBusMessageIter, &crossfaderDataIter);
 591         crossfaderData.crossfaderID = static_cast<am_crossfaderID_t> (getUInt(crossfaderDataIter, true));
 592         crossfaderData.name = static_cast<std::string> (getString(crossfaderDataIter, true));
 593         crossfaderData.sinkID_A = static_cast<am_sinkID_t> (getUInt(crossfaderDataIter, true));
 594         crossfaderData.sinkID_B = static_cast<am_sinkID_t> (getUInt(crossfaderDataIter, true));
 595         crossfaderData.sourceID = static_cast<am_sourceID_t> (getUInt(crossfaderDataIter, true));
 596         crossfaderData.hotSink = static_cast<am_HotSink_e> (getUInt(crossfaderDataIter, false));
 597         dbus_message_iter_next(&mDBusMessageIter);
 598     }
 599     return (crossfaderData);
 600 }
 601
 602 am_MainSoundProperty_s CAmRoutingDbusMessageHandler::getMainSoundProperty()
 603 {
 604     am_MainSoundProperty_s mainSoundProperty;
 605     DBusMessageIter structIter;
 606
 607     dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
 608     mainSoundProperty.type = static_cast<am_CustomMainSoundPropertyType_t>(getInt(structIter, true));
 609     mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
 610     dbus_message_iter_next(&mDBusMessageIter);
 611
 612     return (mainSoundProperty);
 613 }
 614
 615 void CAmRoutingDbusMessageHandler::append(bool toAppend)
 616 {
 617     dbus_bool_t mybool = toAppend;
 618     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 619     {
 620         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 621         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 622         mErrorMsg = "Cannot create reply!";
 623     }
 624 }
 625
 626 void CAmRoutingDbusMessageHandler::append(double toAppend)
 627 {
 628     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 629     {
 630         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 631         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 632         mErrorMsg = "Cannot create reply!";
 633     }
 634 }
 635
 636 void CAmRoutingDbusMessageHandler::append(char toAppend)
 637 {
 638     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 639     {
 640         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 641         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 642         mErrorMsg = "Cannot create reply!";
 643     }
 644 }
 645
 646 void CAmRoutingDbusMessageHandler::append(dbus_int16_t toAppend)
 647 {
 648     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
 649     {
 650         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 651         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 652         mErrorMsg = "Cannot create reply!";
 653     }
 654 }
 655
 656 void CAmRoutingDbusMessageHandler::append(dbus_uint16_t toAppend)
 657 {
 658     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 659     {
 660         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 661         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 662         mErrorMsg = "Cannot create reply!";
 663     }
 664 }
 665
 666 void CAmRoutingDbusMessageHandler::setDBusConnection(DBusConnection*& connection)
 667 {
 668     assert(connection != NULL);
 669     mpDBusConnection = connection;
 670 }
 671
 672 void CAmRoutingDbusMessageHandler::append(const am::am_SinkType_s& sinkType)
 673 {
 674     DBusMessageIter structIter;
 675     DBusMessageIter structAvailIter;
 676     dbus_bool_t success = true;
 677     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 678     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 679     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 680     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 681     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 682     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 683     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 684     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 685     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 686     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 687     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 688     if (!success)
 689     {
 690         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 691         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 692         mErrorMsg = "Cannot create reply!";
 693     }
 694 }
 695
 696 void CAmRoutingDbusMessageHandler::append(const am::am_SourceType_s& sourceType)
 697 {
 698     DBusMessageIter structIter;
 699     DBusMessageIter structAvailIter;
 700     dbus_bool_t success = true;
 701     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 702     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 703     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 704     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 705     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 706     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 707     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 708     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 709     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 710     if (!success)
 711     {
 712         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 713         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 714         mErrorMsg = "Cannot create reply!";
 715     }
 716 }
 717
 718 void CAmRoutingDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 719 {
 720     DBusMessageIter structIter;
 721     dbus_bool_t success = true;
 722     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 723     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 724     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 725     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 726     if (!success)
 727     {
 728         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 729         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 730         mErrorMsg = "Cannot create reply!";
 731     }
 732 }
 733
 734 void CAmRoutingDbusMessageHandler::append(const am::am_Availability_s& availability)
 735 {
 736     DBusMessageIter structAvailIter;
 737     dbus_bool_t success = true;
 738     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 739     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 740     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 741     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 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 am::am_SystemProperty_s& SystemProperty)
 751 {
 752     DBusMessageIter structIter;
 753     dbus_bool_t success = true;
 754     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 755     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 756     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 757     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 758     if (!success)
 759     {
 760         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 761         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 762         mErrorMsg = "Cannot create reply!";
 763     }
 764 }
 765
 766 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 767 {
 768     DBusMessageIter arrayIter;
 769     DBusMessageIter structIter;
 770     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator = listMainConnections.begin();
 771     dbus_bool_t success = true;
 772     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 773     for (; listIterator < listMainConnections.end(); ++listIterator)
 774     {
 775         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 776         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 777         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 778         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 779         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 780         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 781         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 782     }
 783     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 784     if (!success)
 785     {
 786         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 787         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 788         mErrorMsg = "Cannot create reply!";
 789     }
 790 }
 791
 792 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkType_s>& listMainSinks)
 793 {
 794     DBusMessageIter arrayIter;
 795     DBusMessageIter structIter;
 796     DBusMessageIter availIter;
 797     std::vector<am::am_SinkType_s>::const_iterator listIterator = listMainSinks.begin();
 798     dbus_bool_t success = true;
 799     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 800     for (; listIterator < listMainSinks.end(); ++listIterator)
 801     {
 802         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 803         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 804         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 805         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 806         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 807         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 808         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 809         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 810         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 811         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 812         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 813     }
 814     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 815     if (!success)
 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 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceType_s>& listMainSources)
 824 {
 825     DBusMessageIter arrayIter;
 826     DBusMessageIter structIter;
 827     DBusMessageIter availIter;
 828     std::vector<am::am_SourceType_s>::const_iterator listIterator = listMainSources.begin();
 829     dbus_bool_t success = true;
 830     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 831     for (; listIterator < listMainSources.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_UINT16, &listIterator->sourceID);
 835         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 836         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 837         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 838         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 839         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 840         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 841         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 842     }
 843     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 844     if (!success)
 845     {
 846         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 847         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 848         mErrorMsg = "Cannot create reply!";
 849     }
 850 }
 851
 852 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s>& listMainSoundProperties)
 853 {
 854     DBusMessageIter arrayIter;
 855     DBusMessageIter structIter;
 856     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator = listMainSoundProperties.begin();
 857     dbus_bool_t success = true;
 858     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 859     for (; listIterator < listMainSoundProperties.end(); ++listIterator)
 860     {
 861         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 862         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 863         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 864         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 865     }
 866     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 867     if (!success)
 868     {
 869         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 870         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 871         mErrorMsg = "Cannot create reply!";
 872     }
 873 }
 874
 875 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceClass_s>& listSourceClasses)
 876 {
 877     DBusMessageIter arrayIter;
 878     DBusMessageIter structIter;
 879     DBusMessageIter propIter;
 880     DBusMessageIter innerIter;
 881     std::vector<am::am_SourceClass_s>::const_iterator listIterator = listSourceClasses.begin();
 882     dbus_bool_t success = true;
 883     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 884     for (; listIterator < listSourceClasses.end(); ++listIterator)
 885     {
 886         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 887         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 888         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 889         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 890
 891         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 892         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 893         {
 894             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 895             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 896             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 897             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 898         }
 899         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 900         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 901     }
 902     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 903     if (!success)
 904     {
 905         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 906         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 907         mErrorMsg = "Cannot create reply!";
 908     }
 909 }
 910
 911 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkClass_s>& listSinkClasses)
 912 {
 913     DBusMessageIter arrayIter;
 914     DBusMessageIter structIter;
 915     DBusMessageIter propIter;
 916     DBusMessageIter innerIter;
 917     std::vector<am::am_SinkClass_s>::const_iterator listIterator = listSinkClasses.begin();
 918     dbus_bool_t success = true;
 919     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 920     for (; listIterator < listSinkClasses.end(); ++listIterator)
 921     {
 922         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 923         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 924         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 925         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 926
 927         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 928         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 929         {
 930             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 931             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 932             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 933             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 934         }
 935         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 936         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 937     }
 938     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 939     if (!success)
 940     {
 941         {
 942             log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 943             mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 944             mErrorMsg = "Cannot create reply!";
 945         }
 946     }
 947 }
 948
 949 std::vector<am_CustomAvailabilityReason_t> CAmRoutingDbusMessageHandler::getListconnectionFormats()
 950 {
 951     DBusMessageIter arrayIter;
 952     std::vector<am_CustomAvailabilityReason_t> listConnectionFormats;
 953     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 954        {
 955            log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListconnectionFormats DBUS handler argument is no array!");
 956            mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 957            mErrorMsg = "DBus argument is no array";
 958        }
 959    else
 960    {
 961        dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 962        do
 963        {
 964            am_CustomAvailabilityReason_t connectionformat(static_cast<am_CustomAvailabilityReason_t>(getUInt(arrayIter, false)));
 965            listConnectionFormats.push_back(connectionformat);
 966        } while (dbus_message_iter_next(&arrayIter));
 967        dbus_message_iter_next(&mDBusMessageIter);
 968    }
 969    return (listConnectionFormats);
 970
 971 }
 972
 973 std::vector<bool> CAmRoutingDbusMessageHandler::getListBool()
 974 {
 975     DBusMessageIter arrayIter;
 976     std::vector<bool> listBools;
 977     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 978        {
 979            log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListBool DBUS handler argument is no array!");
 980            mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 981            mErrorMsg = "DBus argument is no array";
 982        }
 983    else
 984    {
 985        dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 986        do
 987        {
 988            bool myBool(static_cast<bool>(getBool(arrayIter, false)));
 989            listBools.push_back(myBool);
 990        } while (dbus_message_iter_next(&arrayIter));
 991        dbus_message_iter_next(&mDBusMessageIter);
 992    }
 993    return (listBools);
 994 }
 995
 996 am_SoundProperty_s CAmRoutingDbusMessageHandler::getSoundProperty()
 997 {
 998     am_SoundProperty_s soundProperty;
 999     DBusMessageIter structIter;
1000
1001     dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
1002     soundProperty.type = static_cast<am_CustomSoundPropertyType_t>(getInt(structIter, true));
1003     soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
1004     dbus_message_iter_next(&mDBusMessageIter);
1005
1006     return(soundProperty);
1007 }
1008
1009 std::vector<am_SoundProperty_s> CAmRoutingDbusMessageHandler::getListSoundProperties()
1010 {
1011     DBusMessageIter arrayIter;
1012     DBusMessageIter structIter;
1013     am_SoundProperty_s soundProperty;
1014     std::vector<am_SoundProperty_s> listSoundProperties;
1015     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
1016        {
1017            log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListSoundProperties DBUS handler argument is no array!");
1018            mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
1019            mErrorMsg = "DBus argument is no array";
1020        }
1021    else
1022    {
1023        dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
1024        do
1025        {
1026            dbus_message_iter_recurse(&arrayIter, &structIter);
1027            soundProperty.type = static_cast<am_CustomSoundPropertyType_t>(getInt(structIter, true));
1028            soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
1029            listSoundProperties.push_back(soundProperty);
1030        } while (dbus_message_iter_next(&arrayIter));
1031        dbus_message_iter_next(&structIter);
1032    }
1033    return (listSoundProperties);
1034 }
1035
1036 std::vector<am_MainSoundProperty_s> CAmRoutingDbusMessageHandler::getListMainSoundProperties()
1037 {
1038     DBusMessageIter arrayIter;
1039     DBusMessageIter structIter;
1040     am_MainSoundProperty_s soundProperty;
1041     std::vector<am_MainSoundProperty_s> listSoundProperties;
1042     if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
1043        {
1044            log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusMessageHandler::getListSoundProperties DBUS handler argument is no array!");
1045            mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
1046            mErrorMsg = "DBus argument is no array";
1047        }
1048    else
1049    {
1050        dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
1051        do
1052        {
1053            dbus_message_iter_recurse(&arrayIter, &structIter);
1054            soundProperty.type = static_cast<am_CustomMainSoundPropertyType_t>(getInt(structIter, true));
1055            soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
1056            listSoundProperties.push_back(soundProperty);
1057        } while (dbus_message_iter_next(&arrayIter));
1058        dbus_message_iter_next(&structIter);
1059    }
1060    return (listSoundProperties);
1061 }
1062
1063 am_NotificationPayload_s CAmRoutingDbusMessageHandler::getNotificationPayload()
1064 {
1065     am_NotificationPayload_s notificationPayload;
1066     DBusMessageIter structIter;
1067
1068     dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
1069     notificationPayload.type = static_cast<am_CustomNotificationType_t>(getInt(structIter, true));
1070     notificationPayload.value = static_cast<int16_t>(getInt(structIter, false));
1071     dbus_message_iter_next(&mDBusMessageIter);
1072
1073     return (notificationPayload);
1074 }
1075
1076 dbus_int32_t CAmRoutingDbusMessageHandler::getInt32()
1077 {
1078     return (getInt32(mDBusMessageIter, true));
1079 }
1080
1081 dbus_int32_t CAmRoutingDbusMessageHandler::getInt32(DBusMessageIter& iter, bool next)
1082 {
1083     dbus_int32_t param(0);
1084   #ifdef GLIB_DBUS_TYPES_TOLERANT
1085       if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
1086   #else
1087       if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
1088   #endif
1089       {
1090           log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int32_t!");
1091           mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
1092           mErrorMsg = "DBus argument is no int32_t";
1093       }
1094       else
1095       {
1096           dbus_message_iter_get_basic(&iter, &param);
1097           if (next)
1098               dbus_message_iter_next(&iter);
1099       }
1100       return (param);
1101 }
1102
1103 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s>& listSystemProperties)
1104 {
1105     DBusMessageIter arrayIter;
1106     DBusMessageIter structIter;
1107     std::vector<am::am_SystemProperty_s>::const_iterator listIterator = listSystemProperties.begin();
1108     dbus_bool_t success = true;
1109     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
1110     for (; listIterator < listSystemProperties.end(); ++listIterator)
1111     {
1112         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
1113         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
1114         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
1115         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
1116     }
1117     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
1118     if (!success)
1119     {
1120         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
1121         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
1122         mErrorMsg = "Cannot create reply!";
1123     }
1124 }
1125
1126 void CAmRoutingDbusMessageHandler::append(const am::am_Error_e error)
1127 {
1128     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &error))
1129     {
1130         log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
1131         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
1132         mErrorMsg = "Cannot create reply!";
1133     }
1134 }
1135
1136 }
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149