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         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initReply Cannot allocate DBus message!"));
  73         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
  74         mErrorMsg="Cannot create reply!";
  75     }
  76     dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
  77 }
  78
  79 void DBusMessageHandler::initSignal(std::string path, std::string signalName)
  80 {
  81         assert(!path.empty());
  82         assert(!signalName.empty());
  83         std::string completePath=std::string(DBUS_SERVICE_OBJECT_PATH)+"/"+path;
  84         mDbusMessage=dbus_message_new_signal(completePath.c_str(),DBUS_SERVICE_PREFIX,signalName.c_str());
  85
  86         if (mDbusMessage == NULL)
  87         {
  88         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initSignal Cannot allocate DBus message!"));
  89         }
  90     dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
  91 }
  92
  93 void DBusMessageHandler::sendMessage()
  94 {
  95         assert(mDBusConnection!=NULL);
  96         if(mReveiveMessage!=0)
  97         {
  98                 mSerial=dbus_message_get_serial(mReveiveMessage);
  99         }
 100         else
 101         {
 102                 mSerial=1;
 103         }
 104         if (!mErrorName.empty()) {
 105                 mDbusMessage = dbus_message_new_error(mReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
 106         }
 107     if (!dbus_connection_send(mDBusConnection, mDbusMessage, &mSerial))
 108     {
 109         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::sendMessage cannot send message!"));
 110     }
 111     dbus_connection_flush(mDBusConnection);
 112     dbus_message_unref(mDbusMessage);
 113     mDbusMessage = NULL;
 114 }
 115
 116 char* DBusMessageHandler::getString()
 117 {
 118     char* param=NULL;
 119
 120     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 121     {
 122         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("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(&mDBusMessageIter, &param);
 129         dbus_message_iter_next(&mDBusMessageIter);
 130     }
 131     return (param);
 132 }
 133
 134 dbus_bool_t DBusMessageHandler::getBool()
 135 {
 136     dbus_bool_t boolparam=false;
 137
 138     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 139     {
 140         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getBool DBUS handler argument is no bool!"));
 141         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 142         mErrorMsg="DBus argument is no bool";
 143     }
 144     else
 145     {
 146         dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam);
 147         dbus_message_iter_next(&mDBusMessageIter);
 148     }
 149     return (boolparam);
 150 }
 151
 152 char DBusMessageHandler::getByte()
 153 {
 154     char param;
 155
 156     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 157     {
 158         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getByte DBUS handler argument is no byte!"));
 159         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 160         mErrorMsg="DBus argument is no byte";
 161     }
 162     else
 163     {
 164         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 165         dbus_message_iter_next(&mDBusMessageIter);
 166     }
 167     return (param);
 168 }
 169
 170 dbus_uint16_t DBusMessageHandler::getUInt()
 171 {
 172     dbus_uint16_t param;
 173
 174 #ifdef GLIB_DBUS_TYPES_TOLERANT
 175     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 176 #else
 177     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 178 #endif
 179     {
 180         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!"));
 181         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 182         mErrorMsg="DBus argument is no uint16_t";
 183     }
 184     else
 185     {
 186         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 187         dbus_message_iter_next(&mDBusMessageIter);
 188     }
 189     return (param);
 190 }
 191
 192 dbus_int16_t DBusMessageHandler::getInt()
 193 {
 194     dbus_int16_t param;
 195
 196 #ifdef GLIB_DBUS_TYPES_TOLERANT
 197     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 198 #else
 199     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 200 #endif
 201     {
 202         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getInt DBUS handler argument is no int16_t!"));
 203         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 204         mErrorMsg="DBus argument is no int16_t";
 205     }
 206     else
 207     {
 208         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 209         dbus_message_iter_next(&mDBusMessageIter);
 210     }
 211     return (param);
 212 }
 213
 214 double DBusMessageHandler::getDouble()
 215 {
 216     double param;
 217     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 218     {
 219         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getDouble DBUS handler argument is no double!"));
 220         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 221         mErrorMsg="DBus argument is no double";
 222     }
 223     else
 224     {
 225         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 226         dbus_message_iter_next(&mDBusMessageIter);
 227     }
 228     return (param);
 229 }
 230
 231 void DBusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
 232 {
 233         DBusMessageIter arrayIter;
 234     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 235     {
 236         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getProperty DBUS handler argument is no array!"));
 237         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 238         mErrorMsg="DBus argument is no array";
 239     }
 240     else
 241     {
 242         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 243         dbus_message_iter_get_basic(&arrayIter, &type);
 244         dbus_message_iter_next(&arrayIter);
 245         dbus_message_iter_get_basic(&arrayIter, &value);
 246         dbus_message_iter_next(&mDBusMessageIter);
 247     }
 248 }
 249
 250 void DBusMessageHandler::append(bool toAppend)
 251 {
 252         dbus_bool_t mybool=toAppend;
 253     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 254     {
 255         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 256         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 257         mErrorMsg="Cannot create reply!";
 258     }
 259 }
 260
 261
 262 void DBusMessageHandler::append(double toAppend)
 263 {
 264     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 265     {
 266         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 267         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 268         mErrorMsg="Cannot create reply!";
 269     }
 270 }
 271
 272 void DBusMessageHandler::append(char toAppend)
 273 {
 274     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 275     {
 276         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 277         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 278         mErrorMsg="Cannot create reply!";
 279     }
 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
 474
 475 void DBusMessageHandler::append(const std::vector<am::am_SourceType_s> & listMainSources)
 476 {
 477     DBusMessageIter arrayIter;
 478     DBusMessageIter structIter;
 479     DBusMessageIter availIter;
 480     std::vector<am::am_SourceType_s>::const_iterator listIterator=listMainSources.begin();
 481     dbus_bool_t success=true;
 482
 483     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 484     for(;listIterator<listMainSources.end();++listIterator)
 485     {
 486         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 487         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 488         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 489         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 490         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 491         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 492         success=success && dbus_message_iter_close_container(&structIter, &availIter);
 493         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 494         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 495     }
 496     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 497
 498     if (!success)
 499     {
 500         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 501         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 502         mErrorMsg="Cannot create reply!";
 503     }
 504 }
 505
 506 void DBusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s> & listMainSoundProperties)
 507 {
 508     DBusMessageIter arrayIter;
 509     DBusMessageIter structIter;
 510     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator=listMainSoundProperties.begin();
 511     dbus_bool_t success=true;
 512
 513     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 514     for(;listIterator<listMainSoundProperties.end();++listIterator)
 515     {
 516         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 517         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 518         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 519         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 520     }
 521     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 522
 523     if (!success)
 524     {
 525         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 526         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 527         mErrorMsg="Cannot create reply!";
 528     }
 529 }
 530
 531 void DBusMessageHandler::append(const std::vector<am::am_SourceClass_s> & listSourceClasses)
 532 {
 533     DBusMessageIter arrayIter;
 534     DBusMessageIter structIter;
 535     DBusMessageIter propIter;
 536     DBusMessageIter innerIter;
 537     std::vector<am::am_SourceClass_s>::const_iterator listIterator=listSourceClasses.begin();
 538     dbus_bool_t success=true;
 539
 540     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 541     for(;listIterator<listSourceClasses.end();++listIterator)
 542     {
 543         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 544         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 545         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 546         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 547
 548         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 549         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 550         {
 551             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 552             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 553             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 554             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 555         }
 556         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 557         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 558     }
 559     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 560
 561     if (!success)
 562     {
 563         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 564         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 565         mErrorMsg="Cannot create reply!";
 566     }
 567 }
 568
 569 void DBusMessageHandler::append(const std::vector<am::am_SinkClass_s> & listSinkClasses)
 570 {
 571     DBusMessageIter arrayIter;
 572     DBusMessageIter structIter;
 573     DBusMessageIter propIter;
 574     DBusMessageIter innerIter;
 575     std::vector<am::am_SinkClass_s>::const_iterator listIterator=listSinkClasses.begin();
 576     dbus_bool_t success=true;
 577
 578     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 579     for(;listIterator<listSinkClasses.end();++listIterator)
 580     {
 581         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 582         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 583         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 584         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 585
 586         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 587         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 588         {
 589             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 590             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 591             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 592             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 593         }
 594         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 595         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 596     }
 597     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 598
 599     if (!success)
 600     {
 601         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 602         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 603         mErrorMsg="Cannot create reply!";
 604     }
 605 }
 606
 607 void DBusMessageHandler::append(const std::vector<am::am_SystemProperty_s> & listSystemProperties)
 608 {
 609     DBusMessageIter arrayIter;
 610     DBusMessageIter structIter;
 611     std::vector<am::am_SystemProperty_s>::const_iterator listIterator=listSystemProperties.begin();
 612     dbus_bool_t success=true;
 613
 614     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 615     for(;listIterator<listSystemProperties.end();++listIterator)
 616     {
 617         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 618         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 619         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 620         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 621     }
 622     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 623
 624     if (!success)
 625     {
 626         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 627         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 628         mErrorMsg="Cannot create reply!";
 629     }
 630 }
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644