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 "CommandSender.h"
  27 #include "DBusConfiguration.h"
  28
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <vector>
  32
  33
  34 DBusMessageHandler::DBusMessageHandler()
  35 :       mDBusMessageIter(),
  36         mDBusError(),
  37         mSerial(0),
  38         mErrorName(""),
  39         mErrorMsg(""),
  40         mDbusMessage(NULL),
  41         mReveiveMessage(NULL),
  42         mDBusConnection(NULL)
  43 {
  44         DLT_LOG(DLT_CONTEXT,DLT_LOG_INFO, DLT_STRING("DBUSMessageHandler constructed"));
  45 }
  46
  47 DBusMessageHandler::~DBusMessageHandler()
  48 {
  49         DLT_LOG(DLT_CONTEXT,DLT_LOG_INFO, DLT_STRING("DBUSMessageHandler destructed"));
  50 }
  51
  52 void DBusMessageHandler::initReceive(DBusMessage* msg)
  53 {
  54         assert(msg!=NULL);
  55         mReveiveMessage=msg;
  56     if (!dbus_message_iter_init(msg, &mDBusMessageIter))
  57     {
  58         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initReceive DBus Message has no arguments!"));
  59         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
  60         mErrorMsg="DBUS Message has no arguments!";
  61     }
  62 }
  63
  64 void DBusMessageHandler::initReply(DBusMessage* msg)
  65 {
  66         assert(msg!=NULL);
  67     mDbusMessage = dbus_message_new_method_return(msg);
  68     if (mDbusMessage==NULL) {
  69         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initReply Cannot allocate DBus message!"));
  70         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
  71         mErrorMsg="Cannot create reply!";
  72     }
  73     dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter);
  74 }
  75
  76 void DBusMessageHandler::initSignal(std::string path, std::string signalName)
  77 {
  78         assert(!path.empty());
  79         assert(!signalName.empty());
  80         std::string completePath=std::string(DBUS_SERVICE_OBJECT_PATH)+"/"+path;
  81         mDbusMessage=dbus_message_new_signal(completePath.c_str(),DBUS_SERVICE_PREFIX,signalName.c_str());
  82
  83         if (mDbusMessage == NULL)
  84         {
  85         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::initSignal Cannot allocate DBus message!"));
  86         }
  87 }
  88
  89 void DBusMessageHandler::sendMessage()
  90 {
  91         assert(mDBusConnection!=NULL);
  92         mSerial=dbus_message_get_serial(mReveiveMessage);
  93         if (!mErrorName.empty()) {
  94                 mDbusMessage = dbus_message_new_error(mReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
  95         }
  96     if (!dbus_connection_send(mDBusConnection, mDbusMessage, &mSerial))
  97     {
  98         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::sendMessage cannot send message!"));
  99     }
 100     dbus_connection_flush(mDBusConnection);
 101     dbus_message_unref(mDbusMessage);
 102     mDbusMessage = NULL;
 103 }
 104
 105 char* DBusMessageHandler::getString()
 106 {
 107     char* param=NULL;
 108
 109     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 110     {
 111         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getString DBUS handler argument is no String!"));
 112         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 113         mErrorMsg="DBus argument is no string";
 114     }
 115     else
 116     {
 117         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 118         dbus_message_iter_next(&mDBusMessageIter);
 119     }
 120     return (param);
 121 }
 122
 123 dbus_bool_t DBusMessageHandler::getBool()
 124 {
 125     dbus_bool_t boolparam=false;
 126
 127     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 128     {
 129         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getBool DBUS handler argument is no bool!"));
 130         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 131         mErrorMsg="DBus argument is no bool";
 132     }
 133     else
 134     {
 135         dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam);
 136         dbus_message_iter_next(&mDBusMessageIter);
 137     }
 138     return (boolparam);
 139 }
 140
 141 char DBusMessageHandler::getByte()
 142 {
 143     char param;
 144
 145     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 146     {
 147         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getByte DBUS handler argument is no byte!"));
 148         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 149         mErrorMsg="DBus argument is no byte";
 150     }
 151     else
 152     {
 153         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 154         dbus_message_iter_next(&mDBusMessageIter);
 155     }
 156     return (param);
 157 }
 158
 159 dbus_uint16_t DBusMessageHandler::getUInt()
 160 {
 161     dbus_uint16_t param;
 162
 163     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 164     {
 165         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!"));
 166         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 167         mErrorMsg="DBus argument is no uint16_t";
 168     }
 169     else
 170     {
 171         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 172         dbus_message_iter_next(&mDBusMessageIter);
 173     }
 174     return (param);
 175 }
 176
 177 dbus_int16_t DBusMessageHandler::getInt()
 178 {
 179     dbus_int16_t param;
 180
 181     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 182     {
 183         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getInt DBUS handler argument is no int16_t!"));
 184         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 185         mErrorMsg="DBus argument is no int16_t";
 186     }
 187     else
 188     {
 189         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 190         dbus_message_iter_next(&mDBusMessageIter);
 191     }
 192     return (param);
 193 }
 194
 195 double DBusMessageHandler::getDouble()
 196 {
 197     double param;
 198     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 199     {
 200         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getDouble DBUS handler argument is no double!"));
 201         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 202         mErrorMsg="DBus argument is no double";
 203     }
 204     else
 205     {
 206         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 207         dbus_message_iter_next(&mDBusMessageIter);
 208     }
 209     return (param);
 210 }
 211
 212 void DBusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
 213 {
 214         DBusMessageIter arrayIter;
 215     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 216     {
 217         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::getProperty DBUS handler argument is no array!"));
 218         mErrorName=std::string(DBUS_ERROR_INVALID_ARGS);
 219         mErrorMsg="DBus argument is no array";
 220     }
 221     else
 222     {
 223         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 224         dbus_message_iter_get_basic(&arrayIter, &type);
 225         dbus_message_iter_next(&arrayIter);
 226         dbus_message_iter_get_basic(&arrayIter, &value);
 227         dbus_message_iter_next(&mDBusMessageIter);
 228     }
 229 }
 230
 231 void DBusMessageHandler::append(bool toAppend)
 232 {
 233         dbus_bool_t mybool=toAppend;
 234     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 235     {
 236         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 237         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 238         mErrorMsg="Cannot create reply!";
 239     }
 240 }
 241
 242
 243 void DBusMessageHandler::append(double toAppend)
 244 {
 245     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 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 void DBusMessageHandler::append(char toAppend)
 254 {
 255     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 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
 264 void DBusMessageHandler::append(dbus_int16_t toAppend)
 265 {
 266     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &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 void DBusMessageHandler::append(dbus_uint16_t toAppend)
 275 {
 276     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 277     {
 278         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 279         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 280         mErrorMsg="Cannot create reply!";
 281     }
 282 }
 283
 284 void DBusMessageHandler::setDBusConnection(DBusConnection *& connection)
 285 {
 286         assert(connection!=NULL);
 287         mDBusConnection=connection;
 288 }
 289
 290 void DBusMessageHandler::append(const am::am_SinkType_s& sinkType)
 291 {
 292     DBusMessageIter structIter;
 293     DBusMessageIter structAvailIter;
 294     dbus_bool_t success=true;
 295     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "us(ii)iiu", &structIter);
 296     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 297     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 298
 299     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "(ii)", &structAvailIter);
 300     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 301     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 302     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 303
 304     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 305     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 306     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 307     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 308
 309     if (!success)
 310     {
 311         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 312         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 313         mErrorMsg="Cannot create reply!";
 314     }
 315 }
 316
 317 void DBusMessageHandler::append(const am::am_SourceType_s & sourceType)
 318 {
 319     DBusMessageIter structIter;
 320     DBusMessageIter structAvailIter;
 321     dbus_bool_t success=true;
 322     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "us(ii)u", &structIter);
 323     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 324     success=success &&  dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 325
 326     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "(ii)", &structAvailIter);
 327     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 328     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 329     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 330
 331     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 332     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 333
 334     if (!success)
 335     {
 336         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 337         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 338         mErrorMsg="Cannot create reply!";
 339     }
 340 }
 341
 342 void DBusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 343 {
 344         DBusMessageIter structIter;
 345     dbus_bool_t success=true;
 346     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "(ii)", &structIter);
 347     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 348     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 349     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 350
 351     if (!success)
 352     {
 353         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 354         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 355         mErrorMsg="Cannot create reply!";
 356     }
 357 }
 358
 359 void DBusMessageHandler::append(const am::am_Availability_s & availability)
 360 {
 361     DBusMessageIter structAvailIter;
 362     dbus_bool_t success=true;
 363     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "(ii)", &structAvailIter);
 364     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 365     success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 366     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 367
 368     if (!success)
 369     {
 370         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 371         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 372         mErrorMsg="Cannot create reply!";
 373     }
 374 }
 375
 376 void DBusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty)
 377 {
 378     DBusMessageIter structIter;
 379     dbus_bool_t success=true;
 380     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, "(ii)", &structIter);
 381     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 382     success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 383     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 384
 385     if (!success)
 386     {
 387         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 388         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 389         mErrorMsg="Cannot create reply!";
 390     }
 391 }
 392
 393 void DBusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 394 {
 395     DBusMessageIter arrayIter;
 396     DBusMessageIter structIter;
 397     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator=listMainConnections.begin();
 398     dbus_bool_t success=true;
 399
 400     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 401     for(;listIterator<listMainConnections.end();++listIterator)
 402     {
 403         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 404         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 405         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 406         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 407         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 408         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 409         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 410     }
 411     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 412
 413     if (!success)
 414     {
 415         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 416         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 417         mErrorMsg="Cannot create reply!";
 418     }
 419 }
 420
 421 void DBusMessageHandler::append(const std::vector<am::am_SinkType_s> & listMainSinks)
 422 {
 423     DBusMessageIter arrayIter;
 424     DBusMessageIter structIter;
 425     DBusMessageIter availIter;
 426     std::vector<am::am_SinkType_s>::const_iterator listIterator=listMainSinks.begin();
 427     dbus_bool_t success=true;
 428
 429     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 430     for(;listIterator<listMainSinks.end();++listIterator)
 431     {
 432         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 433         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 434         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 435         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 436         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 437         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 438         success=success && dbus_message_iter_close_container(&structIter, &availIter);
 439         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 440         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 441         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 442         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 443     }
 444     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 445
 446     if (!success)
 447     {
 448         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 449         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 450         mErrorMsg="Cannot create reply!";
 451     }
 452 }
 453
 454
 455
 456 void DBusMessageHandler::append(const std::vector<am::am_SourceType_s> & listMainSources)
 457 {
 458     DBusMessageIter arrayIter;
 459     DBusMessageIter structIter;
 460     DBusMessageIter availIter;
 461     std::vector<am::am_SourceType_s>::const_iterator listIterator=listMainSources.begin();
 462     dbus_bool_t success=true;
 463
 464     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
 465     for(;listIterator<listMainSources.end();++listIterator)
 466     {
 467         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 468         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 469         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 470         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 471         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 472         success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 473         success=success && dbus_message_iter_close_container(&structIter, &availIter);
 474         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 475         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 476     }
 477     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 478
 479     if (!success)
 480     {
 481         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 482         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 483         mErrorMsg="Cannot create reply!";
 484     }
 485 }
 486
 487 void DBusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s> & listMainSoundProperties)
 488 {
 489     DBusMessageIter arrayIter;
 490     DBusMessageIter structIter;
 491     std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator=listMainSoundProperties.begin();
 492     dbus_bool_t success=true;
 493
 494     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 495     for(;listIterator<listMainSoundProperties.end();++listIterator)
 496     {
 497         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 498         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 499         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 500         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 501     }
 502     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 503
 504     if (!success)
 505     {
 506         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 507         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 508         mErrorMsg="Cannot create reply!";
 509     }
 510 }
 511
 512 void DBusMessageHandler::append(const std::vector<am::am_SourceClass_s> & listSourceClasses)
 513 {
 514     DBusMessageIter arrayIter;
 515     DBusMessageIter structIter;
 516     DBusMessageIter propIter;
 517     DBusMessageIter innerIter;
 518     std::vector<am::am_SourceClass_s>::const_iterator listIterator=listSourceClasses.begin();
 519     dbus_bool_t success=true;
 520
 521     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 522     for(;listIterator<listSourceClasses.end();++listIterator)
 523     {
 524         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 525         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
 526         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 527         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 528
 529         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 530         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 531         {
 532             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 533             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 534             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 535             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 536         }
 537         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 538         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 539     }
 540     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 541
 542     if (!success)
 543     {
 544         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 545         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 546         mErrorMsg="Cannot create reply!";
 547     }
 548 }
 549
 550 void DBusMessageHandler::append(const std::vector<am::am_SinkClass_s> & listSinkClasses)
 551 {
 552     DBusMessageIter arrayIter;
 553     DBusMessageIter structIter;
 554     DBusMessageIter propIter;
 555     DBusMessageIter innerIter;
 556     std::vector<am::am_SinkClass_s>::const_iterator listIterator=listSinkClasses.begin();
 557     dbus_bool_t success=true;
 558
 559     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
 560     for(;listIterator<listSinkClasses.end();++listIterator)
 561     {
 562         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 563         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 564         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 565         success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
 566
 567         std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
 568         for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
 569         {
 570             success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
 571             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
 572             success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
 573             success=success && dbus_message_iter_close_container(&innerIter, &propIter);
 574         }
 575         success=success && dbus_message_iter_close_container(&structIter, &innerIter);
 576         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 577     }
 578     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 579
 580     if (!success)
 581     {
 582         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 583         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 584         mErrorMsg="Cannot create reply!";
 585     }
 586 }
 587
 588 void DBusMessageHandler::append(const std::vector<am::am_SystemProperty_s> & listSystemProperties)
 589 {
 590     DBusMessageIter arrayIter;
 591     DBusMessageIter structIter;
 592     std::vector<am::am_SystemProperty_s>::const_iterator listIterator=listSystemProperties.begin();
 593     dbus_bool_t success=true;
 594
 595     success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
 596     for(;listIterator<listSystemProperties.end();++listIterator)
 597     {
 598         success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 599         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
 600         success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
 601         success=success && dbus_message_iter_close_container(&arrayIter, &structIter);
 602     }
 603     success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 604
 605     if (!success)
 606     {
 607         DLT_LOG(DLT_CONTEXT,DLT_LOG_ERROR, DLT_STRING("DBusMessageHandler::append Cannot allocate DBus message!"));
 608         mErrorName=std::string(DBUS_ERROR_NO_MEMORY);
 609         mErrorMsg="Cannot create reply!";
 610     }
 611 }
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625