PluginCommandInterfaceDbus/src/DBusMessageHandler.cpp

   1 /**
   2  * Copyright (C) 2011, BMW AG
   3  *
   4  * GeniviAudioMananger DbusPlugin
   5  *
   6  * \file DBusMessageHandler.cpp
   7  *
   8  * \date 20-Oct-2011 3:42:04 PM
   9  * \author Christian Mueller (christian.ei.mueller@bmw.de)
  10  *
  11  * \section License
  12  * GNU Lesser General Public License, version 2.1, with special exception (GENIVI clause)
  13  * Copyright (C) 2011, BMW AG Christian Mueller  Christian.ei.mueller@bmw.de
  14  *
  15  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation.
  16  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License, version 2.1, for more details.
  17  * You should have received a copy of the GNU Lesser General Public License, version 2.1, along with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>.
  18  * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may also be applicable to programs even in cases in which the program is not a library in the technical sense.
  19  * Linking AudioManager statically or dynamically with other modules is making a combined work based on AudioManager. You may license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to license your linked modules under the GNU Lesser General Public License, version 2.1, you may use the program under the following exception.
  20  * As a special exception, the copyright holders of AudioManager give you permission to combine AudioManager with software programs or libraries that are released under any license unless such a combination is not permitted by the license of such a software program or library. You may copy and distribute such a system following the terms of the GNU Lesser General Public License, version 2.1, including this special exception, for AudioManager and the licenses of the other code concerned.
  21  * Note that people who make modified versions of AudioManager are not obligated to grant this special exception for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, version 2.1, gives permission to release a modified version without this exception; this exception also makes it possible to release a modified version which carries forward this exception.
  22  *
  23  * THIS CODE HAS BEEN GENERATED BY ENTERPRISE ARCHITECT GENIVI MODEL. PLEASE CHANGE ONLY IN ENTERPRISE ARCHITECT AND GENERATE AGAIN
  24  */
  25 #include <config.h>
  26 #include "DBusMessageHandler.h"
  27 #include "DBusCommandSender.h"
  28
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <vector>
  32
  33 using namespace am;
  34
  35 DLT_IMPORT_CONTEXT(DLT_CONTEXT)
  36
  37 DBusMessageHandler::DBusMessageHandler() :
  38         mDBusMessageIter(), //
  39         mDBusError(), //
  40         mSerial(0), //
  41         mErrorName(""), //
  42         mErrorMsg(""), //
  43         mDbusMessage(NULL), //
  44         mReveiveMessage(NULL), //
  45         mDBusConnection(NULL)
  46 {
  47     DLT_LOG(DLT_CONTEXT, DLT_LOG_INFO, DLT_STRING("DBUSMessageHandler constructed"));
  48 }
  49
  50 DBusMessageHandler::~DBusMessageHandler()
  51 {
  52     DLT_LOG(DLT_CONTEXT, DLT_LOG_INFO, DLT_STRING("DBUSMessageHandler destructed"));
  53 }
  54
  55 void DBusMessageHandler::initReceive(DBusMessage* msg)
  56 {
  57     assert(msg!=NULL);
  58     mReveiveMessage = msg;
  59     if (!dbus_message_iter_init(msg, &mDBusMessageIter))
  60     {
  61         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initReceive DBus Message has no arguments!"));
  62         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
  63         mErrorMsg = "DBUS Message has no arguments!";
  64     }
  65 }
  66
  67 void DBusMessageHandler::initReply(DBusMessage* msg)
  68 {
  69     assert(msg!=NULL);
  70     mDbusMessage = dbus_message_new_method_return(msg);
  71     if (mDbusMessage == NULL)
  72     {
  73         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initReply Cannot allocate DBus message!"));
  74         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
  75         mErrorMsg = "Cannot create reply!";
  76     }
  77     dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
  78 }
  79
  80 void DBusMessageHandler::initSignal(std::string path, std::string signalName)
  81 {
  82     assert(!path.empty());
  83     assert(!signalName.empty());
  84     std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
  85     mDbusMessage = dbus_message_new_signal(completePath.c_str(), DBUS_SERVICE_PREFIX, signalName.c_str());
  86
  87     if (mDbusMessage == NULL)
  88     {
  89         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initSignal Cannot allocate DBus message!"));
  90     }
  91     dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
  92 }
  93
  94 void DBusMessageHandler::sendMessage()
  95 {
  96     assert(mDBusConnection!=NULL);
  97     if (mReveiveMessage != 0)
  98     {
  99         mSerial = dbus_message_get_serial(mReveiveMessage);
 100     }
 101     else
 102     {
 103         mSerial = 1;
 104     }
 105     if (!mErrorName.empty())
 106     {
 107         mDbusMessage = dbus_message_new_error(mReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
 108     }
 109     if (!dbus_connection_send(mDBusConnection, mDbusMessage, &mSerial))
 110     {
 111         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::sendMessage cannot send message!"));
 112     }
 113     dbus_connection_flush(mDBusConnection);
 114     dbus_message_unref(mDbusMessage);
 115     mDbusMessage = NULL;
 116 }
 117
 118 char* DBusMessageHandler::getString()
 119 {
 120     char* param = NULL;
 121
 122     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 123     {
 124         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getString DBUS handler argument is no String!"));
 125         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 126         mErrorMsg = "DBus argument is no string";
 127     }
 128     else
 129     {
 130         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 131         dbus_message_iter_next(&mDBusMessageIter);
 132     }
 133     return (param);
 134 }
 135
 136 dbus_bool_t DBusMessageHandler::getBool()
 137 {
 138     dbus_bool_t boolparam = false;
 139
 140     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 141     {
 142         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getBool DBUS handler argument is no bool!"));
 143         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 144         mErrorMsg = "DBus argument is no bool";
 145     }
 146     else
 147     {
 148         dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam);
 149         dbus_message_iter_next(&mDBusMessageIter);
 150     }
 151     return (boolparam);
 152 }
 153
 154 char DBusMessageHandler::getByte()
 155 {
 156     char param;
 157
 158     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 159     {
 160         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getByte DBUS handler argument is no byte!"));
 161         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 162         mErrorMsg = "DBus argument is no byte";
 163     }
 164     else
 165     {
 166         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 167         dbus_message_iter_next(&mDBusMessageIter);
 168     }
 169     return (param);
 170 }
 171
 172 dbus_uint16_t DBusMessageHandler::getUInt()
 173 {
 174     dbus_uint16_t param;
 175
 176 #ifdef GLIB_DBUS_TYPES_TOLERANT
 177     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 178 #else
 179     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 180 #endif
 181     {
 182         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!"));
 183         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 184         mErrorMsg = "DBus argument is no uint16_t";
 185     }
 186     else
 187     {
 188         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 189         dbus_message_iter_next(&mDBusMessageIter);
 190     }
 191     return (param);
 192 }
 193
 194 dbus_int16_t DBusMessageHandler::getInt()
 195 {
 196     dbus_int16_t param;
 197
 198 #ifdef GLIB_DBUS_TYPES_TOLERANT
 199     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 200 #else
 201     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 202 #endif
 203     {
 204         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getInt DBUS handler argument is no int16_t!"));
 205         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 206         mErrorMsg = "DBus argument is no int16_t";
 207     }
 208     else
 209     {
 210         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 211         dbus_message_iter_next(&mDBusMessageIter);
 212     }
 213     return (param);
 214 }
 215
 216 double DBusMessageHandler::getDouble()
 217 {
 218     double param;
 219     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 220     {
 221         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getDouble DBUS handler argument is no double!"));
 222         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 223         mErrorMsg = "DBus argument is no double";
 224     }
 225     else
 226     {
 227         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 228         dbus_message_iter_next(&mDBusMessageIter);
 229     }
 230     return (param);
 231 }
 232
 233 void DBusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
 234 {
 235     DBusMessageIter arrayIter;
 236     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 237     {
 238         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getProperty DBUS handler argument is no array!"));
 239         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 240         mErrorMsg = "DBus argument is no array";
 241     }
 242     else
 243     {
 244         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 245         dbus_message_iter_get_basic(&arrayIter, &type);
 246         dbus_message_iter_next(&arrayIter);
 247         dbus_message_iter_get_basic(&arrayIter, &value);
 248         dbus_message_iter_next(&mDBusMessageIter);
 249     }
 250 }
 251
 252 void DBusMessageHandler::append(bool toAppend)
 253 {
 254     dbus_bool_t mybool = toAppend;
 255     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 256     {
 257         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 258         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 259         mErrorMsg = "Cannot create reply!";
 260     }
 261 }
 262
 263 void DBusMessageHandler::append(double toAppend)
 264 {
 265     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 266     {
 267         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 268         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 269         mErrorMsg = "Cannot create reply!";
 270     }
 271 }
 272
 273 void DBusMessageHandler::append(char toAppend)
 274 {
 275     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 276     {
 277         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 278         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 279         mErrorMsg = "Cannot create reply!";
 280     }
 281 }
 282
 283 void DBusMessageHandler::append(dbus_int16_t toAppend)
 284 {
 285     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
 286     {
 287         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 288         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 289         mErrorMsg = "Cannot create reply!";
 290     }
 291 }
 292
 293 void DBusMessageHandler::append(dbus_uint16_t toAppend)
 294 {
 295     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 296     {
 297         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 298         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 299         mErrorMsg = "Cannot create reply!";
 300     }
 301 }
 302
 303 void DBusMessageHandler::setDBusConnection(DBusConnection *& connection)
 304 {
 305     assert(connection!=NULL);
 306     mDBusConnection = connection;
 307 }
 308
 309 void DBusMessageHandler::append(const am::am_SinkType_s& sinkType)
 310 {
 311     DBusMessageIter structIter;
 312     DBusMessageIter structAvailIter;
 313     dbus_bool_t success = true;
 314     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 315     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 316     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 317
 318     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 319     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 320     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 321     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 322
 323     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 324     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 325     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 326     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 327
 328     if (!success)
 329     {
 330         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 331         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 332         mErrorMsg = "Cannot create reply!";
 333     }
 334 }
 335
 336 void DBusMessageHandler::append(const am::am_SourceType_s & sourceType)
 337 {
 338     DBusMessageIter structIter;
 339     DBusMessageIter structAvailIter;
 340     dbus_bool_t success = true;
 341     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 342     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 343     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 344
 345     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 346     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 347     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 348     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 349
 350     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 351     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 352
 353     if (!success)
 354     {
 355         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 356         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 357         mErrorMsg = "Cannot create reply!";
 358     }
 359 }
 360
 361 void DBusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 362 {
 363     DBusMessageIter structIter;
 364     dbus_bool_t success = true;
 365     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 366     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 367     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 368     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 369
 370     if (!success)
 371     {
 372         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 373         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 374         mErrorMsg = "Cannot create reply!";
 375     }
 376 }
 377
 378 void DBusMessageHandler::append(const am::am_Availability_s & availability)
 379 {
 380     DBusMessageIter structAvailIter;
 381     dbus_bool_t success = true;
 382     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 383     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 384     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 385     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 386
 387     if (!success)
 388     {
 389         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 390         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 391         mErrorMsg = "Cannot create reply!";
 392     }
 393 }
 394
 395 void DBusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty)
 396 {
 397     DBusMessageIter structIter;
 398     dbus_bool_t success = true;
 399     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 400     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 401     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 402     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 403
 404     if (!success)
 405     {
 406         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 407         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 408         mErrorMsg = "Cannot create reply!";
 409     }
 410 }
 411
 412 void DBusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 413 {
 414     DBusMessageIter arrayIter;
 415     DBusMessageIter structIter;
 416     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator = listMainConnections.begin();
 417     dbus_bool_t success = true;
 418
 419     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 420     for (; listIterator < listMainConnections.end(); ++listIterator)
 421     {
 422         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 423         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 424         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 425         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 426         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 427         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 428         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 429     }
 430     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 431
 432     if (!success)
 433     {
 434         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 435         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 436         mErrorMsg = "Cannot create reply!";
 437     }
 438 }
 439
 440 void DBusMessageHandler::append(const std::vector<am::am_SinkType_s> & listMainSinks)
 441 {
 442     DBusMessageIter arrayIter;
 443     DBusMessageIter structIter;
 444     DBusMessageIter availIter;
 445     std::vector<am::am_SinkType_s>::const_iterator listIterator = listMainSinks.begin();
 446     dbus_bool_t success = true;
 447
 448     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 449     for (; listIterator < listMainSinks.end(); ++listIterator)
 450     {
 451         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 452         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 453         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 454         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 455         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 456         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 457         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 458         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 459         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 460         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 461         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 462     }
 463     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 464
 465     if (!success)
 466     {
 467         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 468         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 469         mErrorMsg = "Cannot create reply!";
 470     }
 471 }
 472
 473 void DBusMessageHandler::append(const std::vector<am::am_SourceType_s> & listMainSources)
 474 {
 475     DBusMessageIter arrayIter;
 476     DBusMessageIter structIter;
 477     DBusMessageIter availIter;
 478     std::vector<am::am_SourceType_s>::const_iterator listIterator = listMainSources.begin();
 479     dbus_bool_t success = true;
 480
 481     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 482     for (; listIterator < listMainSources.end(); ++listIterator)
 483     {
 484         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 485         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 486         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 487         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 488         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 489         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 490         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 491         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 492         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 493     }
 494     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 495
 496     if (!success)
 497     {
 498         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 499         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 500         mErrorMsg = "Cannot create reply!";
 501     }
 502 }
 503
 504 void DBusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s> & listMainSoundProperties)
 505 {
 506     DBusMessageIter arrayIter;
 507     DBusMessageIter structIter;
 508     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator = listMainSoundProperties.begin();
 509     dbus_bool_t success = true;
 510
 511     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 512     for (; listIterator < listMainSoundProperties.end(); ++listIterator)
 513     {
 514         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 515         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 516         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 517         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 518     }
 519     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 520
 521     if (!success)
 522     {
 523         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 524         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 525         mErrorMsg = "Cannot create reply!";
 526     }
 527 }
 528
 529 void DBusMessageHandler::append(const std::vector<am::am_SourceClass_s> & listSourceClasses)
 530 {
 531     DBusMessageIter arrayIter;
 532     DBusMessageIter structIter;
 533     DBusMessageIter propIter;
 534     DBusMessageIter innerIter;
 535     std::vector<am::am_SourceClass_s>::const_iterator listIterator = listSourceClasses.begin();
 536     dbus_bool_t success = true;
 537
 538     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 539     for (; listIterator < listSourceClasses.end(); ++listIterator)
 540     {
 541         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 542         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 543         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 544         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 545
 546         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 547         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 548         {
 549             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 550             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 551             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 552             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 553         }
 554         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 555         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 556     }
 557     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 558
 559     if (!success)
 560     {
 561         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 562         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 563         mErrorMsg = "Cannot create reply!";
 564     }
 565 }
 566
 567 void DBusMessageHandler::append(const std::vector<am::am_SinkClass_s> & listSinkClasses)
 568 {
 569     DBusMessageIter arrayIter;
 570     DBusMessageIter structIter;
 571     DBusMessageIter propIter;
 572     DBusMessageIter innerIter;
 573     std::vector<am::am_SinkClass_s>::const_iterator listIterator = listSinkClasses.begin();
 574     dbus_bool_t success = true;
 575
 576     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 577     for (; listIterator < listSinkClasses.end(); ++listIterator)
 578     {
 579         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 580         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 581         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 582         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 583
 584         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
 585         for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
 586         {
 587             success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 588             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 589             success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 590             success = success && dbus_message_iter_close_container(&innerIter, &propIter);
 591         }
 592         success = success && dbus_message_iter_close_container(&structIter, &innerIter);
 593         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 594     }
 595     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 596
 597     if (!success)
 598     {
 599         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 600         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 601         mErrorMsg = "Cannot create reply!";
 602     }
 603 }
 604
 605 void DBusMessageHandler::append(const std::vector<am::am_SystemProperty_s> & listSystemProperties)
 606 {
 607     DBusMessageIter arrayIter;
 608     DBusMessageIter structIter;
 609     std::vector<am::am_SystemProperty_s>::const_iterator listIterator = listSystemProperties.begin();
 610     dbus_bool_t success = true;
 611
 612     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 613     for (; listIterator < listSystemProperties.end(); ++listIterator)
 614     {
 615         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 616         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 617         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 618         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 619     }
 620     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 621
 622     if (!success)
 623     {
 624         DLT_LOG(DLT_CONTEXT, DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 625         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 626         mErrorMsg = "Cannot create reply!";
 627     }
 628 }
 629