PluginCommandInterfaceDbus/src/DBusMessageHandler.cpp

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