2 * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors
3 * Copyright (c) 2012 BMW
5 * \author Sampreeth Ramavana
6 * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012
9 * 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,
10 * 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,
11 * subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
13 * 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.
14 * 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
15 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
17 * For further information see http://www.genivi.org/.
20 #include "CAmDbusMessageHandler.h"
25 #include "CAmRoutingSenderDbus.h"
26 #include "shared/CAmDltWrapper.h"
31 DLT_IMPORT_CONTEXT(routingDbus)
33 CAmRoutingDbusMessageHandler::CAmRoutingDbusMessageHandler() :
34 mDBusMessageIter(), //
39 mpDBusMessage(NULL), //
40 mpReveiveMessage(NULL), //
41 mpDBusConnection(NULL)
43 log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler constructed");
46 CAmRoutingDbusMessageHandler::~CAmRoutingDbusMessageHandler()
48 log(&routingDbus, DLT_LOG_INFO, "DBUSMessageHandler destructed");
51 void CAmRoutingDbusMessageHandler::initReceive(DBusMessage* msg)
54 mpReveiveMessage = msg;
55 if (!dbus_message_iter_init(msg, &mDBusMessageIter))
57 log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler::initReceive DBus Message has no arguments!");
58 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
59 mErrorMsg = "DBUS Message has no arguments!";
63 void CAmRoutingDbusMessageHandler::initReply(DBusMessage* msg)
66 mpDBusMessage = dbus_message_new_method_return(msg);
67 if (mpDBusMessage == NULL)
69 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initReply Cannot allocate DBus message!");
70 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
71 mErrorMsg = "Cannot create reply!";
73 dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
76 void CAmRoutingDbusMessageHandler::initSignal(std::string path, std::string signalName)
78 assert(!path.empty());
79 assert(!signalName.empty());
80 std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path;
81 mpDBusMessage = dbus_message_new_signal(completePath.c_str(), DBUS_SERVICE_PREFIX, signalName.c_str());
83 if (mpDBusMessage == NULL)
85 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initSignal Cannot allocate DBus message!");
87 dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter);
90 void CAmRoutingDbusMessageHandler::sendMessage()
92 assert(mpDBusConnection!=NULL);
93 if (mpReveiveMessage != 0)
95 mSerial = dbus_message_get_serial(mpReveiveMessage);
101 if (!mErrorName.empty())
103 mpDBusMessage = dbus_message_new_error(mpReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str());
105 if (!dbus_connection_send(mpDBusConnection, mpDBusMessage, &mSerial))
107 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::sendMessage cannot send message!");
109 dbus_connection_flush(mpDBusConnection);
110 dbus_message_unref(mpDBusMessage);
111 mpDBusMessage = NULL;
114 char* CAmRoutingDbusMessageHandler::getString(DBusMessageIter& iter, bool next)
118 if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&iter))
120 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getString DBUS handler argument is no String!");
121 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
122 mErrorMsg = "DBus argument is no string";
126 dbus_message_iter_get_basic(&iter, ¶m);
128 dbus_message_iter_next(&iter);
133 char* CAmRoutingDbusMessageHandler::getString()
135 return (getString(mDBusMessageIter, true));
138 dbus_bool_t CAmRoutingDbusMessageHandler::getBool(DBusMessageIter& iter, bool next)
140 dbus_bool_t boolparam = false;
142 if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&iter))
144 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no bool!");
145 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
146 mErrorMsg = "DBus argument is no bool";
150 dbus_message_iter_get_basic(&iter, &boolparam);
152 dbus_message_iter_next(&iter);
157 dbus_bool_t CAmRoutingDbusMessageHandler::getBool()
159 return (getBool(mDBusMessageIter, true));
162 char CAmRoutingDbusMessageHandler::getByte(DBusMessageIter& iter, bool next)
166 if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&iter))
168 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getByte DBUS handler argument is no byte!");
169 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
170 mErrorMsg = "DBus argument is no byte";
174 dbus_message_iter_get_basic(&iter, ¶m);
176 dbus_message_iter_next(&iter);
181 char CAmRoutingDbusMessageHandler::getByte()
183 return (getByte(mDBusMessageIter, true));
186 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt(DBusMessageIter& iter, bool next)
188 dbus_uint16_t param(0);
189 #ifdef GLIB_DBUS_TYPES_TOLERANT
190 if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&iter))
192 if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter))
195 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!");
196 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
197 mErrorMsg = "DBus argument is no uint16_t";
201 dbus_message_iter_get_basic(&iter, ¶m);
203 dbus_message_iter_next(&iter);
208 dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt()
210 return (getUInt(mDBusMessageIter, true));
213 dbus_int16_t CAmRoutingDbusMessageHandler::getInt(DBusMessageIter& iter, bool next)
215 dbus_int16_t param(0);
216 #ifdef GLIB_DBUS_TYPES_TOLERANT
217 if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter))
219 if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter))
222 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int16_t!");
223 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
224 mErrorMsg = "DBus argument is no int16_t";
228 dbus_message_iter_get_basic(&iter, ¶m);
230 dbus_message_iter_next(&iter);
235 dbus_int16_t CAmRoutingDbusMessageHandler::getInt()
237 return (getInt(mDBusMessageIter, true));
240 double CAmRoutingDbusMessageHandler::getDouble(DBusMessageIter& iter, bool next)
243 if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&iter))
245 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getDouble DBUS handler argument is no double!");
246 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
247 mErrorMsg = "DBus argument is no double";
251 dbus_message_iter_get_basic(&iter, ¶m);
253 dbus_message_iter_next(&iter);
258 double CAmRoutingDbusMessageHandler::getDouble()
260 return (getDouble(mDBusMessageIter, true));
263 am::am_Availability_s CAmRoutingDbusMessageHandler::getAvailability()
265 am::am_Availability_s availability;
266 if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter))
268 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getAvailability DBUS handler argument is no struct!");
269 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
270 mErrorMsg = "DBus argument is no struct";
274 DBusMessageIter structIter;
275 dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
276 availability.availability = static_cast<am_Availablility_e>(getInt(structIter, true));
277 availability.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(structIter, false));
278 dbus_message_iter_next(&mDBusMessageIter);
280 return (availability);
283 std::vector<am_EarlyData_s> CAmRoutingDbusMessageHandler::getEarlyData()
285 std::vector<am_EarlyData_s> listEarlyData;
286 if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter))
288 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getProperty DBUS handler argument is no array!");
289 mErrorName = std::string(DBUS_ERROR_INVALID_ARGS);
290 mErrorMsg = "DBus argument is no array";
294 DBusMessageIter arrayIter, structIter, soundpropIter;
295 am_EarlyData_s earlyData;
297 //first the volume array
300 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
301 dbus_message_iter_recurse(&arrayIter, &structIter);
302 earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
303 if (earlyData.type==ED_SINK_VOLUME)
304 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
306 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
307 earlyData.data.volume = static_cast<am_volume_t>(getInt(structIter, false));
308 listEarlyData.push_back(earlyData);
309 } while (dbus_message_iter_next(&arrayIter));
310 dbus_message_iter_next(&mDBusMessageIter);
312 //then the soundproperty array
315 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
316 dbus_message_iter_recurse(&arrayIter, &structIter);
317 earlyData.type = static_cast<am_EarlyDataType_e>(getUInt(structIter, true));
318 if (earlyData.type==ED_SINK_PROPERTY)
319 earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
321 earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
322 dbus_message_iter_recurse(&structIter, &soundpropIter);
323 earlyData.data.soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(soundpropIter, true));
324 earlyData.data.soundProperty.value = (getInt(soundpropIter, false));
325 listEarlyData.push_back(earlyData);
326 } while (dbus_message_iter_next(&arrayIter));
328 return (listEarlyData);
331 am_Domain_s CAmRoutingDbusMessageHandler::getDomainData()
333 am_Domain_s domainData;
334 domainData.domainID = static_cast<am_domainID_t>(getUInt());
335 domainData.name = getString();
336 domainData.busname = getString();
337 domainData.nodename = getString();
338 domainData.early = getBool();
339 domainData.complete = getBool();
340 domainData.state = static_cast<am_DomainState_e>(getUInt());
344 am_Source_s CAmRoutingDbusMessageHandler::getSourceData()
346 am_Source_s sourceData;
347 DBusMessageIter availIter, arrayIter, structIter;
348 am_SoundProperty_s soundProperty;
349 am_ConnectionFormat_e connectionFormat;
350 am_MainSoundProperty_s mainSoundProperty;
351 sourceData.sourceID = static_cast<am_sourceID_t>(getUInt());
352 sourceData.domainID = static_cast<am_domainID_t>(getUInt());
353 sourceData.name = getString();
354 sourceData.sourceClassID = static_cast<am_sourceClass_t>(getUInt());
355 sourceData.sourceState = static_cast<am_SourceState_e>(getUInt());
356 sourceData.volume = static_cast<am_volume_t>(getInt());
357 sourceData.visible = getBool();
358 dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
359 sourceData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
360 sourceData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
361 dbus_message_iter_next(&mDBusMessageIter);
362 sourceData.interruptState = static_cast<am_InterruptState_e>(getUInt());
363 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
366 dbus_message_iter_recurse(&arrayIter, &structIter);
367 soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
368 soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
369 sourceData.listSoundProperties.push_back(soundProperty);
370 } while (dbus_message_iter_next(&arrayIter));
371 dbus_message_iter_next(&mDBusMessageIter);
372 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
375 connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
376 sourceData.listConnectionFormats.push_back(connectionFormat);
377 } while (dbus_message_iter_next(&arrayIter));
378 dbus_message_iter_next(&mDBusMessageIter);
380 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
383 dbus_message_iter_recurse(&arrayIter, &structIter);
384 mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
385 mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
386 sourceData.listMainSoundProperties.push_back(mainSoundProperty);
387 } while (dbus_message_iter_next(&arrayIter));
391 am_Sink_s CAmRoutingDbusMessageHandler::getSinkData()
394 DBusMessageIter structIter, availIter, arrayIter;
395 am_SoundProperty_s soundProperty;
396 am_ConnectionFormat_e connectionFormat;
397 am_MainSoundProperty_s mainSoundProperty;
398 sinkData.sinkID = static_cast<am_sinkID_t>(getUInt());
399 sinkData.name = getString();
400 sinkData.domainID = static_cast<am_domainID_t>(getUInt());
401 sinkData.sinkClassID = static_cast<am_sinkClass_t>(getUInt());
402 sinkData.volume = static_cast<am_volume_t>(getInt());
403 sinkData.visible = getBool();
404 dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
405 sinkData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
406 sinkData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
407 dbus_message_iter_next(&mDBusMessageIter);
408 sinkData.muteState = static_cast<am_MuteState_e>(getInt());
409 sinkData.mainVolume = static_cast<am_mainVolume_t>(getInt());
411 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
414 dbus_message_iter_recurse(&arrayIter, &structIter);
415 soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
416 soundProperty.value = static_cast<int16_t>(getInt(structIter, false));
417 sinkData.listSoundProperties.push_back(soundProperty);
418 } while (dbus_message_iter_next(&arrayIter));
420 dbus_message_iter_next(&mDBusMessageIter);
422 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
425 connectionFormat = static_cast<am_ConnectionFormat_e>(getInt(arrayIter, false));
426 sinkData.listConnectionFormats.push_back(connectionFormat);
427 } while (dbus_message_iter_next(&arrayIter));
428 dbus_message_iter_next(&mDBusMessageIter);
430 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
433 dbus_message_iter_recurse(&arrayIter, &structIter);
434 mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
435 mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
436 sinkData.listMainSoundProperties.push_back(mainSoundProperty);
437 } while (dbus_message_iter_next(&arrayIter));
441 am_Gateway_s CAmRoutingDbusMessageHandler::getGatewayData()
443 am_Gateway_s gatewayData;
444 DBusMessageIter arrayIter;
445 am_ConnectionFormat_e connectionFormat;
447 gatewayData.gatewayID = static_cast<am_gatewayID_t>(getUInt());
448 gatewayData.name = getString();
449 gatewayData.sinkID = static_cast<am_sinkID_t>(getUInt());
450 gatewayData.sourceID = static_cast<am_sourceID_t>(getUInt());
451 gatewayData.domainSinkID = static_cast<am_domainID_t>(getUInt());
452 gatewayData.domainSourceID = static_cast<am_domainID_t>(getUInt());
453 gatewayData.controlDomainID = static_cast<am_domainID_t>(getUInt());
456 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
457 connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
458 gatewayData.listSourceFormats.push_back(connectionFormat);
459 } while (dbus_message_iter_next(&arrayIter));
460 dbus_message_iter_next(&mDBusMessageIter);
463 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
464 connectionFormat = static_cast<am_ConnectionFormat_e>(getUInt(arrayIter, false));
465 gatewayData.listSinkFormats.push_back(connectionFormat);
466 } while (dbus_message_iter_next(&arrayIter));
467 dbus_message_iter_next(&mDBusMessageIter);
470 dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
471 convertion = getBool(arrayIter, false);
472 gatewayData.convertionMatrix.push_back(connectionFormat);
473 } while (dbus_message_iter_next(&arrayIter));
474 return (gatewayData);
477 am_MainSoundProperty_s CAmRoutingDbusMessageHandler::getMainSoundProperty()
479 am_MainSoundProperty_s mainSoundProperty;
480 DBusMessageIter structIter;
482 dbus_message_iter_recurse(&mDBusMessageIter, &structIter);
483 mainSoundProperty.type = static_cast<am_MainSoundPropertyType_e>(getInt(structIter, true));
484 mainSoundProperty.value = static_cast<int16_t>(getInt(structIter, false));
485 dbus_message_iter_next(&mDBusMessageIter);
487 return (mainSoundProperty);
490 void CAmRoutingDbusMessageHandler::append(bool toAppend)
492 dbus_bool_t mybool = toAppend;
493 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool))
495 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
496 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
497 mErrorMsg = "Cannot create reply!";
501 void CAmRoutingDbusMessageHandler::append(double toAppend)
503 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend))
505 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
506 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
507 mErrorMsg = "Cannot create reply!";
511 void CAmRoutingDbusMessageHandler::append(char toAppend)
513 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend))
515 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
516 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
517 mErrorMsg = "Cannot create reply!";
521 void CAmRoutingDbusMessageHandler::append(dbus_int16_t toAppend)
523 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend))
525 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
526 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
527 mErrorMsg = "Cannot create reply!";
531 void CAmRoutingDbusMessageHandler::append(dbus_uint16_t toAppend)
533 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend))
535 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
536 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
537 mErrorMsg = "Cannot create reply!";
541 void CAmRoutingDbusMessageHandler::setDBusConnection(DBusConnection*& connection)
543 assert(connection != NULL);
544 mpDBusConnection = connection;
547 void CAmRoutingDbusMessageHandler::append(const am::am_SinkType_s& sinkType)
549 DBusMessageIter structIter;
550 DBusMessageIter structAvailIter;
551 dbus_bool_t success = true;
552 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
553 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID);
554 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name);
555 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
556 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability);
557 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason);
558 success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
559 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume);
560 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState);
561 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID);
562 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
565 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
566 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
567 mErrorMsg = "Cannot create reply!";
571 void CAmRoutingDbusMessageHandler::append(const am::am_SourceType_s& sourceType)
573 DBusMessageIter structIter;
574 DBusMessageIter structAvailIter;
575 dbus_bool_t success = true;
576 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
577 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID);
578 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name);
579 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
580 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability);
581 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason);
582 success = success && dbus_message_iter_close_container(&structIter, &structAvailIter);
583 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID);
584 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
587 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
588 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
589 mErrorMsg = "Cannot create reply!";
593 void CAmRoutingDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty)
595 DBusMessageIter structIter;
596 dbus_bool_t success = true;
597 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
598 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type);
599 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value);
600 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
603 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
604 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
605 mErrorMsg = "Cannot create reply!";
609 void CAmRoutingDbusMessageHandler::append(const am::am_Availability_s& availability)
611 DBusMessageIter structAvailIter;
612 dbus_bool_t success = true;
613 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter);
614 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability);
615 success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason);
616 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter);
619 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
620 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
621 mErrorMsg = "Cannot create reply!";
625 void CAmRoutingDbusMessageHandler::append(const am::am_SystemProperty_s& SystemProperty)
627 DBusMessageIter structIter;
628 dbus_bool_t success = true;
629 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter);
630 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type);
631 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value);
632 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter);
635 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
636 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
637 mErrorMsg = "Cannot create reply!";
641 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
643 DBusMessageIter arrayIter;
644 DBusMessageIter structIter;
645 std::vector<am::am_MainConnectionType_s>::const_iterator listIterator = listMainConnections.begin();
646 dbus_bool_t success = true;
647 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter);
648 for (; listIterator < listMainConnections.end(); ++listIterator)
650 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
651 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID);
652 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
653 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
654 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay);
655 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState);
656 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
658 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
661 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
662 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
663 mErrorMsg = "Cannot create reply!";
667 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkType_s>& listMainSinks)
669 DBusMessageIter arrayIter;
670 DBusMessageIter structIter;
671 DBusMessageIter availIter;
672 std::vector<am::am_SinkType_s>::const_iterator listIterator = listMainSinks.begin();
673 dbus_bool_t success = true;
674 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter);
675 for (; listIterator < listMainSinks.end(); ++listIterator)
677 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
678 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID);
679 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
680 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
681 success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
682 success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
683 success = success && dbus_message_iter_close_container(&structIter, &availIter);
684 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume);
685 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState);
686 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
687 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
689 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
692 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
693 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
694 mErrorMsg = "Cannot create reply!";
698 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceType_s>& listMainSources)
700 DBusMessageIter arrayIter;
701 DBusMessageIter structIter;
702 DBusMessageIter availIter;
703 std::vector<am::am_SourceType_s>::const_iterator listIterator = listMainSources.begin();
704 dbus_bool_t success = true;
705 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter);
706 for (; listIterator < listMainSources.end(); ++listIterator)
708 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
709 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID);
710 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
711 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter);
712 success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability);
713 success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason);
714 success = success && dbus_message_iter_close_container(&structIter, &availIter);
715 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
716 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
718 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
721 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
722 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
723 mErrorMsg = "Cannot create reply!";
727 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s>& listMainSoundProperties)
729 DBusMessageIter arrayIter;
730 DBusMessageIter structIter;
731 std::vector<am::am_MainSoundProperty_s>::const_iterator listIterator = listMainSoundProperties.begin();
732 dbus_bool_t success = true;
733 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
734 for (; listIterator < listMainSoundProperties.end(); ++listIterator)
736 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
737 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
738 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
739 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
741 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
744 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
745 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
746 mErrorMsg = "Cannot create reply!";
750 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceClass_s>& listSourceClasses)
752 DBusMessageIter arrayIter;
753 DBusMessageIter structIter;
754 DBusMessageIter propIter;
755 DBusMessageIter innerIter;
756 std::vector<am::am_SourceClass_s>::const_iterator listIterator = listSourceClasses.begin();
757 dbus_bool_t success = true;
758 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
759 for (; listIterator < listSourceClasses.end(); ++listIterator)
761 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
762 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID);
763 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
764 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
766 std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
767 for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
769 success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
770 success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
771 success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
772 success = success && dbus_message_iter_close_container(&innerIter, &propIter);
774 success = success && dbus_message_iter_close_container(&structIter, &innerIter);
775 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
777 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
780 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
781 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
782 mErrorMsg = "Cannot create reply!";
786 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkClass_s>& listSinkClasses)
788 DBusMessageIter arrayIter;
789 DBusMessageIter structIter;
790 DBusMessageIter propIter;
791 DBusMessageIter innerIter;
792 std::vector<am::am_SinkClass_s>::const_iterator listIterator = listSinkClasses.begin();
793 dbus_bool_t success = true;
794 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter);
795 for (; listIterator < listSinkClasses.end(); ++listIterator)
797 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
798 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID);
799 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name);
800 success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter);
802 std::vector<am::am_ClassProperty_s>::const_iterator listInnerIterator = listIterator->listClassProperties.begin();
803 for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator)
805 success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter);
806 success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty);
807 success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value);
808 success = success && dbus_message_iter_close_container(&innerIter, &propIter);
810 success = success && dbus_message_iter_close_container(&structIter, &innerIter);
811 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
813 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
817 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
818 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
819 mErrorMsg = "Cannot create reply!";
824 void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s>& listSystemProperties)
826 DBusMessageIter arrayIter;
827 DBusMessageIter structIter;
828 std::vector<am::am_SystemProperty_s>::const_iterator listIterator = listSystemProperties.begin();
829 dbus_bool_t success = true;
830 success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter);
831 for (; listIterator < listSystemProperties.end(); ++listIterator)
833 success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter);
834 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type);
835 success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value);
836 success = success && dbus_message_iter_close_container(&arrayIter, &structIter);
838 success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter);
841 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
842 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
843 mErrorMsg = "Cannot create reply!";
847 void CAmRoutingDbusMessageHandler::append(const am::am_Error_e error)
849 if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &error))
851 log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!");
852 mErrorName = std::string(DBUS_ERROR_NO_MEMORY);
853 mErrorMsg = "Cannot create reply!";