PluginCommandInterfaceDbus/src/CAmDbusMessageHandler.cpp

   1 /**
   2  *  Copyright (c) 2012 BMW
   3  *
   4  *  \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
   5  *
   6  *  \copyright
   7  *  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction,
   8  *  including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
   9  *  subject to the following conditions:
  10  *  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  11  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  12  *  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
  13  *  THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  14  *
  15  *  For further information see http://www.genivi.org/.
  16  */
  17
  18 #include "CAmDbusMessageHandler.h"
  19 #include "config.h"
  20 #include <cstdlib>
  21 #include <cassert>
  22 #include <vector>
  23 #include "CAmCommandSenderDbus.h"
  24 #include "shared/CAmDltWrapper.h"
  25
  26 DLT_IMPORT_CONTEXT(commandDbus)
  27
  28 namespace am
  29 {
  30
  31 CAmDbusMessageHandler::CAmDbusMessageHandler() :
  32         mDBusMessageIter(), //
  33         mDBusError(), //
  34         mSerial(0), //
  35         mErrorName(""), //
  36         mErrorMsg(""), //
  37         mpDBusMessage(NULL), //
  38         mpReveiveMessage(NULL), //
  39         mpDBusConnection(NULL)
  40 {
  41     log(&commandDbus, DLT_LOG_INFO, "DBusMessageHandler constructed");
  42 }
  43
  44 CAmDbusMessageHandler::~CAmDbusMessageHandler()
  45 {
  46     log(&commandDbus, DLT_LOG_INFO, "DBUSMessageHandler destructed");
  47 }
  48
  49 void CAmDbusMessageHandler::initReceive(DBusMessage* msg)
  50 {
  51     assert(msg!=NULL);
  52     mpReveiveMessage = msg;
  53     if (!dbus_message_iter_init(msg, &mDBusMessageIter))
  54     {
  55         log(&commandDbus, DLT_LOG_INFO, "DBusMessageHandler::initReceive DBus Message has no arguments!");
  56         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
  57         mErrorMsg = "DBUS Message has no arguments!";
  58     }
  59 }
  60
  61 void CAmDbusMessageHandler::initReply(DBusMessage* msg)
  62 {
  63     assert(msg!=NULL);
  64     mpDBusMessage = dbus_message_new_method_return(msg);
  65     if (mpDBusMessage == NULL)
  66     {
  67         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::initReply Cannot allocate DBus message!");
  68         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
  69         mErrorMsg = "Cannot create reply!";
  70     }
  71     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  72 }
  73
  74 void CAmDbusMessageHandler::initSignal(std::string path, std::string signalName)
  75 {
  76     assert(!path.empty());
  77     assert(!signalName.empty());
  78     std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
  79     mpDBusMessage = dbus_message_new_signal(completePath.c_str(), DBUS_SERVICE_PREFIX, signalName.c_str());
  80
  81     if (mpDBusMessage == NULL)
  82     {
  83         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::initSignal Cannot allocate DBus message!");
  84     }
  85     dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
  86 }
  87
  88 void CAmDbusMessageHandler::sendMessage()
  89 {
  90     assert(mpDBusConnection!=NULL);
  91     if (mpReveiveMessage != 0)
  92     {
  93         mSerial = dbus_message_get_serial(mpReveiveMessage);
  94     }
  95     else
  96     {
  97         mSerial = 1;
  98     }
  99     if (!mErrorName.empty())
 100     {
 101         mpDBusMessage = dbus_message_new_error(mpReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
 102     }
 103     if (!dbus_connection_send(mpDBusConnection, mpDBusMessage, &mSerial))
 104     {
 105         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::sendMessage cannot send message!");
 106     }
 107     dbus_connection_flush(mpDBusConnection);
 108     dbus_message_unref(mpDBusMessage);
 109     mpDBusMessage = NULL;
 110 }
 111
 112 char* CAmDbusMessageHandler::getString()
 113 {
 114     char* param = NULL;
 115
 116     if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 117     {
 118         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getString DBUS handler argument is no String!");
 119         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 120         mErrorMsg = "DBus argument is no string";
 121     }
 122     else
 123     {
 124         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 125         dbus_message_iter_next(&mDBusMessageIter);
 126     }
 127     return (param);
 128 }
 129
 130 dbus_bool_t CAmDbusMessageHandler::getBool()
 131 {
 132     dbus_bool_t boolparam = false;
 133
 134     if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 135     {
 136         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no bool!");
 137         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 138         mErrorMsg = "DBus argument is no bool";
 139     }
 140     else
 141     {
 142         dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam);
 143         dbus_message_iter_next(&mDBusMessageIter);
 144     }
 145     return (boolparam);
 146 }
 147
 148 char CAmDbusMessageHandler::getByte()
 149 {
 150     char param(0);
 151
 152     if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 153     {
 154         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getByte DBUS handler argument is no byte!");
 155         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 156         mErrorMsg = "DBus argument is no byte";
 157     }
 158     else
 159     {
 160         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 161         dbus_message_iter_next(&mDBusMessageIter);
 162     }
 163     return (param);
 164 }
 165
 166 dbus_uint16_t CAmDbusMessageHandler::getUInt()
 167 {
 168     dbus_uint16_t param(0);
 169
 170 #ifdef GLIB_DBUS_TYPES_TOLERANT
 171     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 172 #else
 173     if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 174 #endif
 175     {
 176         log(&commandDbus, DLT_LOG_ERROR, "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 CAmDbusMessageHandler::getInt()
 189 {
 190     dbus_int16_t param(0);
 191
 192 #ifdef GLIB_DBUS_TYPES_TOLERANT
 193     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 194 #else
 195     if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 196 #endif
 197     {
 198         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int16_t!");
 199         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 200         mErrorMsg = "DBus argument is no int16_t";
 201     }
 202     else
 203     {
 204         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 205         dbus_message_iter_next(&mDBusMessageIter);
 206     }
 207     return (param);
 208 }
 209
 210 double CAmDbusMessageHandler::getDouble()
 211 {
 212     double param(0);
 213     if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 214     {
 215         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getDouble DBUS handler argument is no double!");
 216         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 217         mErrorMsg = "DBus argument is no double";
 218     }
 219     else
 220     {
 221         dbus_message_iter_get_basic(&mDBusMessageIter, &param);
 222         dbus_message_iter_next(&mDBusMessageIter);
 223     }
 224     return (param);
 225 }
 226
 227 void CAmDbusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value)
 228 {
 229     DBusMessageIter arrayIter;
 230     if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
 231     {
 232         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::getProperty DBUS handler argument is no array!");
 233         mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
 234         mErrorMsg = "DBus argument is no array";
 235     }
 236     else
 237     {
 238         dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
 239         dbus_message_iter_get_basic(&arrayIter, &type);
 240         dbus_message_iter_next(&arrayIter);
 241         dbus_message_iter_get_basic(&arrayIter, &value);
 242         dbus_message_iter_next(&mDBusMessageIter);
 243     }
 244 }
 245
 246 void CAmDbusMessageHandler::append(bool toAppend)
 247 {
 248     dbus_bool_t mybool = toAppend;
 249     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
 250     {
 251         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 252         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 253         mErrorMsg = "Cannot create reply!";
 254     }
 255 }
 256
 257 void CAmDbusMessageHandler::append(double toAppend)
 258 {
 259     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
 260     {
 261         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 262         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 263         mErrorMsg = "Cannot create reply!";
 264     }
 265 }
 266
 267 void CAmDbusMessageHandler::append(char toAppend)
 268 {
 269     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
 270     {
 271         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 272         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 273         mErrorMsg = "Cannot create reply!";
 274     }
 275 }
 276
 277 void CAmDbusMessageHandler::append(dbus_int16_t toAppend)
 278 {
 279     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
 280     {
 281         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 282         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 283         mErrorMsg = "Cannot create reply!";
 284     }
 285 }
 286
 287 void CAmDbusMessageHandler::append(dbus_uint16_t toAppend)
 288 {
 289     if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
 290     {
 291         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 292         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 293         mErrorMsg = "Cannot create reply!";
 294     }
 295 }
 296
 297 void CAmDbusMessageHandler::setDBusConnection(DBusConnection *& connection)
 298 {
 299     assert(connection!=NULL);
 300     mpDBusConnection = connection;
 301 }
 302
 303 void CAmDbusMessageHandler::append(const am::am_SinkType_s& sinkType)
 304 {
 305     DBusMessageIter structIter;
 306     DBusMessageIter structAvailIter;
 307     dbus_bool_t success = true;
 308     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 309     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
 310     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
 311
 312     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 313     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
 314     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
 315     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 316
 317     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
 318     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
 319     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
 320     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 321
 322     if (!success)
 323     {
 324         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 325         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 326         mErrorMsg = "Cannot create reply!";
 327     }
 328 }
 329
 330 void CAmDbusMessageHandler::append(const am::am_SourceType_s & sourceType)
 331 {
 332     DBusMessageIter structIter;
 333     DBusMessageIter structAvailIter;
 334     dbus_bool_t success = true;
 335     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 336     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
 337     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
 338
 339     success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 340     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
 341     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
 342     success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
 343
 344     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
 345     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 346
 347     if (!success)
 348     {
 349         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 350         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 351         mErrorMsg = "Cannot create reply!";
 352     }
 353 }
 354
 355 void CAmDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
 356 {
 357     DBusMessageIter structIter;
 358     dbus_bool_t success = true;
 359     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 360     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
 361     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
 362     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 363
 364     if (!success)
 365     {
 366         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 367         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 368         mErrorMsg = "Cannot create reply!";
 369     }
 370 }
 371
 372 void CAmDbusMessageHandler::append(const am::am_Availability_s & availability)
 373 {
 374     DBusMessageIter structAvailIter;
 375     dbus_bool_t success = true;
 376     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
 377     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
 378     success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
 379     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
 380
 381     if (!success)
 382     {
 383         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 384         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 385         mErrorMsg = "Cannot create reply!";
 386     }
 387 }
 388
 389 void CAmDbusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty)
 390 {
 391     DBusMessageIter structIter;
 392     dbus_bool_t success = true;
 393     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 394     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
 395     success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
 396     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
 397
 398     if (!success)
 399     {
 400         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 401         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 402         mErrorMsg = "Cannot create reply!";
 403     }
 404 }
 405
 406 void CAmDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
 407 {
 408     DBusMessageIter arrayIter;
 409     DBusMessageIter structIter;
 410     std::vector<am::am_MainConnectionType_s>::const_iterator listIterator = listMainConnections.begin();
 411     dbus_bool_t success = true;
 412
 413     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
 414     for (; listIterator < listMainConnections.end(); ++listIterator)
 415     {
 416         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 417         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
 418         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
 419         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 420         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
 421         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
 422         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 423     }
 424     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 425
 426     if (!success)
 427     {
 428         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 429         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 430         mErrorMsg = "Cannot create reply!";
 431     }
 432 }
 433
 434 void CAmDbusMessageHandler::append(const std::vector<am::am_SinkType_s> & listMainSinks)
 435 {
 436     DBusMessageIter arrayIter;
 437     DBusMessageIter structIter;
 438     DBusMessageIter availIter;
 439     std::vector<am::am_SinkType_s>::const_iterator listIterator = listMainSinks.begin();
 440     dbus_bool_t success = true;
 441
 442     success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
 443     for (; listIterator < listMainSinks.end(); ++listIterator)
 444     {
 445         success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
 446         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
 447         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
 448         success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
 449         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
 450         success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
 451         success = success && dbus_message_iter_close_container(&structIter, &availIter);
 452         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
 453         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
 454         success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
 455         success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
 456     }
 457     success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
 458
 459     if (!success)
 460     {
 461         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 462         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 463         mErrorMsg = "Cannot create reply!";
 464     }
 465 }
 466
 467 void CAmDbusMessageHandler::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         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 493         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 494         mErrorMsg = "Cannot create reply!";
 495     }
 496 }
 497
 498 void CAmDbusMessageHandler::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         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 518         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 519         mErrorMsg = "Cannot create reply!";
 520     }
 521 }
 522
 523 void CAmDbusMessageHandler::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         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 556         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 557         mErrorMsg = "Cannot create reply!";
 558     }
 559 }
 560
 561 void CAmDbusMessageHandler::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         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 594         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 595         mErrorMsg = "Cannot create reply!";
 596     }
 597 }
 598
 599 void CAmDbusMessageHandler::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         log(&commandDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
 619         mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
 620         mErrorMsg = "Cannot create reply!";
 621     }
 622 }
 623 }