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 "DBusMessageHandler.h"
  26 #include "DBusCommandSender.h"
  27 #include "DBusConfiguration.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     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 175     {
 176         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!"));
 177         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 178         mErrorMsg="DBus argument is no uint16_t";
 179     }
 180     else
 181     {
 182         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 183         dbus_message_iter_next(&mDBusMessageIter);
 184     }
 185     return (param);
 186 }
 187
 188 dbus_int16_t DBusMessageHandler::getInt()
 189 {
 190     dbus_int16_t param;
 191
 192     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 193     {
 194         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getInt DBUS handler argument is no int16_t!"));
 195         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 196         mErrorMsg="DBus argument is no int16_t";
 197     }
 198     else
 199     {
 200         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 201         dbus_message_iter_next(&mDBusMessageIter);
 202     }
 203     return (param);
 204 }
 205
 206 double DBusMessageHandler::getDouble()
 207 {
 208     double param;
 209     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 210     {
 211         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getDouble DBUS handler argument is no double!"));
 212         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 213         mErrorMsg="DBus argument is no double";
 214     }
 215     else
 216     {
 217         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 218         dbus_message_iter_next(&mDBusMessageIter);
 219     }
 220     return (param);
 221 }
 222
 223 void DBusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
 224 {
 225         DBusMessageIter arrayIter;
 226     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 227     {
 228         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getProperty DBUS handler argument is no array!"));
 229         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 230         mErrorMsg="DBus argument is no array";
 231     }
 232     else
 233     {
 234         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 235         dbus_message_iter_get_basic(&arrayIter, &type);
 236         dbus_message_iter_next(&arrayIter);
 237         dbus_message_iter_get_basic(&arrayIter, &value);
 238         dbus_message_iter_next(&mDBusMessageIter);
 239     }
 240 }
 241
 242 void DBusMessageHandler::append(bool toAppend)
 243 {
 244         dbus_bool_t mybool=toAppend;
 245     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 246     {
 247         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 248         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 249         mErrorMsg="Cannot create reply!";
 250     }
 251 }
 252
 253
 254 void DBusMessageHandler::append(double toAppend)
 255 {
 256     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 257     {
 258         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 259         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 260         mErrorMsg="Cannot create reply!";
 261     }
 262 }
 263
 264 void DBusMessageHandler::append(char toAppend)
 265 {
 266     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 267     {
 268         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 269         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 270         mErrorMsg="Cannot create reply!";
 271     }
 272 }
 273
 274
 275 void DBusMessageHandler::append(dbus_int16_t toAppend)
 276 {
 277     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
 278     {
 279         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 280         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 281         mErrorMsg="Cannot create reply!";
 282     }
 283 }
 284
 285 void DBusMessageHandler::append(dbus_uint16_t toAppend)
 286 {
 287     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 288     {
 289         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 290         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 291         mErrorMsg="Cannot create reply!";
 292     }
 293 }
 294
 295 void DBusMessageHandler::setDBusConnection(DBusConnection *& connection)
 296 {
 297         assert(connection!=NULL);
 298         mDBusConnection=connection;
 299 }
 300
 301 void DBusMessageHandler::append(const am::am_SinkType_s& sinkType)
 302 {
 303     DBusMessageIter structIter;
 304     DBusMessageIter structAvailIter;
 305     dbus_bool_t success=true;
 306     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 307     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 308     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 309
 310     success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 311     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 312     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 313     success=success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 314
 315     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 316     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 317     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 318     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 319
 320     if (!success)
 321     {
 322         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 323         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 324         mErrorMsg="Cannot create reply!";
 325     }
 326 }
 327
 328 void DBusMessageHandler::append(const am::am_SourceType_s & sourceType)
 329 {
 330     DBusMessageIter structIter;
 331     DBusMessageIter structAvailIter;
 332     dbus_bool_t success=true;
 333     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 334     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 335     success=success &&  dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 336
 337     success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 338     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 339     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 340     success=success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 341
 342     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 343     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 344
 345     if (!success)
 346     {
 347         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 348         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 349         mErrorMsg="Cannot create reply!";
 350     }
 351 }
 352
 353 void DBusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 354 {
 355         DBusMessageIter structIter;
 356     dbus_bool_t success=true;
 357     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 358     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 359     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 360     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 361
 362     if (!success)
 363     {
 364         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 365         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 366         mErrorMsg="Cannot create reply!";
 367     }
 368 }
 369
 370 void DBusMessageHandler::append(const am::am_Availability_s & availability)
 371 {
 372     DBusMessageIter structAvailIter;
 373     dbus_bool_t success=true;
 374     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT,NULL, &structAvailIter);
 375     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 376     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 377     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 378
 379     if (!success)
 380     {
 381         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 382         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 383         mErrorMsg="Cannot create reply!";
 384     }
 385 }
 386
 387 void DBusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty)
 388 {
 389     DBusMessageIter structIter;
 390     dbus_bool_t success=true;
 391     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 392     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 393     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 394     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 395
 396     if (!success)
 397     {
 398         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 399         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 400         mErrorMsg="Cannot create reply!";
 401     }
 402 }
 403
 404 void DBusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 405 {
 406     DBusMessageIter arrayIter;
 407     DBusMessageIter structIter;
 408     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator=listMainConnections.begin();
 409     dbus_bool_t success=true;
 410
 411     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 412     for(;listIterator<listMainConnections.end();++listIterator)
 413     {
 414         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 415         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 416         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 417         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 418         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 419         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 420         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 421     }
 422     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 423
 424     if (!success)
 425     {
 426         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 427         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 428         mErrorMsg="Cannot create reply!";
 429     }
 430 }
 431
 432 void DBusMessageHandler::append(const std::vector<am::am_SinkType_s> & listMainSinks)
 433 {
 434     DBusMessageIter arrayIter;
 435     DBusMessageIter structIter;
 436     DBusMessageIter availIter;
 437     std::vector<am::am_SinkType_s>::const_iterator listIterator=listMainSinks.begin();
 438     dbus_bool_t success=true;
 439
 440     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 441     for(;listIterator<listMainSinks.end();++listIterator)
 442     {
 443         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 444         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 445         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 446         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 447         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 448         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 449         success=success && dbus_message_iter_close_container(&structIter, &availIter);
 450         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 451         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 452         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 453         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 454     }
 455     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 456
 457     if (!success)
 458     {
 459         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 460         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 461         mErrorMsg="Cannot create reply!";
 462     }
 463 }
 464
 465
 466
 467 void DBusMessageHandler::append(const std::vector<am::am_SourceType_s> & listMainSources)
 468 {
 469     DBusMessageIter arrayIter;
 470     DBusMessageIter structIter;
 471     DBusMessageIter availIter;
 472     std::vector<am::am_SourceType_s>::const_iterator listIterator=listMainSources.begin();
 473     dbus_bool_t success=true;
 474
 475     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 476     for(;listIterator<listMainSources.end();++listIterator)
 477     {
 478         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 479         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 480         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 481         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 482         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 483         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 484         success=success && dbus_message_iter_close_container(&structIter, &availIter);
 485         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 486         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 487     }
 488     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 489
 490     if (!success)
 491     {
 492         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 493         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 494         mErrorMsg="Cannot create reply!";
 495     }
 496 }
 497
 498 void DBusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s> & listMainSoundProperties)
 499 {
 500     DBusMessageIter arrayIter;
 501     DBusMessageIter structIter;
 502     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator=listMainSoundProperties.begin();
 503     dbus_bool_t success=true;
 504
 505     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 506     for(;listIterator<listMainSoundProperties.end();++listIterator)
 507     {
 508         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 509         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 510         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 511         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 512     }
 513     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 514
 515     if (!success)
 516     {
 517         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 518         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 519         mErrorMsg="Cannot create reply!";
 520     }
 521 }
 522
 523 void DBusMessageHandler::append(const std::vector<am::am_SourceClass_s> & listSourceClasses)
 524 {
 525     DBusMessageIter arrayIter;
 526     DBusMessageIter structIter;
 527     DBusMessageIter propIter;
 528     DBusMessageIter innerIter;
 529     std::vector<am::am_SourceClass_s>::const_iterator listIterator=listSourceClasses.begin();
 530     dbus_bool_t success=true;
 531
 532     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 533     for(;listIterator<listSourceClasses.end();++listIterator)
 534     {
 535         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 536         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 537         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 538         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 539
 540         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 541         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 542         {
 543             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 544             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 545             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 546             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 547         }
 548         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 549         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 550     }
 551     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 552
 553     if (!success)
 554     {
 555         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 556         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 557         mErrorMsg="Cannot create reply!";
 558     }
 559 }
 560
 561 void DBusMessageHandler::append(const std::vector<am::am_SinkClass_s> & listSinkClasses)
 562 {
 563     DBusMessageIter arrayIter;
 564     DBusMessageIter structIter;
 565     DBusMessageIter propIter;
 566     DBusMessageIter innerIter;
 567     std::vector<am::am_SinkClass_s>::const_iterator listIterator=listSinkClasses.begin();
 568     dbus_bool_t success=true;
 569
 570     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 571     for(;listIterator<listSinkClasses.end();++listIterator)
 572     {
 573         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 574         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 575         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 576         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 577
 578         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 579         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 580         {
 581             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 582             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 583             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 584             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 585         }
 586         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 587         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 588     }
 589     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 590
 591     if (!success)
 592     {
 593         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 594         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 595         mErrorMsg="Cannot create reply!";
 596     }
 597 }
 598
 599 void DBusMessageHandler::append(const std::vector<am::am_SystemProperty_s> & listSystemProperties)
 600 {
 601     DBusMessageIter arrayIter;
 602     DBusMessageIter structIter;
 603     std::vector<am::am_SystemProperty_s>::const_iterator listIterator=listSystemProperties.begin();
 604     dbus_bool_t success=true;
 605
 606     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 607     for(;listIterator<listSystemProperties.end();++listIterator)
 608     {
 609         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 610         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 611         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 612         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 613     }
 614     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 615
 616     if (!success)
 617     {
 618         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 619         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 620         mErrorMsg="Cannot create reply!";
 621     }
 622 }
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636