From 06476e68a42077a0597628dca1c4a53cd20f5236 Mon Sep 17 00:00:00 2001 From: christian mueller Date: Wed, 4 Apr 2012 15:27:10 +0200 Subject: * some enhancement to routingPluginDbus to make to get acces to all interfaces and handle multiple domains Signed-off-by: christian mueller --- PluginRoutingInterfaceDbus/CMakeLists.txt | 3 + .../include/CAmDbusMessageHandler.h | 36 +- PluginRoutingInterfaceDbus/include/CAmDbusSend.h | 40 +- .../include/CAmRoutingSenderDbus.h | 78 +- .../include/IAmRoutingReceiverShadow.h | 143 ++-- .../include/RoutingReceiver.xml | 234 +++-- .../include/RoutingSender.xml | 85 ++ .../src/CAmDbusMessageHandler.cpp | 944 +++++++++++++-------- PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp | 187 ++-- .../src/CAmRoutingSenderDbus.cpp | 360 +++++--- .../src/IAmRoutingReceiverShadow.cpp | 930 ++++++++++++-------- 11 files changed, 1958 insertions(+), 1082 deletions(-) create mode 100644 PluginRoutingInterfaceDbus/include/RoutingSender.xml diff --git a/PluginRoutingInterfaceDbus/CMakeLists.txt b/PluginRoutingInterfaceDbus/CMakeLists.txt index 5781bf9..4f8ade9 100644 --- a/PluginRoutingInterfaceDbus/CMakeLists.txt +++ b/PluginRoutingInterfaceDbus/CMakeLists.txt @@ -58,6 +58,9 @@ IF(WITH_TESTS) # add_subdirectory (test) ENDIF(WITH_TESTS) +execute_process(COMMAND cp "${CMAKE_SOURCE_DIR}/PluginRoutingInterfaceDbus/${INCLUDE_FOLDER}/RoutingReceiver.xml" ${EXECUTABLE_OUTPUT_PATH}/RoutingReceiver.xml) +execute_process(COMMAND cp "${CMAKE_SOURCE_DIR}/PluginRoutingInterfaceDbus/${INCLUDE_FOLDER}/RoutingSender.xml" ${EXECUTABLE_OUTPUT_PATH}/RoutingSender.xml) + #IF(WITH_DOCUMENTATION) # file(MAKE_DIRECTORY ${DOC_OUTPUT_PATH}) # configure_file(${DOXY_FILE} ${DOC_OUTPUT_PATH}/Doxyfile @ONLY IMMEDIATE) diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h index 69f5d34..03d9eca 100644 --- a/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h +++ b/PluginRoutingInterfaceDbus/include/CAmDbusMessageHandler.h @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -19,13 +21,12 @@ #define _CAMSDBUSMESSAGEHANDLER_H_ -#include #include -#include #include #include #include #include +#include "audiomanagertypes.h" namespace am { @@ -33,11 +34,11 @@ namespace am { /** * handles DBus Messages, is used to extract & append parameters and send messages */ -class CAmDbusMessageHandler +class CAmRoutingDbusMessageHandler { public: - CAmDbusMessageHandler(); - ~CAmDbusMessageHandler(); + CAmRoutingDbusMessageHandler(); + ~CAmRoutingDbusMessageHandler(); /** * sets the DBus Connection @@ -75,14 +76,24 @@ public: * @return */ dbus_uint16_t getUInt(); + dbus_uint16_t getUInt(DBusMessageIter& iter, bool next); dbus_int16_t getInt(); - dbus_uint32_t getUInt32(); - dbus_int32_t getInt32(); + dbus_int16_t getInt(DBusMessageIter& iter, bool next); dbus_bool_t getBool(); + dbus_bool_t getBool(DBusMessageIter& iter, bool next); char getByte(); + char getByte(DBusMessageIter& iter, bool next); double getDouble(); + double getDouble(DBusMessageIter& iter, bool next); char* getString(); - void getProperty(dbus_int16_t& type, dbus_int16_t& value); + char* getString(DBusMessageIter& iter, bool next); + am::am_Availability_s getAvailability(); + std::vector getEarlyData(); + am_Domain_s getDomainData(); + am_Source_s getSourceData(); + am_Sink_s getSinkData(); + am_Gateway_s getGatewayData(); + am_MainSoundProperty_s getMainSoundProperty(); /** * the overloaded append function appends different datatypes to the dbusmessage @@ -93,6 +104,7 @@ public: void append(char toAppend); void append(bool toAppend); void append(double toAppend); + void append(const am::am_Error_e error); void append(const am::am_SinkType_s& sinkType); void append(const am::am_SourceType_s& sourceType); void append(const am::am_MainSoundProperty_s mainSoundProperty); @@ -113,9 +125,9 @@ private: dbus_uint32_t mSerial; std::string mErrorName; std::string mErrorMsg; - DBusMessage* mDbusMessage; - DBusMessage* mReveiveMessage; - DBusConnection* mDBusConnection; + DBusMessage* mpDBusMessage; + DBusMessage* mpReveiveMessage; + DBusConnection* mpDBusConnection; }; } diff --git a/PluginRoutingInterfaceDbus/include/CAmDbusSend.h b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h index 65fe0bd..3f8f0a5 100644 --- a/PluginRoutingInterfaceDbus/include/CAmDbusSend.h +++ b/PluginRoutingInterfaceDbus/include/CAmDbusSend.h @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -20,25 +22,31 @@ //#include "headers.h" #include +#include +#include +#include "audiomanagertypes.h" -class CAmDbusSend { +namespace am +{ + +class CAmRoutingDbusSend +{ public: - CAmDbusSend(DBusConnection* conn, const char* bus_name,const char* path, const char* interface, const char* method); - virtual ~CAmDbusSend(); - void appendString(char* string); - void appendInteger(int integer); - void sendReply(bool* reply); - void sendReply(int* reply); - void sendReply(void); - void Replyint32(int *reply); + CAmRoutingDbusSend(DBusConnection* conn, std::string bus_name, std::string path, std::string interface, std::string method); + virtual ~CAmRoutingDbusSend(); + void append(std::string string); + void append(uint16_t integer); + void append(int16_t integer); + void append(std::vector listSoundProperties); + void append(am_SoundProperty_s soundProperty); + am_Error_e send(); private: - DBusMessage* m_msg; - DBusMessageIter m_args; - DBusConnection* m_conn; - DBusMessage* replymsg; - //DBusMessageIter args; - DBusMessageIter mDBusMessageIter; + DBusMessage* mpDbusMessage; + DBusConnection* mpDbusConnection; + DBusMessageIter mDbusMessageIter; + DBusError mDBusError; }; +} #endif /* _CAMDBUSSEND_H_ */ diff --git a/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h b/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h index fb727a3..751f5ae 100644 --- a/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h +++ b/PluginRoutingInterfaceDbus/include/CAmRoutingSenderDbus.h @@ -19,48 +19,72 @@ #define ROUTINGSENDER_H_ #include "routing/IAmRoutingSend.h" -#include -#include #include "CAmDbusMessageHandler.h" #include "IAmRoutingReceiverShadow.h" -#include "shared/CAmDbusWrapper.h" -using namespace am; +namespace am +{ -const char ROUTING_NODE[]="RoutingReceiver"; +#define ROUTING_NODE "RoutingInterface" class CAmRoutingSenderDbus: public IAmRoutingSend { public: CAmRoutingSenderDbus(); virtual ~CAmRoutingSenderDbus(); - am_Error_e startupInterface(IAmRoutingReceive* routingreceiveinterface) ; - void setRoutingReady(const uint16_t handle) ; - void setRoutingRundown(const uint16_t handle) ; - am_Error_e asyncAbort(const am_Handle_s handle) ; - am_Error_e asyncConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat) ; - am_Error_e asyncDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID) ; - am_Error_e asyncSetSinkVolume(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time) ; - am_Error_e asyncSetSourceVolume(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time) ; - am_Error_e asyncSetSourceState(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state) ; - am_Error_e asyncSetSinkSoundProperties(const am_Handle_s handle, const am_sinkID_t sinkID, const std::vector& listSoundProperties) ; - am_Error_e asyncSetSinkSoundProperty(const am_Handle_s handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty) ; - am_Error_e asyncSetSourceSoundProperties(const am_Handle_s handle, const am_sourceID_t sourceID, const std::vector& listSoundProperties) ; - am_Error_e asyncSetSourceSoundProperty(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty) ; - am_Error_e asyncCrossFade(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time) ; - am_Error_e setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) ; - am_Error_e returnBusName(std::string& BusName) const ; - void getInterfaceVersion(std::string& version) const ; + am_Error_e startupInterface(IAmRoutingReceive* pIAmRoutingReceive); + void setRoutingReady(const uint16_t handle); + void setRoutingRundown(const uint16_t handle); + am_Error_e asyncAbort(const am_Handle_s handle); + am_Error_e asyncConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat); + am_Error_e asyncDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID); + am_Error_e asyncSetSinkVolume(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time); + am_Error_e asyncSetSourceVolume(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time); + am_Error_e asyncSetSourceState(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state); + am_Error_e asyncSetSinkSoundProperties(const am_Handle_s handle, const am_sinkID_t sinkID, const std::vector& listSoundProperties); + am_Error_e asyncSetSinkSoundProperty(const am_Handle_s handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty); + am_Error_e asyncSetSourceSoundProperties(const am_Handle_s handle, const am_sourceID_t sourceID, const std::vector& listSoundProperties); + am_Error_e asyncSetSourceSoundProperty(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty); + am_Error_e asyncCrossFade(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time); + am_Error_e setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState); + am_Error_e returnBusName(std::string& BusName) const; + void getInterfaceVersion(std::string& version) const; + + struct rs_lookupData_s + { + std::string busname; + std::string path; + std::string interface; + }; + + void removeHandle(uint16_t handle); + void addDomainLookup(am_domainID_t domainID, rs_lookupData_s lookupData); + void addSourceLookup(am_sourceID_t sourceID, am_domainID_t domainID); + void addSinkLookup(am_sinkID_t sinkID, am_domainID_t domainID); + void removeDomainLookup(am_domainID_t domainID); + void removeSourceLookup(am_sourceID_t sourceID); + void removeSinkLookup(am_sinkID_t sinkID); private: - CAmDbusMessageHandler mDBusMessageHandler; - IAmRoutingReceiverShadow mRoutingReceiverShadow; + CAmDbusWrapper* mpCAmDBusWrapper; + IAmRoutingReceive *mpIAmRoutingReceive; + DBusConnection* mpDBusConnection; + CAmRoutingDbusMessageHandler mCAmRoutingDBusMessageHandler; + IAmRoutingReceiverShadowDbus mIAmRoutingReceiverShadowDbus; - CAmDbusWrapper* mDBusWrapper; - IAmRoutingReceive *mRoutingReceiveInterface; + typedef std::map mapDomain_t; + typedef std::map mapSinks_t; + typedef std::map mapSources_t; + typedef std::map mapConnections_t; + typedef std::map mapHandles_t; + mapDomain_t mMapDomains; + mapSinks_t mMapSinks; + mapSources_t mMapSources; + mapConnections_t mMapConnections; + mapHandles_t mMapHandles; - DBusConnection* connection; }; +} #endif /* ROUTINGSENDER_H_ */ diff --git a/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h index 4cd1b2d..642ab6f 100644 --- a/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h +++ b/PluginRoutingInterfaceDbus/include/IAmRoutingReceiverShadow.h @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -18,79 +20,108 @@ #ifndef _IAMROUTINGRECEIVERSHADOW_H_ #define _IAMROUTINGRECEIVERSHADOW_H_ -#include "routing/IAmRoutingSend.h" #include -#include #include -#include "shared/CAmDbusWrapper.h" #include "CAmDbusMessageHandler.h" namespace am { -class IAmRoutingReceiverShadow; - -typedef void (IAmRoutingReceiverShadow::*CallBackMethod)(DBusConnection *connection, DBusMessage *message); +class CAmRoutingSenderDbus; +class IAmRoutingReceive; +class CAmDbusWrapper; /** * receives the DBus Callbacks, marhsalls and demarshalls the parameters and calls CommandReceive */ -class IAmRoutingReceiverShadow { +class IAmRoutingReceiverShadowDbus +{ public: - IAmRoutingReceiverShadow(); - virtual ~IAmRoutingReceiverShadow(); - void ackConnect(DBusConnection *conn, DBusMessage *msg) ; - void ackDisconnect(DBusConnection *conn, DBusMessage *msg) ; - void ackSetSinkVolume(DBusConnection *conn, DBusMessage *msg); - void ackSetSourceVolume(DBusConnection *conn, DBusMessage *msg); - void ackSinkVolumeTick(DBusConnection *conn, DBusMessage *msg); - void ackSourceVolumeTick(DBusConnection *conn, DBusMessage *msg); - void ackSetSinkSoundProperty(DBusConnection *conn, DBusMessage *msg); - void ackSetSourceSoundProperty(DBusConnection *conn, DBusMessage *msg); + IAmRoutingReceiverShadowDbus(CAmRoutingSenderDbus* pRoutingSenderDbus); + virtual ~IAmRoutingReceiverShadowDbus(); + void ackConnect(DBusConnection *conn, DBusMessage *msg); + void ackDisconnect(DBusConnection *conn, DBusMessage *msg); + void ackSetSinkVolume(DBusConnection *conn, DBusMessage *msg); + void ackSetSourceVolume(DBusConnection *conn, DBusMessage *msg); + void ackSetSourceState(DBusConnection *conn, DBusMessage *msg); + void ackSinkVolumeTick(DBusConnection *conn, DBusMessage *msg); + void ackSourceVolumeTick(DBusConnection *conn, DBusMessage *msg); + void ackSetSinkSoundProperty(DBusConnection *conn, DBusMessage *msg); + void ackSetSourceSoundProperty(DBusConnection *conn, DBusMessage *msg); + void ackSetSinkSoundProperties(DBusConnection *conn, DBusMessage *msg); + void ackSetSourceSoundProperties(DBusConnection *conn, DBusMessage *msg); + void ackCrossFading(DBusConnection *conn, DBusMessage *msg); + void registerDomain(DBusConnection *conn, DBusMessage *msg); + void registerSource(DBusConnection *conn, DBusMessage *msg); + void registerSink(DBusConnection *conn, DBusMessage *msg); + void registerGateway(DBusConnection *conn, DBusMessage *msg); + void peekDomain(DBusConnection *conn, DBusMessage *msg); + void deregisterDomain(DBusConnection *conn, DBusMessage *msg); + void deregisterGateway(DBusConnection *conn, DBusMessage *msg); + void peekSink(DBusConnection *conn, DBusMessage *msg); + void deregisterSink(DBusConnection *conn, DBusMessage *msg); + void peekSource(DBusConnection *conn, DBusMessage *msg); + void deregisterSource(DBusConnection *conn, DBusMessage *msg); + void registerCrossfader(DBusConnection *conn, DBusMessage *msg); + void deregisterCrossfader(DBusConnection *conn, DBusMessage *msg); + void peekSourceClassID(DBusConnection *conn, DBusMessage *msg); + void peekSinkClassID(DBusConnection *conn, DBusMessage *msg); + void hookInterruptStatusChange(DBusConnection *conn, DBusMessage *msg); + void hookDomainRegistrationComplete(DBusConnection *conn, DBusMessage *msg); + void hookSinkAvailablityStatusChange(DBusConnection *conn, DBusMessage *msg); + void hookSourceAvailablityStatusChange(DBusConnection *conn, DBusMessage *msg); + void hookDomainStateChange(DBusConnection *conn, DBusMessage *msg); + void hookTimingInformationChanged(DBusConnection *conn, DBusMessage *msg); + void sendChangedData(DBusConnection *conn, DBusMessage *msg); + void confirmRoutingReady(DBusConnection *conn, DBusMessage *msg); + void confirmRoutingRundown(DBusConnection *conn, DBusMessage *msg); + + /** + * sets the pointer to the CommandReceiveInterface and registers Callback + * @param receiver + */ + void setRoutingReceiver(IAmRoutingReceive*& receiver); - void registerDomain(DBusConnection *conn, DBusMessage *msg) ; - void registerSource(DBusConnection *conn, DBusMessage *msg) ; - void registerSink(DBusConnection *conn, DBusMessage *msg) ; - void registerGateway(DBusConnection *conn, DBusMessage *msg) ; - void hookDomainRegistrationComplete(DBusConnection *conn, DBusMessage *msg); + void gotReady(int16_t numberDomains, uint16_t handle); + void gotRundown(int16_t numberDomains, uint16_t handle); - /** - * sets the pointer to the CommandReceiveInterface and registers Callback - * @param receiver - */ - void setRoutingReceiver(IAmRoutingReceive*& receiver); private: - IAmRoutingReceive* mRoutingReceiveInterface; - CAmDbusWrapper* mDBusWrapper; - typedef std::map functionMap_t; - functionMap_t mFunctionMap; - CAmDbusMessageHandler mDBUSMessageHandler; + typedef void (IAmRoutingReceiverShadowDbus::*CallBackMethod)(DBusConnection *connection, DBusMessage *message); + IAmRoutingReceive* mRoutingReceiveInterface; + CAmDbusWrapper* mDBusWrapper; + CAmRoutingSenderDbus* mpRoutingSenderDbus; + + typedef std::map functionMap_t; + functionMap_t mFunctionMap; + CAmRoutingDbusMessageHandler mDBUSMessageHandler; + int16_t mNumberDomains; + uint16_t mHandle; - /** - * receives a callback whenever the path of the plugin is called - */ - static DBusHandlerResult receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data); + /** + * receives a callback whenever the path of the plugin is called + */ + static DBusHandlerResult receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data); - /** - * dynamic delegate that handles the Callback of the static receiveCallback - * @param conn DBus connection - * @param msg DBus message - * @param user_data pointer to instance of IAmRoutingReceiverShadow - * @return - */ - DBusHandlerResult receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg); + /** + * dynamic delegate that handles the Callback of the static receiveCallback + * @param conn DBus connection + * @param msg DBus message + * @param user_data pointer to instance of IAmRoutingReceiverShadow + * @return + */ + DBusHandlerResult receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg); - /** - * sends out introspectiondata read from an xml file. - * @param conn - * @param msg - */ - void sendIntrospection(DBusConnection* conn, DBusMessage* msg) ; + /** + * sends out introspectiondata read from an xml file. + * @param conn + * @param msg + */ + void sendIntrospection(DBusConnection* conn, DBusMessage* msg); - /** - * creates the function map needed to combine DBus messages and function adresses - * @return the map - */ - functionMap_t createMap(); + /** + * creates the function map needed to combine DBus messages and function adresses + * @return the map + */ + functionMap_t createMap(); }; } diff --git a/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml index 78e06e3..a263966 100644 --- a/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml +++ b/PluginRoutingInterfaceDbus/include/RoutingReceiver.xml @@ -5,80 +5,170 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/PluginRoutingInterfaceDbus/include/RoutingSender.xml b/PluginRoutingInterfaceDbus/include/RoutingSender.xml new file mode 100644 index 0000000..7841218 --- /dev/null +++ b/PluginRoutingInterfaceDbus/include/RoutingSender.xml @@ -0,0 +1,85 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp index 2e6817d..65b77b6 100644 --- a/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp +++ b/PluginRoutingInterfaceDbus/src/CAmDbusMessageHandler.cpp @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -16,617 +18,843 @@ */ #include "CAmDbusMessageHandler.h" -#include "CAmRoutingSenderDbus.h" #include "config.h" - -#include -#include +#include +#include #include +#include "CAmRoutingSenderDbus.h" +#include "shared/CAmDltWrapper.h" -using namespace am; +namespace am +{ -DLT_IMPORT_CONTEXT(DLT_CONTEXT) +DLT_IMPORT_CONTEXT(routingDbus) -CAmDbusMessageHandler::CAmDbusMessageHandler() -: mDBusMessageIter(), - mDBusError(), - mSerial(0), - mErrorName(""), - mErrorMsg(""), - mDbusMessage(NULL), - mReveiveMessage(NULL), - mDBusConnection(NULL) +CAmRoutingDbusMessageHandler::CAmRoutingDbusMessageHandler() : + mDBusMessageIter(), // + mDBusError(), // + mSerial(0), // + mErrorName(""), // + mErrorMsg(""), // + mpDBusMessage(NULL), // + mpReveiveMessage(NULL), // + mpDBusConnection(NULL) { + log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler constructed"); } -CAmDbusMessageHandler::~CAmDbusMessageHandler() +CAmRoutingDbusMessageHandler::~CAmRoutingDbusMessageHandler() { + log(&routingDbus, DLT_LOG_INFO, "DBUSMessageHandler destructed"); } -void CAmDbusMessageHandler::initReceive(DBusMessage* msg) +void CAmRoutingDbusMessageHandler::initReceive(DBusMessage* msg) { - assert(msg!=NULL); - mReveiveMessage=msg; + assert(msg!=NULL); + mpReveiveMessage = msg; if (!dbus_message_iter_init(msg, &mDBusMessageIter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBUS Message has no arguments!"; + log(&routingDbus, DLT_LOG_INFO, "DBusMessageHandler::initReceive DBus Message has no arguments!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBUS Message has no arguments!"; } } -void CAmDbusMessageHandler::initReply(DBusMessage* msg) +void CAmRoutingDbusMessageHandler::initReply(DBusMessage* msg) { - assert(msg!=NULL); - mDbusMessage = dbus_message_new_method_return(msg); - if (mDbusMessage==NULL) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + assert(msg!=NULL); + mpDBusMessage = dbus_message_new_method_return(msg); + if (mpDBusMessage == NULL) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initReply Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } - dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter); + dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter); } -void CAmDbusMessageHandler::initSignal(std::string path, std::string signalName) +void CAmRoutingDbusMessageHandler::initSignal(std::string path, std::string signalName) { - assert(!path.empty()); - assert(!signalName.empty()); - std::string completePath=std::string(DBUS_SERVICE_OBJECT_PATH)+"/"+path; - std::string objectpath=std::string(DBUS_SERVICE_PREFIX)+"."+path; - mDbusMessage=dbus_message_new_signal(completePath.c_str(),objectpath.c_str(),signalName.c_str()); - + assert(!path.empty()); + assert(!signalName.empty()); + std::string completePath = std::string(DBUS_SERVICE_OBJECT_PATH) + "/" + path; + mpDBusMessage = dbus_message_new_signal(completePath.c_str(), DBUS_SERVICE_PREFIX, signalName.c_str()); - dbus_message_iter_init_append(mDbusMessage, &mDBusMessageIter); + if (mpDBusMessage == NULL) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::initSignal Cannot allocate DBus message!"); + } + dbus_message_iter_init_append(mpDBusMessage, &mDBusMessageIter); } -void CAmDbusMessageHandler::sendMessage() +void CAmRoutingDbusMessageHandler::sendMessage() { - assert(mDBusConnection!=NULL); - if(mReveiveMessage!=0) - { - mSerial=dbus_message_get_serial(mReveiveMessage); - } - else - { - mSerial=1; - } - if (!mErrorName.empty()) { - mDbusMessage = dbus_message_new_error(mReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str()); - } - if (!dbus_connection_send(mDBusConnection, mDbusMessage, &mSerial)) + assert(mpDBusConnection!=NULL); + if (mpReveiveMessage != 0) + { + mSerial = dbus_message_get_serial(mpReveiveMessage); + } + else + { + mSerial = 1; + } + if (!mErrorName.empty()) + { + mpDBusMessage = dbus_message_new_error(mpReveiveMessage, mErrorName.c_str(), mErrorMsg.c_str()); + } + if (!dbus_connection_send(mpDBusConnection, mpDBusMessage, &mSerial)) { - ; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::sendMessage cannot send message!"); } - dbus_connection_flush(mDBusConnection); - dbus_message_unref(mDbusMessage); - mDbusMessage = NULL; + dbus_connection_flush(mpDBusConnection); + dbus_message_unref(mpDBusMessage); + mpDBusMessage = NULL; } -char* CAmDbusMessageHandler::getString() +char* CAmRoutingDbusMessageHandler::getString(DBusMessageIter& iter, bool next) { - char* param=NULL; + char* param = NULL; - if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&iter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no string"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getString DBUS handler argument is no String!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no string"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, ¶m); + if (next) + dbus_message_iter_next(&iter); } return (param); } -dbus_bool_t CAmDbusMessageHandler::getBool() +char* CAmRoutingDbusMessageHandler::getString() +{ + return (getString(mDBusMessageIter, true)); +} + +dbus_bool_t CAmRoutingDbusMessageHandler::getBool(DBusMessageIter& iter, bool next) { - dbus_bool_t boolparam=false; + dbus_bool_t boolparam = false; - if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&iter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no bool"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no bool!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no bool"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, &boolparam); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, &boolparam); + if (next) + dbus_message_iter_next(&iter); } return (boolparam); } -char CAmDbusMessageHandler::getByte() +dbus_bool_t CAmRoutingDbusMessageHandler::getBool() +{ + return (getBool(mDBusMessageIter, true)); +} + +char CAmRoutingDbusMessageHandler::getByte(DBusMessageIter& iter, bool next) { char param; - if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + if (DBUS_TYPE_BYTE != dbus_message_iter_get_arg_type(&iter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no byte"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getByte DBUS handler argument is no byte!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no byte"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, ¶m); + if (next) + dbus_message_iter_next(&iter); } return (param); } -dbus_uint16_t CAmDbusMessageHandler::getUInt() +char CAmRoutingDbusMessageHandler::getByte() { - dbus_uint16_t param; + return (getByte(mDBusMessageIter, true)); +} - if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter)) +dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt(DBusMessageIter& iter, bool next) +{ + dbus_uint16_t param; +#ifdef GLIB_DBUS_TYPES_TOLERANT + if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&iter)) +#else + if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&iter)) +#endif { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no uint16_t"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getUInt DBUS handler argument is no uint16_t!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no uint16_t"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, ¶m); + if (next) + dbus_message_iter_next(&iter); } return (param); } -dbus_int16_t CAmDbusMessageHandler::getInt() +dbus_uint16_t CAmRoutingDbusMessageHandler::getUInt() { - dbus_int16_t param; + return (getUInt(mDBusMessageIter, true)); +} - if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDBusMessageIter)) +dbus_int16_t CAmRoutingDbusMessageHandler::getInt(DBusMessageIter& iter, bool next) +{ + dbus_int16_t param; +#ifdef GLIB_DBUS_TYPES_TOLERANT + if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter) && DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&iter)) +#else + if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&iter)) +#endif { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no int16_t"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getInt DBUS handler argument is no int16_t!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no int16_t"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, ¶m); + if (next) + dbus_message_iter_next(&iter); } return (param); } -dbus_uint32_t CAmDbusMessageHandler::getUInt32() +dbus_int16_t CAmRoutingDbusMessageHandler::getInt() { - dbus_uint16_t param; + return (getInt(mDBusMessageIter, true)); +} - if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter)) +double CAmRoutingDbusMessageHandler::getDouble(DBusMessageIter& iter, bool next) +{ + double param; + if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&iter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no uint32_t"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getDouble DBUS handler argument is no double!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no double"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); - dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_get_basic(&iter, ¶m); + if (next) + dbus_message_iter_next(&iter); } return (param); } -dbus_int32_t CAmDbusMessageHandler::getInt32() +double CAmRoutingDbusMessageHandler::getDouble() { - dbus_int32_t param; + return (getDouble(mDBusMessageIter, true)); +} - if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter)) +am::am_Availability_s CAmRoutingDbusMessageHandler::getAvailability() +{ + am::am_Availability_s availability; + if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no int32_t"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getAvailability DBUS handler argument is no struct!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no struct"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); + DBusMessageIter structIter; + dbus_message_iter_recurse(&mDBusMessageIter, &structIter); + availability.availability = static_cast(getInt(structIter, true)); + availability.availabilityReason = static_cast(getInt(structIter, false)); dbus_message_iter_next(&mDBusMessageIter); } - return (param); + return (availability); } -double CAmDbusMessageHandler::getDouble() +std::vector CAmRoutingDbusMessageHandler::getEarlyData() { - double param; - if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + std::vector listEarlyData; + if (DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&mDBusMessageIter)) { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no double"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getProperty DBUS handler argument is no array!"); + mErrorName = std::string(DBUS_ERROR_INVALID_ARGS); + mErrorMsg = "DBus argument is no array"; } else { - dbus_message_iter_get_basic(&mDBusMessageIter, ¶m); + DBusMessageIter arrayIter, structIter, soundpropIter; + am_EarlyData_s earlyData; + + //first the volume array + do + { + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + dbus_message_iter_recurse(&arrayIter, &structIter); + earlyData.type = static_cast(getUInt(structIter, true)); + if (earlyData.type==ED_SINK_VOLUME) + earlyData.sinksource.sink = static_cast(getUInt(structIter, true)); + else + earlyData.sinksource.source = static_cast(getUInt(structIter, true)); + earlyData.data.volume = static_cast(getInt(structIter, false)); + listEarlyData.push_back(earlyData); + } while (dbus_message_iter_next(&arrayIter)); dbus_message_iter_next(&mDBusMessageIter); - } - return (param); -} -void CAmDbusMessageHandler::getProperty(dbus_int16_t & type, dbus_int16_t & value) -{ - DBusMessageIter arrayIter; - if (DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + //then the soundproperty array + do + { + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + dbus_message_iter_recurse(&arrayIter, &structIter); + earlyData.type = static_cast(getUInt(structIter, true)); + if (earlyData.type==ED_SINK_PROPERTY) + earlyData.sinksource.sink = static_cast(getUInt(structIter, true)); + else + earlyData.sinksource.source = static_cast(getUInt(structIter, true)); + dbus_message_iter_recurse(&structIter, &soundpropIter); + earlyData.data.soundProperty.type = static_cast(getInt(soundpropIter, true)); + earlyData.data.soundProperty.value = (getInt(soundpropIter, false)); + listEarlyData.push_back(earlyData); + } while (dbus_message_iter_next(&arrayIter)); + } + return (listEarlyData); +} + +am_Domain_s CAmRoutingDbusMessageHandler::getDomainData() +{ + am_Domain_s domainData; + domainData.domainID = static_cast(getUInt()); + domainData.name = getString(); + domainData.busname = getString(); + domainData.nodename = getString(); + domainData.early = getBool(); + domainData.complete = getBool(); + domainData.state = static_cast(getUInt()); + return (domainData); +} + +am_Source_s CAmRoutingDbusMessageHandler::getSourceData() +{ + am_Source_s sourceData; + DBusMessageIter availIter, arrayIter, structIter; + am_SoundProperty_s soundProperty; + am_ConnectionFormat_e connectionFormat; + am_MainSoundProperty_s mainSoundProperty; + sourceData.sourceID = static_cast(getUInt()); + sourceData.domainID = static_cast(getUInt()); + sourceData.name = getString(); + sourceData.sourceClassID = static_cast(getUInt()); + sourceData.sourceState = static_cast(getUInt()); + sourceData.volume = static_cast(getInt()); + sourceData.visible = getBool(); + dbus_message_iter_recurse(&mDBusMessageIter, &availIter); + sourceData.available.availability = static_cast(getInt(availIter, true)); + sourceData.available.availabilityReason = static_cast(getInt(availIter, false)); + dbus_message_iter_next(&mDBusMessageIter); + sourceData.interruptState = static_cast(getUInt()); + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + dbus_message_iter_recurse(&arrayIter, &structIter); + soundProperty.type = static_cast(getInt(structIter, true)); + soundProperty.value = static_cast(getInt(structIter, false)); + sourceData.listSoundProperties.push_back(soundProperty); + } while (dbus_message_iter_next(&arrayIter)); + dbus_message_iter_next(&mDBusMessageIter); + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + connectionFormat = static_cast(getInt(arrayIter, false)); + sourceData.listConnectionFormats.push_back(connectionFormat); + } while (dbus_message_iter_next(&arrayIter)); + dbus_message_iter_next(&mDBusMessageIter); + + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + dbus_message_iter_recurse(&arrayIter, &structIter); + mainSoundProperty.type = static_cast(getInt(structIter, true)); + mainSoundProperty.value = static_cast(getInt(structIter, false)); + sourceData.listMainSoundProperties.push_back(mainSoundProperty); + } while (dbus_message_iter_next(&arrayIter)); + return (sourceData); +} + +am_Sink_s CAmRoutingDbusMessageHandler::getSinkData() +{ + am_Sink_s sinkData; + DBusMessageIter structIter, availIter, arrayIter; + am_SoundProperty_s soundProperty; + am_ConnectionFormat_e connectionFormat; + am_MainSoundProperty_s mainSoundProperty; + sinkData.sinkID = static_cast(getUInt()); + sinkData.name = getString(); + sinkData.domainID = static_cast(getUInt()); + sinkData.sinkClassID = static_cast(getUInt()); + sinkData.volume = static_cast(getInt()); + sinkData.visible = getBool(); + dbus_message_iter_recurse(&mDBusMessageIter, &availIter); + sinkData.available.availability = static_cast(getInt(availIter, true)); + sinkData.available.availabilityReason = static_cast(getInt(availIter, false)); + dbus_message_iter_next(&mDBusMessageIter); + sinkData.muteState = static_cast(getInt()); + sinkData.mainVolume = static_cast(getInt()); + + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + dbus_message_iter_recurse(&arrayIter, &structIter); + soundProperty.type = static_cast(getInt(structIter, true)); + soundProperty.value = static_cast(getInt(structIter, false)); + sinkData.listSoundProperties.push_back(soundProperty); + } while (dbus_message_iter_next(&arrayIter)); + + dbus_message_iter_next(&mDBusMessageIter); + + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + connectionFormat = static_cast(getInt(arrayIter, false)); + sinkData.listConnectionFormats.push_back(connectionFormat); + } while (dbus_message_iter_next(&arrayIter)); + dbus_message_iter_next(&mDBusMessageIter); + + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + do + { + dbus_message_iter_recurse(&arrayIter, &structIter); + mainSoundProperty.type = static_cast(getInt(structIter, true)); + mainSoundProperty.value = static_cast(getInt(structIter, false)); + sinkData.listMainSoundProperties.push_back(mainSoundProperty); + } while (dbus_message_iter_next(&arrayIter)); + return (sinkData); +} + +am_Gateway_s CAmRoutingDbusMessageHandler::getGatewayData() +{ + am_Gateway_s gatewayData; + DBusMessageIter arrayIter; + am_ConnectionFormat_e connectionFormat; + bool convertion; + gatewayData.gatewayID = static_cast(getUInt()); + gatewayData.name = getString(); + gatewayData.sinkID = static_cast(getUInt()); + gatewayData.sourceID = static_cast(getUInt()); + gatewayData.domainSinkID = static_cast(getUInt()); + gatewayData.domainSourceID = static_cast(getUInt()); + gatewayData.controlDomainID = static_cast(getUInt()); + do { - mErrorName=std::string(DBUS_ERROR_INVALID_ARGS); - mErrorMsg="DBus argument is no array"; - } - else + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + connectionFormat = static_cast(getUInt(arrayIter, false)); + gatewayData.listSourceFormats.push_back(connectionFormat); + } while (dbus_message_iter_next(&arrayIter)); + dbus_message_iter_next(&mDBusMessageIter); + do { dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); - dbus_message_iter_get_basic(&arrayIter, &type); - dbus_message_iter_next(&arrayIter); - dbus_message_iter_get_basic(&arrayIter, &value); - dbus_message_iter_next(&mDBusMessageIter); - } + connectionFormat = static_cast(getUInt(arrayIter, false)); + gatewayData.listSinkFormats.push_back(connectionFormat); + } while (dbus_message_iter_next(&arrayIter)); + dbus_message_iter_next(&mDBusMessageIter); + do + { + dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter); + convertion = getBool(arrayIter, false); + gatewayData.convertionMatrix.push_back(connectionFormat); + } while (dbus_message_iter_next(&arrayIter)); + return (gatewayData); } -void CAmDbusMessageHandler::append(bool toAppend) +am_MainSoundProperty_s CAmRoutingDbusMessageHandler::getMainSoundProperty() { - dbus_bool_t mybool=toAppend; + am_MainSoundProperty_s mainSoundProperty; + DBusMessageIter structIter; + + dbus_message_iter_recurse(&mDBusMessageIter, &structIter); + mainSoundProperty.type = static_cast(getInt(structIter, true)); + mainSoundProperty.value = static_cast(getInt(structIter, false)); + dbus_message_iter_next(&mDBusMessageIter); + + return (mainSoundProperty); +} + +void CAmRoutingDbusMessageHandler::append(bool toAppend) +{ + dbus_bool_t mybool = toAppend; if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BOOLEAN, &mybool)) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } - -void CAmDbusMessageHandler::append(double toAppend) +void CAmRoutingDbusMessageHandler::append(double toAppend) { if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_DOUBLE, &toAppend)) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(char toAppend) +void CAmRoutingDbusMessageHandler::append(char toAppend) { if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_BYTE, &toAppend)) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } - -void CAmDbusMessageHandler::append(dbus_int16_t toAppend) +void CAmRoutingDbusMessageHandler::append(dbus_int16_t toAppend) { if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_INT16, &toAppend)) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(dbus_uint16_t toAppend) +void CAmRoutingDbusMessageHandler::append(dbus_uint16_t toAppend) { if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &toAppend)) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(dbus_uint32_t toAppend) +void CAmRoutingDbusMessageHandler::setDBusConnection(DBusConnection*& connection) { - if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT32, &toAppend)) - { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; - } + assert(connection != NULL); + mpDBusConnection = connection; } -void CAmDbusMessageHandler::setDBusConnection(DBusConnection *& connection) -{ - assert(connection!=NULL); - mDBusConnection=connection; -} - -void CAmDbusMessageHandler::append(const am::am_SinkType_s& sinkType) +void CAmRoutingDbusMessageHandler::append(const am::am_SinkType_s& sinkType) { DBusMessageIter structIter; DBusMessageIter structAvailIter; - dbus_bool_t success=true; - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name); - - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason); - success=success && dbus_message_iter_close_container(&structIter, &structAvailIter); - - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID); - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); - + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sinkType.name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availability); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sinkType.availability.availabilityReason); + success = success && dbus_message_iter_close_container(&structIter, &structAvailIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.volume); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &sinkType.muteState); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sinkType.sinkClassID); + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const am::am_SourceType_s & sourceType) +void CAmRoutingDbusMessageHandler::append(const am::am_SourceType_s& sourceType) { DBusMessageIter structIter; DBusMessageIter structAvailIter; - dbus_bool_t success=true; - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name); - - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason); - success=success && dbus_message_iter_close_container(&structIter, &structAvailIter); - - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID); - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); - + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &sourceType.name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availability); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &sourceType.availability.availabilityReason); + success = success && dbus_message_iter_close_container(&structIter, &structAvailIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &sourceType.sourceClassID); + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty) +void CAmRoutingDbusMessageHandler::append(const am::am_MainSoundProperty_s mainSoundProperty) { - DBusMessageIter structIter; - dbus_bool_t success=true; - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value); - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); - + DBusMessageIter structIter; + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &mainSoundProperty.value); + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const am::am_Availability_s & availability) +void CAmRoutingDbusMessageHandler::append(const am::am_Availability_s& availability) { DBusMessageIter structAvailIter; - dbus_bool_t success=true; - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT,NULL, &structAvailIter); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability); - success=success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason); - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter); - + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structAvailIter); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availability); + success = success && dbus_message_iter_append_basic(&structAvailIter, DBUS_TYPE_INT16, &availability.availabilityReason); + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structAvailIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const am::am_SystemProperty_s & SystemProperty) +void CAmRoutingDbusMessageHandler::append(const am::am_SystemProperty_s& SystemProperty) { DBusMessageIter structIter; - dbus_bool_t success=true; - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value); - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); - + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &SystemProperty.value); + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &structIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const std::vector& listMainConnections) +void CAmRoutingDbusMessageHandler::append(const std::vector& listMainConnections) { DBusMessageIter arrayIter; DBusMessageIter structIter; - std::vector::const_iterator listIterator=listMainConnections.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter); - for(;listIteratormainConnectionID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); - } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + std::vector::const_iterator listIterator = listMainConnections.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qqqnn)", &arrayIter); + for (; listIterator < listMainConnections.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->mainConnectionID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->delay); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->connectionState); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); + } + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const std::vector & listMainSinks) +void CAmRoutingDbusMessageHandler::append(const std::vector& listMainSinks) { DBusMessageIter arrayIter; DBusMessageIter structIter; DBusMessageIter availIter; - std::vector::const_iterator listIterator=listMainSinks.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter); - for(;listIteratorsinkID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter); - success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability); - success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason); - success=success && dbus_message_iter_close_container(&structIter, &availIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); - } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + std::vector::const_iterator listIterator = listMainSinks.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)nnq)", &arrayIter); + for (; listIterator < listMainSinks.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter); + success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability); + success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason); + success = success && dbus_message_iter_close_container(&structIter, &availIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->volume); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->muteState); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); + } + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } - - -void CAmDbusMessageHandler::append(const std::vector & listMainSources) +void CAmRoutingDbusMessageHandler::append(const std::vector& listMainSources) { DBusMessageIter arrayIter; DBusMessageIter structIter; DBusMessageIter availIter; - std::vector::const_iterator listIterator=listMainSources.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter); - for(;listIteratorsourceID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter); - success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability); - success=success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason); - success=success && dbus_message_iter_close_container(&structIter, &availIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); - } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + std::vector::const_iterator listIterator = listMainSources.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qs(nn)q)", &arrayIter); + for (; listIterator < listMainSources.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_STRUCT, NULL, &availIter); + success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availability); + success = success && dbus_message_iter_append_basic(&availIter, DBUS_TYPE_INT16, &listIterator->availability.availabilityReason); + success = success && dbus_message_iter_close_container(&structIter, &availIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); + } + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const std::vector & listMainSoundProperties) +void CAmRoutingDbusMessageHandler::append(const std::vector& listMainSoundProperties) { DBusMessageIter arrayIter; DBusMessageIter structIter; - std::vector::const_iterator listIterator=listMainSoundProperties.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter); - for(;listIterator::const_iterator listIterator = listMainSoundProperties.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter); + for (; listIterator < listMainSoundProperties.end(); ++listIterator) { - success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const std::vector & listSourceClasses) +void CAmRoutingDbusMessageHandler::append(const std::vector& listSourceClasses) { DBusMessageIter arrayIter; DBusMessageIter structIter; DBusMessageIter propIter; DBusMessageIter innerIter; - std::vector::const_iterator listIterator=listSourceClasses.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter); - for(;listIteratorsourceClassID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter); - - std::vector::const_iterator listInnerIterator=listIterator->listClassProperties.begin(); - for(;listInnerIteratorlistClassProperties.end();++listInnerIterator) + std::vector::const_iterator listIterator = listSourceClasses.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter); + for (; listIterator < listSourceClasses.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sourceClassID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter); + + std::vector::const_iterator listInnerIterator = listIterator->listClassProperties.begin(); + for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator) { - success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter); - success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty); - success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value); - success=success && dbus_message_iter_close_container(&innerIter, &propIter); + success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter); + success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty); + success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value); + success = success && dbus_message_iter_close_container(&innerIter, &propIter); } - success=success && dbus_message_iter_close_container(&structIter, &innerIter); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); + success = success && dbus_message_iter_close_container(&structIter, &innerIter); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } -void CAmDbusMessageHandler::append(const std::vector & listSinkClasses) +void CAmRoutingDbusMessageHandler::append(const std::vector& listSinkClasses) { DBusMessageIter arrayIter; DBusMessageIter structIter; DBusMessageIter propIter; DBusMessageIter innerIter; - std::vector::const_iterator listIterator=listSinkClasses.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter); - for(;listIteratorsinkClassID); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); - success=success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter); - - std::vector::const_iterator listInnerIterator=listIterator->listClassProperties.begin(); - for(;listInnerIteratorlistClassProperties.end();++listInnerIterator) + std::vector::const_iterator listIterator = listSinkClasses.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(qsa(nn))", &arrayIter); + for (; listIterator < listSinkClasses.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_UINT16, &listIterator->sinkClassID); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_STRING, &listIterator->name); + success = success && dbus_message_iter_open_container(&structIter, DBUS_TYPE_ARRAY, "(nn)", &innerIter); + + std::vector::const_iterator listInnerIterator = listIterator->listClassProperties.begin(); + for (; listInnerIterator < listIterator->listClassProperties.end(); ++listInnerIterator) { - success=success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter); - success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty); - success=success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value); - success=success && dbus_message_iter_close_container(&innerIter, &propIter); + success = success && dbus_message_iter_open_container(&innerIter, DBUS_TYPE_STRUCT, NULL, &propIter); + success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->classProperty); + success = success && dbus_message_iter_append_basic(&propIter, DBUS_TYPE_INT16, &listInnerIterator->value); + success = success && dbus_message_iter_close_container(&innerIter, &propIter); } - success=success && dbus_message_iter_close_container(&structIter, &innerIter); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); + success = success && dbus_message_iter_close_container(&structIter, &innerIter); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; + } } } -void CAmDbusMessageHandler::append(const std::vector & listSystemProperties) +void CAmRoutingDbusMessageHandler::append(const std::vector& listSystemProperties) { DBusMessageIter arrayIter; DBusMessageIter structIter; - std::vector::const_iterator listIterator=listSystemProperties.begin(); - dbus_bool_t success=true; - - success=success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter); - for(;listIterator::const_iterator listIterator = listSystemProperties.begin(); + dbus_bool_t success = true; + success = success && dbus_message_iter_open_container(&mDBusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter); + for (; listIterator < listSystemProperties.end(); ++listIterator) { - success=success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type); - success=success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value); - success=success && dbus_message_iter_close_container(&arrayIter, &structIter); + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); } - success=success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); - + success = success && dbus_message_iter_close_container(&mDBusMessageIter, &arrayIter); if (!success) { - mErrorName=std::string(DBUS_ERROR_NO_MEMORY); - mErrorMsg="Cannot create reply!"; + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; } } +void CAmRoutingDbusMessageHandler::append(const am::am_Error_e error) +{ + if (!dbus_message_iter_append_basic(&mDBusMessageIter, DBUS_TYPE_UINT16, &error)) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append Cannot allocate DBus message!"); + mErrorName = std::string(DBUS_ERROR_NO_MEMORY); + mErrorMsg = "Cannot create reply!"; + } +} + +} diff --git a/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp index 16a42ca..0f02ab3 100644 --- a/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp +++ b/PluginRoutingInterfaceDbus/src/CAmDbusSend.cpp @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -16,118 +18,123 @@ */ #include "CAmDbusSend.h" -#include +#include "shared/CAmDltWrapper.h" -DLT_IMPORT_CONTEXT(DLT_CONTEXT) +namespace am +{ -CAmDbusSend::CAmDbusSend (DBusConnection* conn, const char* bus_name,const char* path, const char* interface, const char* method) : m_conn(conn) { - m_msg=dbus_message_new_method_call(bus_name,path,interface,method); - if (NULL == m_msg) { - this->~CAmDbusSend(); - } -} +DLT_IMPORT_CONTEXT(routingDbus) -CAmDbusSend::~CAmDbusSend() { - if(replymsg) - dbus_message_unref(replymsg); +CAmRoutingDbusSend::CAmRoutingDbusSend(DBusConnection* conn, std::string bus_name, std::string path, std::string interface, std::string method) : + mpDbusMessage(NULL), // + mpDbusConnection(conn), // + mDbusMessageIter(), // + mDBusError() +{ + dbus_error_init(&mDBusError); + mpDbusMessage = dbus_message_new_method_call(bus_name.c_str(), path.c_str(), interface.c_str(), method.c_str()); + if (NULL == mpDbusMessage) + { + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::CAmRoutingDbusSend dbus error:", mDBusError.message); + this->~CAmRoutingDbusSend(); + } } -void CAmDbusSend::appendString(char* string) { - dbus_message_iter_init_append(m_msg, &m_args); - if (!dbus_message_iter_append_basic(&m_args, DBUS_TYPE_STRING, string)) { - this->~CAmDbusSend(); - } +CAmRoutingDbusSend::~CAmRoutingDbusSend() +{ } -void CAmDbusSend::appendInteger(int integer) { - dbus_message_iter_init_append(m_msg, &m_args); - if (!dbus_message_iter_append_basic(&m_args, DBUS_TYPE_INT32, &integer)) { - this->~CAmDbusSend(); - } - +void CAmRoutingDbusSend::append(std::string string) +{ + dbus_message_iter_init_append(mpDbusMessage, &mDbusMessageIter); + if (!dbus_message_iter_append_basic(&mDbusMessageIter, DBUS_TYPE_STRING, string.c_str())) + { + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::append no more memory"); + this->~CAmRoutingDbusSend(); + } } -void CAmDbusSend::sendReply(bool* reply) { - - DBusPendingCall* pending; - DBusMessageIter args; - if (!dbus_connection_send_with_reply (m_conn, m_msg, &pending, -1)) { // -1 is default timeout - this->~CAmDbusSend(); - } - - if (NULL == pending) { - this->~CAmDbusSend(); - } - dbus_connection_flush(m_conn); - dbus_message_unref(m_msg); - dbus_pending_call_block(pending); - - DBusMessage* msg=dbus_pending_call_steal_reply(pending); - - if (NULL == msg) { - this->~CAmDbusSend(); - } - - dbus_pending_call_unref(pending); - - if (!dbus_message_iter_init(msg, &args)) { - } else if (DBUS_TYPE_BOOLEAN != dbus_message_iter_get_arg_type(&args)) { - } else { - dbus_message_iter_get_basic(&args, reply); - } - - dbus_message_unref(msg); +void CAmRoutingDbusSend::append(uint16_t integer) +{ + dbus_message_iter_init_append(mpDbusMessage, &mDbusMessageIter); + if (!dbus_message_iter_append_basic(&mDbusMessageIter, DBUS_TYPE_UINT16, &integer)) + { + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::append no more memory"); + this->~CAmRoutingDbusSend(); + } } -void CAmDbusSend::sendReply(int* reply) { - - DBusPendingCall* pending; - DBusMessageIter args; - if (!dbus_connection_send_with_reply (m_conn, m_msg, &pending, -1)) { // -1 is default timeout - this->~CAmDbusSend(); - } - - if (NULL == pending) { - this->~CAmDbusSend(); - } - dbus_connection_flush(m_conn); - dbus_message_unref(m_msg); - dbus_pending_call_block(pending); - - DBusMessage* msg=dbus_pending_call_steal_reply(pending); - - if (NULL == msg) { - this->~CAmDbusSend(); - } +void CAmRoutingDbusSend::append(int16_t integer) +{ + dbus_message_iter_init_append(mpDbusMessage, &mDbusMessageIter); + if (!dbus_message_iter_append_basic(&mDbusMessageIter, DBUS_TYPE_INT16, &integer)) + { + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::append no more memory"); + this->~CAmRoutingDbusSend(); + } +} - dbus_pending_call_unref(pending); +void CAmRoutingDbusSend::append(std::vector listSoundProperties) +{ + DBusMessageIter arrayIter; + DBusMessageIter structIter; + std::vector::const_iterator listIterator = listSoundProperties.begin(); + dbus_bool_t success = true; - if (!dbus_message_iter_init(msg, &args)) { - } else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args)) { - } else { - dbus_message_iter_get_basic(&args, reply); - } + success = success && dbus_message_iter_open_container(&mDbusMessageIter, DBUS_TYPE_ARRAY, "(nn)", &arrayIter); + for (; listIterator < listSoundProperties.end(); ++listIterator) + { + success = success && dbus_message_iter_open_container(&arrayIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &listIterator->value); + success = success && dbus_message_iter_close_container(&arrayIter, &structIter); + } + success = success && dbus_message_iter_close_container(&mDbusMessageIter, &arrayIter); - dbus_message_unref(msg); + if (!success) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append error", mDBusError.message); + } } -void CAmDbusSend::sendReply(void) { +void CAmRoutingDbusSend::append(am_SoundProperty_s soundProperty) +{ + DBusMessageIter structIter; + dbus_bool_t success = true; - if (!dbus_connection_send(m_conn, m_msg, NULL)) - { - this->~CAmDbusSend(); - } - replymsg = NULL; + success = success && dbus_message_iter_open_container(&mDbusMessageIter, DBUS_TYPE_STRUCT, NULL, &structIter); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &soundProperty.type); + success = success && dbus_message_iter_append_basic(&structIter, DBUS_TYPE_INT16, &soundProperty.value); + success = success && dbus_message_iter_close_container(&mDbusMessageIter, &structIter); + if (!success) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::append error", mDBusError.message); + } } -void CAmDbusSend::Replyint32(int *reply) + +am_Error_e CAmRoutingDbusSend::send() { - if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&mDBusMessageIter)) + + am_Error_e error; + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDbusConnection, mpDbusMessage, -1, &mDBusError)); + if (!reply) { + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingDbusSend::send failed, dbus error", mDBusError.message); + return (E_UNKNOWN); + } + if (!dbus_message_iter_init(reply, &mDbusMessageIter)) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::send DBus Message has no arguments!"); + } + if (DBUS_TYPE_INT16 != dbus_message_iter_get_arg_type(&mDbusMessageIter)) + { + log(&routingDbus, DLT_LOG_ERROR, "DBusMessageHandler::getBool DBUS handler argument is no error!"); } else { - dbus_message_iter_get_basic(&mDBusMessageIter, reply); + dbus_message_iter_get_basic(&mDbusMessageIter, &error); } - dbus_message_iter_next(&mDBusMessageIter); + return (error); +} } diff --git a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp index 8306911..360d61d 100644 --- a/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp +++ b/PluginRoutingInterfaceDbus/src/CAmRoutingSenderDbus.cpp @@ -1,7 +1,9 @@ /** * Copyright (c) 2012 BMW + * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors * * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 + * \author Sampreeth Ramavana * * \copyright * 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, @@ -15,15 +17,15 @@ * For further information see http://www.genivi.org/. */ -#include "shared/CAmDltWrapper.h" -#include "shared/CAmDbusWrapper.h" #include "CAmRoutingSenderDbus.h" +#include +#include #include "CAmDbusSend.h" +#include "shared/CAmDltWrapper.h" +#include "shared/CAmDbusWrapper.h" -#define PULSE_INTERFACE_TARGET "org.genivi.pulse" -#define PULSE_REGISTER_PATH "/pulse" -#define PULSE_INTERFACE_NAME "org.genivi.pulse" - +namespace am +{ DLT_DECLARE_CONTEXT(routingDbus) extern "C" IAmRoutingSend* PluginRoutingInterfaceDbusFactory() @@ -36,11 +38,12 @@ extern "C" void destroyRoutingPluginInterfaceDbus(IAmRoutingSend* routingSendInt delete routingSendInterface; } -CAmRoutingSenderDbus::CAmRoutingSenderDbus() - : mDBusMessageHandler(), - mRoutingReceiverShadow(), - mDBusWrapper(NULL), - mRoutingReceiveInterface(NULL) +CAmRoutingSenderDbus::CAmRoutingSenderDbus() : + mpCAmDBusWrapper(), // + mpIAmRoutingReceive(), // + mpDBusConnection(), // + mCAmRoutingDBusMessageHandler(), // + mIAmRoutingReceiverShadowDbus(this) { CAmDltWrapper::instance()->registerContext(routingDbus, "DRS", "DBus Plugin"); log(&routingDbus, DLT_LOG_INFO, "RoutingSender constructed"); @@ -52,161 +55,300 @@ CAmRoutingSenderDbus::~CAmRoutingSenderDbus() CAmDltWrapper::instance()->unregisterContext(routingDbus); } -am_Error_e CAmRoutingSenderDbus::asyncAbort(const am_Handle_s handle) +am_Error_e CAmRoutingSenderDbus::startupInterface(IAmRoutingReceive* pIAmRoutingReceive) { - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "abort"); - send.appendInteger(handle.handleType); - send.appendInteger(handle.handle); - send.sendReply(); + log(&routingDbus, DLT_LOG_INFO, "startupInterface called"); + mpIAmRoutingReceive = pIAmRoutingReceive; + mIAmRoutingReceiverShadowDbus.setRoutingReceiver(mpIAmRoutingReceive); + mpIAmRoutingReceive->getDBusConnectionWrapper(mpCAmDBusWrapper); + assert(mpCAmDBusWrapper!=NULL); + mpCAmDBusWrapper->getDBusConnection(mpDBusConnection); + assert(mpDBusConnection!=NULL); + mCAmRoutingDBusMessageHandler.setDBusConnection(mpDBusConnection); return (E_OK); } +void CAmRoutingSenderDbus::getInterfaceVersion(std::string & version) const +{ + version = RoutingSendVersion; +} + +void CAmRoutingSenderDbus::setRoutingReady(const uint16_t handle) +{ + log(&routingDbus, DLT_LOG_INFO, "sending routingReady signal"); + mCAmRoutingDBusMessageHandler.initSignal(std::string(ROUTING_NODE), "setRoutingReady"); + mCAmRoutingDBusMessageHandler.sendMessage(); + mIAmRoutingReceiverShadowDbus.gotReady(mMapDomains.size(),handle); +} + +void CAmRoutingSenderDbus::setRoutingRundown(const uint16_t handle) +{ + mCAmRoutingDBusMessageHandler.initSignal(std::string(ROUTING_NODE), "setRoutingRundown"); + mCAmRoutingDBusMessageHandler.sendMessage(); + mIAmRoutingReceiverShadowDbus.gotRundown(mMapDomains.size(),handle); +} + +am_Error_e CAmRoutingSenderDbus::asyncAbort(const am_Handle_s handle) +{ + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncAbort called"); + mapHandles_t::iterator iter = mMapHandles.begin(); + iter = mMapHandles.find(handle.handle); + if (iter != mMapHandles.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncAbort"); + send.append(handle.handle); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncAbort could not find interface"); + return (E_UNKNOWN); + +} + am_Error_e CAmRoutingSenderDbus::asyncConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_sourceID_t sourceID, const am_sinkID_t sinkID, const am_ConnectionFormat_e connectionFormat) { - (void) connectionFormat; - log(&routingDbus, DLT_LOG_INFO, "pulse async connect"); - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "connect"); - send.appendInteger(handle.handle); - send.appendInteger(connectionID); - send.appendInteger(sourceID); - send.appendInteger(sinkID); - send.sendReply(); - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncConnect called"); + mapSources_t::iterator iter = mMapSources.begin(); + iter = mMapSources.find(sourceID); + if (iter != mMapSources.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncConnect"); + send.append(handle.handle); + send.append(connectionID); + send.append(sourceID); + send.append(sinkID); + send.append(static_cast(connectionFormat)); + mMapConnections.insert(std::make_pair(connectionID, (iter->second))); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncConnect could not find interface"); + return (E_UNKNOWN); } am_Error_e CAmRoutingSenderDbus::asyncDisconnect(const am_Handle_s handle, const am_connectionID_t connectionID) { - log(&routingDbus, DLT_LOG_INFO, "pulse async disconnect"); - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "disconnect"); - send.appendInteger(handle.handle); - send.appendInteger(connectionID); - send.sendReply(); - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncDisconnect called"); + mapConnections_t::iterator iter = mMapConnections.begin(); + iter = mMapConnections.find(connectionID); + if (iter != mMapConnections.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncDisconnect"); + send.append(handle.handle); + send.append(connectionID); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncDisconnect could not find interface"); + return (E_UNKNOWN); } am_Error_e CAmRoutingSenderDbus::asyncSetSinkVolume(const am_Handle_s handle, const am_sinkID_t sinkID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time) { - log(&routingDbus, DLT_LOG_INFO, "pulse set sink volume"); - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSinkVolume"); - send.appendInteger(handle.handle); - send.appendInteger(sinkID); - send.appendInteger(volume); - send.appendInteger(ramp); - send.appendInteger(time); - send.sendReply(); - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSinkVolume called"); + mapSinks_t::iterator iter = mMapSinks.begin(); + iter = mMapSinks.find(sinkID); + if (iter != mMapSinks.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSinkVolume"); + send.append(handle.handle); + send.append(sinkID); + send.append(volume); + send.append(static_cast(ramp)); + send.append(time); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSinkVolume could not find interface"); + return (E_UNKNOWN); } am_Error_e CAmRoutingSenderDbus::asyncSetSourceVolume(const am_Handle_s handle, const am_sourceID_t sourceID, const am_volume_t volume, const am_RampType_e ramp, const am_time_t time) { - log(&routingDbus, DLT_LOG_INFO, "pulse set source volume"); - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSourceVolume"); - send.appendInteger(handle.handle); - send.appendInteger(sourceID); - send.appendInteger(volume); - send.appendInteger(ramp); - send.appendInteger(time); - send.sendReply(); - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSourceVolume called"); + mapSources_t::iterator iter = mMapSources.begin(); + iter = mMapSources.find(sourceID); + if (iter != mMapSources.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSourceVolume"); + send.append(handle.handle); + send.append(sourceID); + send.append(volume); + send.append(static_cast(ramp)); + send.append(time); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSourceVolume could not find interface"); + return (E_UNKNOWN); } am_Error_e CAmRoutingSenderDbus::asyncSetSourceState(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SourceState_e state) { - (void) handle; - (void) sourceID; - (void) state; - return (E_NOT_USED); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSourceState called"); + mapSources_t::iterator iter = mMapSources.begin(); + iter = mMapSources.find(sourceID); + if (iter != mMapSources.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSourceState"); + send.append(handle.handle); + send.append(sourceID); + send.append(static_cast(state)); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSourceState could not find interface"); + return (E_UNKNOWN); } -am_Error_e CAmRoutingSenderDbus::asyncCrossFade(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time) +am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperties(const am_Handle_s handle, const am_sinkID_t sinkID, const std::vector& listSoundProperties) { - (void) handle; - (void) crossfaderID; - (void) hotSink; - (void) rampType; - (void) time; - return (E_NOT_USED); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSinkSoundProperties called"); + mapSinks_t::iterator iter = mMapSinks.begin(); + iter = mMapSinks.find(sinkID); + if (iter != mMapSinks.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSinkSoundProperties"); + send.append(handle.handle); + send.append(sinkID); + send.append(listSoundProperties); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSinkSoundProperties could not find interface"); + return (E_UNKNOWN); } -am_Error_e CAmRoutingSenderDbus::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) +am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperty(const am_Handle_s handle, const am_sinkID_t sinkID, const am_SoundProperty_s& soundProperty) { - (void) domainID; - (void) domainState; - return (E_NOT_USED); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSinkSoundProperty called"); + mapSinks_t::iterator iter = mMapSinks.begin(); + iter = mMapSinks.find(sinkID); + if (iter != mMapSinks.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSinkSoundProperty"); + send.append(handle.handle); + send.append(sinkID); + send.append(soundProperty); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSinkSoundProperty could not find interface"); + return (E_UNKNOWN); } -am_Error_e CAmRoutingSenderDbus::startupInterface(IAmRoutingReceive *routingreceiveinterface) +am_Error_e CAmRoutingSenderDbus::asyncSetSourceSoundProperties(const am_Handle_s handle, const am_sourceID_t sourceID, const std::vector& listSoundProperties) { - log(&routingDbus, DLT_LOG_INFO, "startupInterface called"); - mRoutingReceiveInterface=routingreceiveinterface; - mRoutingReceiverShadow.setRoutingReceiver(mRoutingReceiveInterface); - mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper); - //assert(mDBusWrapper!=NULL); - mDBusWrapper->getDBusConnection(connection); - //assert(connection!=NULL); - mDBusMessageHandler.setDBusConnection(connection); - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSourceSoundProperties called"); + mapSources_t::iterator iter = mMapSources.begin(); + iter = mMapSources.find(sourceID); + if (iter != mMapSources.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSourceSoundProperties"); + send.append(handle.handle); + send.append(sourceID); + send.append(listSoundProperties); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSourceSoundProperties could not find interface"); + return (E_UNKNOWN); } -void CAmRoutingSenderDbus::setRoutingReady(const uint16_t handle) +am_Error_e CAmRoutingSenderDbus::asyncSetSourceSoundProperty(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SoundProperty_s& soundProperty) { - (void) handle; - log(&routingDbus, DLT_LOG_INFO, "sending systemReady signal"); - mDBusMessageHandler.initSignal(std::string(ROUTING_NODE),"signal_systemReady"); - mDBusMessageHandler.sendMessage(); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::asyncSetSourceSoundProperty called"); + mapSources_t::iterator iter = mMapSources.begin(); + iter = mMapSources.find(sourceID); + if (iter != mMapSources.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "asyncSetSourceSoundProperty"); + send.append(handle.handle); + send.append(sourceID); + send.append(soundProperty); + mMapHandles.insert(std::make_pair(handle.handle, iter->second)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::asyncSetSourceSoundProperty could not find interface"); + return (E_UNKNOWN); } -void CAmRoutingSenderDbus::setRoutingRundown(const uint16_t handle) +am_Error_e CAmRoutingSenderDbus::asyncCrossFade(const am_Handle_s handle, const am_crossfaderID_t crossfaderID, const am_HotSink_e hotSink, const am_RampType_e rampType, const am_time_t time) { - (void) handle; + (void)handle; + (void)crossfaderID; + (void)hotSink; + (void)rampType; + (void)time; + //todo implement + return (E_NON_EXISTENT); } -am_Error_e CAmRoutingSenderDbus::returnBusName(std::string & BusName) const +am_Error_e CAmRoutingSenderDbus::setDomainState(const am_domainID_t domainID, const am_DomainState_e domainState) { - BusName = "DbusPlugin"; - return (E_OK); + log(&routingDbus, DLT_LOG_INFO, "CAmRoutingSenderDbus::setDomainState called"); + mapDomain_t::iterator iter = mMapDomains.begin(); + iter = mMapDomains.find(domainID); + if (iter != mMapDomains.end()) + { + CAmRoutingDbusSend send(mpDBusConnection, iter->second.busname, iter->second.path, iter->second.interface, "setDomainState"); + send.append(domainID); + send.append(static_cast(domainState)); + return (send.send()); + } + log(&routingDbus, DLT_LOG_ERROR, "CAmRoutingSenderDbus::setDomainState could not find interface"); + return (E_UNKNOWN); } -am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperty(const am_Handle_s handle, const am_sinkID_t sinkID, const am_SoundProperty_s & soundProperty) +am_Error_e CAmRoutingSenderDbus::returnBusName(std::string& BusName) const { - log(&routingDbus, DLT_LOG_INFO, "pulse set sink sound property "); - CAmDbusSend send = CAmDbusSend(connection,PULSE_INTERFACE_TARGET,PULSE_REGISTER_PATH, PULSE_INTERFACE_NAME, "setSinkSoundProperty"); - send.appendInteger(handle.handle); - send.appendInteger(soundProperty.type); - send.appendInteger(soundProperty.value); - send.appendInteger(sinkID); - send.sendReply(); + BusName = "DbusRoutingPlugin"; return (E_OK); } -am_Error_e CAmRoutingSenderDbus::asyncSetSinkSoundProperties(const am_Handle_s handle, const am_sinkID_t sinkID, const std::vector & listSoundProperties) +void CAmRoutingSenderDbus::removeHandle(uint16_t handle) { - (void) handle; - (void) sinkID; - (void) listSoundProperties; - return (E_NOT_USED); + mMapHandles.erase(handle); } -am_Error_e CAmRoutingSenderDbus::asyncSetSourceSoundProperty(const am_Handle_s handle, const am_sourceID_t sourceID, const am_SoundProperty_s & soundProperty) +void CAmRoutingSenderDbus::addDomainLookup(am_domainID_t domainID, rs_lookupData_s lookupData) { - (void) handle; - (void) sourceID; - (void) soundProperty; - return (E_NOT_USED); + mMapDomains.insert(std::make_pair(domainID, lookupData)); } -am_Error_e CAmRoutingSenderDbus::asyncSetSourceSoundProperties(const am_Handle_s handle, const am_sourceID_t sourceID, const std::vector & listSoundProperties) +void CAmRoutingSenderDbus::addSourceLookup(am_sourceID_t sourceID, am_domainID_t domainID) { - (void) handle; - (void) sourceID; - (void) listSoundProperties; - return (E_NOT_USED); + mapDomain_t::iterator iter(mMapDomains.begin()); + iter = mMapDomains.find(domainID); + if (iter != mMapDomains.end()) + { + mMapSources.insert(std::make_pair(sourceID, iter->second)); + } } -void CAmRoutingSenderDbus::getInterfaceVersion(std::string & version) const +void CAmRoutingSenderDbus::addSinkLookup(am_sinkID_t sinkID, am_domainID_t domainID) +{ + mapDomain_t::iterator iter(mMapDomains.begin()); + iter = mMapDomains.find(domainID); + if (iter != mMapDomains.end()) + { + mMapSinks.insert(std::make_pair(sinkID, iter->second)); + } +} + +void CAmRoutingSenderDbus::removeDomainLookup(am_domainID_t domainID) { - version=RoutingSendVersion; + mMapHandles.erase(domainID); } +void CAmRoutingSenderDbus::removeSourceLookup(am_sourceID_t sourceID) +{ + mMapHandles.erase(sourceID); +} + +void CAmRoutingSenderDbus::removeSinkLookup(am_sinkID_t sinkID) +{ + mMapHandles.erase(sinkID); +} +} diff --git a/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp index d8623cb..e48e753 100644 --- a/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp +++ b/PluginRoutingInterfaceDbus/src/IAmRoutingReceiverShadow.cpp @@ -1,7 +1,9 @@ /** * Copyright (c) copyright 2011-2012 Aricent® Group and its licensors + * Copyright (c) 2012 BMW * - * \author: Sampreeth Ramavana + * \author Sampreeth Ramavana + * \author Christian Mueller, christian.ei.mueller@bmw.de BMW 2011,2012 * * \copyright * 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, @@ -15,386 +17,578 @@ * For further information see http://www.genivi.org/. */ - -#include +#include "IAmRoutingReceiverShadow.h" #include #include #include #include -#include "IAmRoutingReceiverShadow.h" #include "CAmRoutingSenderDbus.h" +#include "shared/CAmDbusWrapper.h" #include "shared/CAmDltWrapper.h" -using namespace am; +namespace am +{ DLT_IMPORT_CONTEXT(routingDbus) + /** * static ObjectPathTable is needed for DBus Callback handling */ static DBusObjectPathVTable gObjectPathVTable; -IAmRoutingReceiverShadow::IAmRoutingReceiverShadow() -: mRoutingReceiveInterface(NULL), - mDBusWrapper(NULL), - mFunctionMap(createMap()), - mDBUSMessageHandler() +IAmRoutingReceiverShadowDbus::IAmRoutingReceiverShadowDbus(CAmRoutingSenderDbus* pRoutingSenderDbus) : + mRoutingReceiveInterface(NULL), // + mDBusWrapper(NULL), // + mpRoutingSenderDbus(pRoutingSenderDbus), // + mFunctionMap(createMap()), // + mDBUSMessageHandler(), // + mNumberDomains(0), // + mHandle(0) { - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow constructed"); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow constructed"); } -IAmRoutingReceiverShadow::~IAmRoutingReceiverShadow() +IAmRoutingReceiverShadowDbus::~IAmRoutingReceiverShadowDbus() { - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow destructed"); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow destructed"); } - -void IAmRoutingReceiverShadow::registerDomain(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::registerDomain(DBusConnection *conn, DBusMessage *msg) { - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called"); - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - am_Domain_s mDomain; - mDomain.domainID = 0; - - char *name = mDBUSMessageHandler.getString(); - char *nodename = mDBUSMessageHandler.getString(); - mDomain.early = mDBUSMessageHandler.getBool(); - mDomain.state = (am_DomainState_e)mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called, name", name,"nodename", nodename,"mDomain.early", mDomain.early, "mDomain.state", mDomain.state ); - - mDomain.name = std::string(name); - mDomain.nodename = std::string(nodename); - mDomain.busname = "pulsePlugin"; - mDomain.complete = 0; // will be set once hookdomainregistration event is received - - // pass the data to the controller and the database - am_Error_e returnCode = mRoutingReceiveInterface->registerDomain(mDomain, mDomain.domainID); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain domain ID, mDomain.domainID", mDomain.domainID ); - mDBUSMessageHandler.initReply(msg); - mDBUSMessageHandler.append((dbus_uint32_t)mDomain.domainID); - mDBUSMessageHandler.sendMessage(); - if (returnCode != E_OK) - { - log(&routingDbus, DLT_LOG_INFO, "error registering domain" ); - } + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called"); + + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_Domain_s domain(mDBUSMessageHandler.getDomainData()); + CAmRoutingSenderDbus::rs_lookupData_s lookupData; + lookupData.busname = mDBUSMessageHandler.getString(); + lookupData.path = mDBUSMessageHandler.getString(); + lookupData.interface = mDBUSMessageHandler.getString(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerDomain called, name ", domain.name, "nodename ", domain.nodename); + domain.busname = "DbusRoutingPlugin"; + am_Error_e returnCode = mRoutingReceiveInterface->registerDomain(domain, domain.domainID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(domain.domainID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + if (returnCode != E_OK) + { + log(&routingDbus, DLT_LOG_INFO, "error registering domain"); + return; + } + mpRoutingSenderDbus->addDomainLookup(domain.domainID, lookupData); } -void IAmRoutingReceiverShadow::registerSource(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::registerSource(DBusConnection* conn, DBusMessage* msg) { - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::RegisterSource called"); - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - am_Source_s mSource; - - char *name = mDBUSMessageHandler.getString(); - mSource.sourceID = 0; - mSource.sourceClassID = mDBUSMessageHandler.getInt32(); - mSource.domainID = mDBUSMessageHandler.getInt32(); - mSource.sourceState = SS_ON; - mSource.listConnectionFormats.push_back(CF_GENIVI_STEREO); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSource called, name", name,"mSource.sourceClassID", mSource.sourceClassID,"mSource.domainID", mSource.domainID ); - - mSource.name = std::string(name); - - am_Error_e returnCode = mRoutingReceiveInterface->registerSource(mSource, mSource.sourceID); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registersource, mSource.sourceID", mSource.sourceID ); - mDBUSMessageHandler.initReply(msg); - mDBUSMessageHandler.append((dbus_uint32_t)mSource.sourceID); - mDBUSMessageHandler.sendMessage(); - if (returnCode != E_OK) - { - log(&routingDbus, DLT_LOG_INFO, "error registering source" ); - } - + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::RegisterSource called"); + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_Source_s sourceData(mDBUSMessageHandler.getSourceData()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSource called, name", sourceData.name, "mSource.sourceClassID", sourceData.sourceClassID, "mSource.domainID", sourceData.domainID); + am_Error_e returnCode = mRoutingReceiveInterface->registerSource(sourceData, sourceData.sourceID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sourceData.sourceID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + if (returnCode != E_OK) + { + log(&routingDbus, DLT_LOG_INFO, "error registering source"); + return; + } + mpRoutingSenderDbus->addSourceLookup(sourceData.sourceID, sourceData.domainID); } -void IAmRoutingReceiverShadow::registerSink(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::registerSink(DBusConnection* conn, DBusMessage* msg) { - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - am_Sink_s mSink; - - char *name = mDBUSMessageHandler.getString(); - mSink.sinkID = 0; - mSink.sinkClassID = mDBUSMessageHandler.getInt32(); - mSink.domainID = mDBUSMessageHandler.getInt32(); - mSink.muteState = MS_UNMUTED; - mSink.listConnectionFormats.push_back(CF_GENIVI_STEREO); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSink called, name", name,"mSink.sinkClassID", mSink.sinkClassID,"mSink.domainID", mSink.domainID ); - - mSink.name = std::string(name); - - am_Error_e returnCode = mRoutingReceiveInterface->registerSink(mSink, mSink.sinkID); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registersink, mSink.sinkID", mSink.sinkID ); - mDBUSMessageHandler.initReply(msg); - mDBUSMessageHandler.append((dbus_uint32_t)mSink.sinkID); - mDBUSMessageHandler.sendMessage(); - if (returnCode != E_OK) - { - log(&routingDbus, DLT_LOG_INFO, "error registering sink" ); - } - + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_Sink_s sinkData(mDBUSMessageHandler.getSinkData()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerSink called, name", sinkData.name, "mSink.sinkClassID", sinkData.sinkClassID, "mSink.domainID", sinkData.domainID); + am_Error_e returnCode = mRoutingReceiveInterface->registerSink(sinkData, sinkData.sinkID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sinkData.sinkID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + if (returnCode != E_OK) + { + log(&routingDbus, DLT_LOG_INFO, "error registering sink"); + return; + } + mpRoutingSenderDbus->addSinkLookup(sinkData.sinkID, sinkData.domainID); } -void IAmRoutingReceiverShadow::registerGateway(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::registerGateway(DBusConnection* conn, DBusMessage* msg) { - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - am_Gateway_s mGateway; - mGateway.gatewayID = 0; - - char *name = mDBUSMessageHandler.getString(); - char *sink = mDBUSMessageHandler.getString(); - char *source = mDBUSMessageHandler.getString(); - char *domainsource = mDBUSMessageHandler.getString(); - char *domainsink = mDBUSMessageHandler.getString(); - char *controldomain = mDBUSMessageHandler.getString(); - mGateway.listSinkFormats.push_back(CF_GENIVI_STEREO); - mGateway.listSourceFormats.push_back(CF_GENIVI_STEREO); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerGateway called, name", name,"sink", sink,"source", source ); - log(&routingDbus, DLT_LOG_INFO, "domainsource", domainsource,"domainsink", domainsink,"controldomain", controldomain ); - - mGateway.name = std::string(name); - mGateway.sinkID = 101; - mGateway.sourceID = 101; - mGateway.domainSourceID = 1; - mGateway.domainSinkID = 1; - mGateway.controlDomainID = 1; - mGateway.convertionMatrix.push_back(true); - - am_Error_e returnCode = mRoutingReceiveInterface->registerGateway(mGateway, mGateway.gatewayID); - mDBUSMessageHandler.initReply(msg); - mDBUSMessageHandler.append((dbus_uint32_t)mGateway.gatewayID); - mDBUSMessageHandler.sendMessage(); - if (returnCode != E_OK) - { - log(&routingDbus, DLT_LOG_INFO, "error registering gateway" ); - } - + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_Gateway_s gatewayData(mDBUSMessageHandler.getGatewayData()); + am_Error_e returnCode = mRoutingReceiveInterface->registerGateway(gatewayData, gatewayData.gatewayID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(gatewayData.gatewayID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + if (returnCode != E_OK) + { + log(&routingDbus, DLT_LOG_INFO, "error registering gateway"); + return; + } } -void IAmRoutingReceiverShadow::hookDomainRegistrationComplete(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::hookDomainRegistrationComplete(DBusConnection* conn, DBusMessage* msg) { - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - int domainID = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainRegistrationComplete called, domainID", domainID); - mRoutingReceiveInterface->hookDomainRegistrationComplete((am_domainID_t)domainID); - + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_domainID_t domainID(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainRegistrationComplete called, domainID", domainID); + mRoutingReceiveInterface->hookDomainRegistrationComplete((am_domainID_t)((domainID))); } -void IAmRoutingReceiverShadow::ackConnect(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackConnect(DBusConnection* conn, DBusMessage* msg) { - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - int handle = mDBUSMessageHandler.getInt32(); - int conid = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackConnect called, handle", handle, "conid", conid, "error", error); - - am_Handle_s myhandle; - myhandle.handleType = H_CONNECT; - myhandle.handle = handle; - am_connectionID_t mconnectionid = (am_connectionID_t)conid; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackConnect(myhandle,mconnectionid, merror); + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_connectionID_t connectionID(mDBUSMessageHandler.getUInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackConnect called, handle", handle, "connectionID", connectionID, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_CONNECT; + myhandle.handle = handle; + mRoutingReceiveInterface->ackConnect(myhandle, connectionID, error); + mpRoutingSenderDbus->removeHandle(handle); } - - -void IAmRoutingReceiverShadow::ackDisconnect(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackDisconnect(DBusConnection* conn, DBusMessage* msg) { - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - int handle = mDBUSMessageHandler.getInt32(); - int conid = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackDisconnect called, handle", handle, "conid", conid, "error", error); - - am_Handle_s myhandle; - myhandle.handleType = H_DISCONNECT; - myhandle.handle = handle; - am_connectionID_t mconnectionid = conid; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackDisconnect(myhandle,mconnectionid, merror); - + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_connectionID_t connectionID(mDBUSMessageHandler.getUInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackDisconnect called, handle", handle, "connectionID", connectionID, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_DISCONNECT; + myhandle.handle = handle; + mRoutingReceiveInterface->ackDisconnect(myhandle, connectionID, error); + mpRoutingSenderDbus->removeHandle(handle); } -void IAmRoutingReceiverShadow::ackSetSinkVolume(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackSetSinkVolume(DBusConnection* conn, DBusMessage* msg) { - - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - int handle = mDBUSMessageHandler.getInt32(); - int volume = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkVolume called, handle", handle, "error", error, "volume", volume); - - am_Handle_s myhandle; - myhandle.handleType = H_SETSINKVOLUME; - myhandle.handle = handle; - am_volume_t mvolume = volume; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackSetSinkVolumeChange(myhandle,mvolume, merror); - + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_volume_t volume(mDBUSMessageHandler.getInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkVolume called, handle", handle, "error", error, "volume", volume); + am_Handle_s myhandle; + myhandle.handleType = H_SETSINKVOLUME; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSinkVolumeChange(myhandle, volume, error); + mpRoutingSenderDbus->removeHandle(handle); } -void IAmRoutingReceiverShadow::ackSinkVolumeTick(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackSetSourceState(DBusConnection* conn, DBusMessage* msg) { + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceState called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSOURCESTATE; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSourceState(myhandle, error); + mpRoutingSenderDbus->removeHandle(handle); +} - (void) conn; - assert(mRoutingReceiveInterface!=NULL); - - mDBUSMessageHandler.initReceive(msg); - - int handle = mDBUSMessageHandler.getInt32(); - int sinkID = mDBUSMessageHandler.getInt32(); - int volume = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSinkVolumeTick called, handle", handle, "sinkID", sinkID, "volume", volume); - - am_Handle_s myhandle; - myhandle.handleType = H_SETSINKVOLUME; - myhandle.handle = handle; - am_volume_t mvolume = volume; - mRoutingReceiveInterface->ackSinkVolumeTick(myhandle,sinkID, mvolume); - +void IAmRoutingReceiverShadowDbus::ackSinkVolumeTick(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_sinkID_t sinkID(mDBUSMessageHandler.getUInt()); + am_volume_t volume(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSinkVolumeTick called, handle", handle, "sinkID", sinkID, "volume", volume); + am_Handle_s myhandle; + myhandle.handleType = H_SETSINKVOLUME; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSinkVolumeTick(myhandle, sinkID, volume); } -void IAmRoutingReceiverShadow::ackSourceVolumeTick(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackSourceVolumeTick(DBusConnection* conn, DBusMessage* msg) { + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_sourceID_t sourceID(mDBUSMessageHandler.getUInt()); + am_volume_t volume(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSourceVolumeTick called, handle", handle, "sourceID", sourceID, "volume", volume); + am_Handle_s myhandle; + myhandle.handleType = H_SETSINKVOLUME; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSourceVolumeTick(myhandle, sourceID, volume); +} - (void) conn; - assert(mRoutingReceiveInterface!=NULL); +void IAmRoutingReceiverShadowDbus::ackSetSourceVolume(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_volume_t volume(mDBUSMessageHandler.getInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceVolume called, handle", handle, "volume", volume, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSOURCEVOLUME; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSourceVolumeChange(myhandle, volume, error); + mpRoutingSenderDbus->removeHandle(handle); +} - mDBUSMessageHandler.initReceive(msg); +void IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperty(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSINKSOUNDPROPERTY; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSinkSoundProperty(myhandle, error); + mpRoutingSenderDbus->removeHandle(handle); +} - int handle = mDBUSMessageHandler.getInt32(); - int sourceID = mDBUSMessageHandler.getInt32(); - int volume = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSourceVolumeTick called, handle", handle, "sourceID", sourceID, "volume", volume); +void IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperty(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle(mDBUSMessageHandler.getUInt()); + am_Error_e error((am_Error_e)((mDBUSMessageHandler.getUInt()))); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSOURCESOUNDPROPERTY; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSourceSoundProperty(myhandle, error); + mpRoutingSenderDbus->removeHandle(handle); +} - am_Handle_s myhandle; - myhandle.handleType = H_SETSINKVOLUME; - myhandle.handle = handle; - am_volume_t mvolume = volume; - mRoutingReceiveInterface->ackSourceVolumeTick(myhandle,sourceID, mvolume); +void IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperties(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle = mDBUSMessageHandler.getUInt(); + am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperties called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSINKSOUNDPROPERTIES; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSinkSoundProperties(myhandle, error); + mpRoutingSenderDbus->removeHandle(handle); +} +void IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperties(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle = mDBUSMessageHandler.getUInt(); + am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceSoundProperties called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_SETSOURCESOUNDPROPERTIES; + myhandle.handle = handle; + mRoutingReceiveInterface->ackSetSourceSoundProperties(myhandle, error); + mpRoutingSenderDbus->removeHandle(handle); } -void IAmRoutingReceiverShadow::ackSetSourceVolume(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::ackCrossFading(DBusConnection* conn, DBusMessage* msg) { + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + uint16_t handle = mDBUSMessageHandler.getUInt(); + am_HotSink_e hotsink = (am_HotSink_e)((mDBUSMessageHandler.getInt())); + am_Error_e error = (am_Error_e)((mDBUSMessageHandler.getUInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackCrossFading called, handle", handle, "error", error); + am_Handle_s myhandle; + myhandle.handleType = H_CROSSFADE; + myhandle.handle = handle; + mRoutingReceiveInterface->ackCrossFading(myhandle, hotsink, error); + mpRoutingSenderDbus->removeHandle(handle); +} - (void) conn; - assert(mRoutingReceiveInterface!=NULL); +void IAmRoutingReceiverShadowDbus::peekDomain(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::string name = std::string(mDBUSMessageHandler.getString()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekDomain called, name", name); + am_domainID_t domainID; + am_Error_e returnCode = mRoutingReceiveInterface->peekDomain(name, domainID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(domainID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); +} - mDBUSMessageHandler.initReceive(msg); +void IAmRoutingReceiverShadowDbus::deregisterDomain(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_domainID_t domainID = mDBUSMessageHandler.getUInt(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterDomain called, id", domainID); + am_Error_e returnCode = mRoutingReceiveInterface->deregisterDomain(domainID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + mpRoutingSenderDbus->removeDomainLookup(domainID); +} - int handle = mDBUSMessageHandler.getInt32(); - int volume = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceVolume called, handle", handle, "volume", volume, "error", error); +void IAmRoutingReceiverShadowDbus::deregisterGateway(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_gatewayID_t gatewayID = mDBUSMessageHandler.getUInt(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterGateway called, id", gatewayID); + am_Error_e returnCode = mRoutingReceiveInterface->deregisterGateway(gatewayID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); +} - am_Handle_s myhandle; - myhandle.handleType = H_SETSOURCEVOLUME; - myhandle.handle = handle; - am_volume_t mvolume = volume; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackSetSourceVolumeChange(myhandle,mvolume, merror); +void IAmRoutingReceiverShadowDbus::peekSink(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::string name = std::string(mDBUSMessageHandler.getString()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSink called, name", name); + am_sinkID_t sinkID; + am_Error_e returnCode = mRoutingReceiveInterface->peekSink(name, sinkID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sinkID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); +} +void IAmRoutingReceiverShadowDbus::deregisterSink(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_sinkID_t sinkID = mDBUSMessageHandler.getInt(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterSink called, id", sinkID); + am_Error_e returnCode = mRoutingReceiveInterface->deregisterSink(sinkID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + mpRoutingSenderDbus->removeSinkLookup(sinkID); } -void IAmRoutingReceiverShadow::ackSetSinkSoundProperty(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::peekSource(DBusConnection* conn, DBusMessage* msg) { + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::string name = std::string(mDBUSMessageHandler.getString()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSource called, name", name); + am_sourceID_t sourceID; + am_Error_e returnCode = mRoutingReceiveInterface->peekSource(name, sourceID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sourceID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); +} - (void) conn; - assert(mRoutingReceiveInterface!=NULL); +void IAmRoutingReceiverShadowDbus::deregisterSource(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_sourceID_t sourceID = mDBUSMessageHandler.getInt(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterSource called, id", sourceID); + am_Error_e returnCode = mRoutingReceiveInterface->deregisterSource(sourceID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + mpRoutingSenderDbus->removeSourceLookup(sourceID); +} - mDBUSMessageHandler.initReceive(msg); +void IAmRoutingReceiverShadowDbus::registerCrossfader(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_Crossfader_s crossfader; + crossfader.crossfaderID = mDBUSMessageHandler.getInt(); + crossfader.name = std::string(mDBUSMessageHandler.getString()); + crossfader.sinkID_A = mDBUSMessageHandler.getInt(); + crossfader.sinkID_B = mDBUSMessageHandler.getInt(); + crossfader.sourceID = mDBUSMessageHandler.getInt(); + crossfader.hotSink = (am_HotSink_e)((mDBUSMessageHandler.getInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::registerCrossfader called, name", crossfader.name); + am_Error_e returnCode = mRoutingReceiveInterface->registerCrossfader(crossfader, crossfader.crossfaderID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(crossfader.crossfaderID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + if (returnCode != E_OK) + { + log(&routingDbus, DLT_LOG_INFO, "error registering crossfader"); + return; + } + //todo: add Crossfader lookup +} - int handle = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSinkSoundProperty called, handle", handle, "error", error); +void IAmRoutingReceiverShadowDbus::deregisterCrossfader(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_crossfaderID_t crossfaderID = mDBUSMessageHandler.getInt(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::deregisterCrossfader called, id", crossfaderID); + am_Error_e returnCode = mRoutingReceiveInterface->deregisterCrossfader(crossfaderID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); + //todo: remove Crossfader lookup +} - am_Handle_s myhandle; - myhandle.handleType = H_SETSINKSOUNDPROPERTY; - myhandle.handle = handle; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackSetSinkSoundProperty(myhandle, merror); +void IAmRoutingReceiverShadowDbus::peekSourceClassID(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::string name = std::string(mDBUSMessageHandler.getString()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSourceClassID called, name", name); + am_sourceClass_t sourceClassID; + am_Error_e returnCode = mRoutingReceiveInterface->peekSourceClassID(name, sourceClassID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sourceClassID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); +} +void IAmRoutingReceiverShadowDbus::peekSinkClassID(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::string name = std::string(mDBUSMessageHandler.getString()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::peekSinkClassID called, name", name); + am_sinkClass_t sinkClassID; + am_Error_e returnCode = mRoutingReceiveInterface->peekSinkClassID(name, sinkClassID); + mDBUSMessageHandler.initReply(msg); + mDBUSMessageHandler.append(sinkClassID); + mDBUSMessageHandler.append(returnCode); + mDBUSMessageHandler.sendMessage(); } -void IAmRoutingReceiverShadow::ackSetSourceSoundProperty(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::hookInterruptStatusChange(DBusConnection* conn, DBusMessage* msg) { - (void) conn; - assert(mRoutingReceiveInterface!=NULL); + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_sourceID_t sourceID = mDBUSMessageHandler.getInt(); + am_InterruptState_e interruptState = (am_InterruptState_e)((mDBUSMessageHandler.getInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookInterruptStatusChange called, sourceID", sourceID); + mRoutingReceiveInterface->hookInterruptStatusChange(sourceID, interruptState); +} - mDBUSMessageHandler.initReceive(msg); +void IAmRoutingReceiverShadowDbus::hookSinkAvailablityStatusChange(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_sinkID_t sinkID = mDBUSMessageHandler.getInt(); + am_Availability_s avialabilty = mDBUSMessageHandler.getAvailability(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSinkAvailablityStatusChange called, sinkID", sinkID); + mRoutingReceiveInterface->hookSinkAvailablityStatusChange(sinkID, avialabilty); +} - int handle = mDBUSMessageHandler.getInt32(); - int error = mDBUSMessageHandler.getInt32(); - log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::ackSetSourceSoundProperty called, handle", handle, "error", error); +void IAmRoutingReceiverShadowDbus::hookSourceAvailablityStatusChange(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_sourceID_t sourceID = mDBUSMessageHandler.getInt(); + am_Availability_s avialabilty = mDBUSMessageHandler.getAvailability(); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookSourceAvailablityStatusChange called, sourceID", sourceID); + mRoutingReceiveInterface->hookSourceAvailablityStatusChange(sourceID, avialabilty); +} +void IAmRoutingReceiverShadowDbus::hookDomainStateChange(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_domainID_t domainID = mDBUSMessageHandler.getInt(); + am_DomainState_e domainState = (am_DomainState_e)((mDBUSMessageHandler.getInt())); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookDomainStateChange called, hookDomainStateChange", domainID); + mRoutingReceiveInterface->hookDomainStateChange(domainID, domainState); +} - am_Handle_s myhandle; - myhandle.handleType = H_SETSOURCESOUNDPROPERTY; - myhandle.handle = handle; - am_Error_e merror = (am_Error_e) error; - mRoutingReceiveInterface->ackSetSourceSoundProperty(myhandle, merror); +void IAmRoutingReceiverShadowDbus::hookTimingInformationChanged(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_connectionID_t connectionID(mDBUSMessageHandler.getInt()); + am_timeSync_t time(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookTimingInformationChanged called, connectionID", connectionID); + mRoutingReceiveInterface->hookTimingInformationChanged(connectionID, time); +} +void IAmRoutingReceiverShadowDbus::sendChangedData(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + std::vector < am_EarlyData_s > listEarlyData(mDBUSMessageHandler.getEarlyData()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadow::hookTimingInformationChanged called, sendChangedData"); + mRoutingReceiveInterface->sendChangedData(listEarlyData); } -DBusHandlerResult IAmRoutingReceiverShadow::receiveCallback(DBusConnection *conn, DBusMessage *msg, void *user_data) +DBusHandlerResult IAmRoutingReceiverShadowDbus::receiveCallback(DBusConnection* conn, DBusMessage* msg, void* user_data) { - assert(conn!=NULL); - assert(msg!=NULL); - assert(user_data!=NULL); - IAmRoutingReceiverShadow* reference=(IAmRoutingReceiverShadow*) user_data; - return (reference->receiveCallbackDelegate(conn,msg)); + assert(conn != NULL); + assert(msg != NULL); + assert(user_data != NULL); + IAmRoutingReceiverShadowDbus* reference = (IAmRoutingReceiverShadowDbus*) ((user_data)); + return (reference->receiveCallbackDelegate(conn, msg)); } -void IAmRoutingReceiverShadow::sendIntrospection(DBusConnection *conn, DBusMessage *msg) +void IAmRoutingReceiverShadowDbus::sendIntrospection(DBusConnection* conn, DBusMessage* msg) { - assert(conn!=NULL); - assert(msg!=NULL); + assert(conn != NULL); + assert(msg != NULL); DBusMessage* reply; DBusMessageIter args; dbus_uint32_t serial = 0; // create a reply from the message reply = dbus_message_new_method_return(msg); - //std::ifstream in(ROUTING_XML_FILE); - //assert(in!=NULL); std::ifstream in("RoutingReceiver.xml", std::ifstream::in); if (!in) { @@ -423,69 +617,121 @@ void IAmRoutingReceiverShadow::sendIntrospection(DBusConnection *conn, DBusMessa dbus_message_unref(reply); } -DBusHandlerResult IAmRoutingReceiverShadow::receiveCallbackDelegate(DBusConnection *conn, DBusMessage *msg) +DBusHandlerResult IAmRoutingReceiverShadowDbus::receiveCallbackDelegate(DBusConnection* conn, DBusMessage* msg) { - - if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) { - sendIntrospection(conn,msg); - return (DBUS_HANDLER_RESULT_HANDLED); - } - - functionMap_t::iterator iter = mFunctionMap.begin(); - std::string k(dbus_message_get_member(msg)); - log(&routingDbus, DLT_LOG_INFO, k.c_str()); - iter=mFunctionMap.find(k); + if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + { + sendIntrospection(conn, msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + functionMap_t::iterator iter = mFunctionMap.begin(); + std::string k(dbus_message_get_member(msg)); + log(&routingDbus, DLT_LOG_INFO, k.c_str()); + iter = mFunctionMap.find(k); if (iter != mFunctionMap.end()) { - std::string p(iter->first); - CallBackMethod cb=iter->second; - (this->*cb)(conn,msg); - return (DBUS_HANDLER_RESULT_HANDLED); + std::string p(iter->first); + CallBackMethod cb = iter->second; + (this->*cb)(conn, msg); + return (DBUS_HANDLER_RESULT_HANDLED); } - - return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); } -void IAmRoutingReceiverShadow::setRoutingReceiver(IAmRoutingReceive*& receiver) +void IAmRoutingReceiverShadowDbus::setRoutingReceiver(IAmRoutingReceive*& receiver) { - assert(receiver!=NULL); - mRoutingReceiveInterface=receiver; - - gObjectPathVTable.message_function=IAmRoutingReceiverShadow::receiveCallback; - - DBusConnection* connection; - mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper); - assert(mDBusWrapper!=NULL); - - mDBusWrapper->getDBusConnection(connection); - assert(connection!=NULL); - mDBUSMessageHandler.setDBusConnection(connection); - - std::string path(ROUTING_NODE); - mDBusWrapper->registerCallback(&gObjectPathVTable,path,this); - + assert(receiver != NULL); + mRoutingReceiveInterface = receiver; + gObjectPathVTable.message_function = IAmRoutingReceiverShadowDbus::receiveCallback; + DBusConnection* connection; + mRoutingReceiveInterface->getDBusConnectionWrapper(mDBusWrapper); + assert(mDBusWrapper != NULL); + mDBusWrapper->getDBusConnection(connection); + assert(connection != NULL); + mDBUSMessageHandler.setDBusConnection(connection); + std::string path(ROUTING_NODE); + { + assert(receiver != NULL); + } + mDBusWrapper->registerCallback(&gObjectPathVTable, path, this); } -IAmRoutingReceiverShadow::functionMap_t IAmRoutingReceiverShadow::createMap() +void IAmRoutingReceiverShadowDbus::confirmRoutingReady(DBusConnection* conn, DBusMessage* msg) { - functionMap_t m; - m["ackConnect"]=&IAmRoutingReceiverShadow::ackConnect ; - m["ackDisconnect"]=&IAmRoutingReceiverShadow::ackDisconnect ; - m["ackSetSinkVolume"]=&IAmRoutingReceiverShadow::ackSetSinkVolume ; - m["ackSetSourceVolume"]=&IAmRoutingReceiverShadow::ackSetSourceVolume ; - m["ackSinkVolumeTick"]=&IAmRoutingReceiverShadow::ackSinkVolumeTick ; - m["ackSourceVolumeTick"]=&IAmRoutingReceiverShadow::ackSourceVolumeTick ; - m["ackSetSinkSoundProperty"]=&IAmRoutingReceiverShadow::ackSetSinkSoundProperty ; - m["ackSetSourceSoundProperty"]=&IAmRoutingReceiverShadow::ackSetSourceSoundProperty ; - - m["registerDomain"]=&IAmRoutingReceiverShadow::registerDomain ; - m["registerSource"]=&IAmRoutingReceiverShadow::registerSource ; - m["registerSink"]=&IAmRoutingReceiverShadow::registerSink ; - m["registerGateway"]=&IAmRoutingReceiverShadow::registerGateway ; - - m["hookDomainRegistrationComplete"]=&IAmRoutingReceiverShadow::hookDomainRegistrationComplete; - return (m); + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_domainID_t domainID(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadowDbus::confirmRoutingReady called, domainID", domainID); + + mNumberDomains--; + if(mNumberDomains==0) + mRoutingReceiveInterface->confirmRoutingRundown(mHandle); } +void IAmRoutingReceiverShadowDbus::confirmRoutingRundown(DBusConnection* conn, DBusMessage* msg) +{ + (void) ((conn)); + assert(mRoutingReceiveInterface != NULL); + mDBUSMessageHandler.initReceive(msg); + am_domainID_t domainID(mDBUSMessageHandler.getInt()); + log(&routingDbus, DLT_LOG_INFO, "IAmRoutingReceiverShadowDbus::confirmRoutingRundown called, domainID", domainID); + + mNumberDomains--; + if(mNumberDomains==0) + mRoutingReceiveInterface->confirmRoutingReady(mHandle); +} +void IAmRoutingReceiverShadowDbus::gotReady(int16_t numberDomains, uint16_t handle) +{ + mNumberDomains=numberDomains; + mHandle=handle; +} +void IAmRoutingReceiverShadowDbus::gotRundown(int16_t numberDomains, uint16_t handle) +{ + mNumberDomains=numberDomains; + mHandle=handle; +} +IAmRoutingReceiverShadowDbus::functionMap_t IAmRoutingReceiverShadowDbus::createMap() +{ + functionMap_t m; + m["ackConnect"] = &IAmRoutingReceiverShadowDbus::ackConnect; + m["ackDisconnect"] = &IAmRoutingReceiverShadowDbus::ackDisconnect; + m["ackSetSinkVolume"] = &IAmRoutingReceiverShadowDbus::ackSetSinkVolume; + m["ackSetSourceVolume"] = &IAmRoutingReceiverShadowDbus::ackSetSourceVolume; + m["ackSetSourceState"] = &IAmRoutingReceiverShadowDbus::ackSetSourceState; + m["ackSinkVolumeTick"] = &IAmRoutingReceiverShadowDbus::ackSinkVolumeTick; + m["ackSourceVolumeTick"] = &IAmRoutingReceiverShadowDbus::ackSourceVolumeTick; + m["ackSetSinkSoundProperty"] = &IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperty; + m["ackSetSourceSoundProperty"] = &IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperty; + m["ackSetSinkSoundProperties"] = &IAmRoutingReceiverShadowDbus::ackSetSinkSoundProperties; + m["ackSetSourceSoundProperties"] = &IAmRoutingReceiverShadowDbus::ackSetSourceSoundProperties; + m["ackCrossFading"] = &IAmRoutingReceiverShadowDbus::ackCrossFading; + m["registerDomain"] = &IAmRoutingReceiverShadowDbus::registerDomain; + m["registerSource"] = &IAmRoutingReceiverShadowDbus::registerSource; + m["registerSink"] = &IAmRoutingReceiverShadowDbus::registerSink; + m["registerGateway"] = &IAmRoutingReceiverShadowDbus::registerGateway; + m["peekDomain"] = &IAmRoutingReceiverShadowDbus::peekDomain; + m["deregisterDomain"] = &IAmRoutingReceiverShadowDbus::deregisterDomain; + m["deregisterGateway"] = &IAmRoutingReceiverShadowDbus::deregisterGateway; + m["peekSink"] = &IAmRoutingReceiverShadowDbus::peekSink; + m["deregisterSink"] = &IAmRoutingReceiverShadowDbus::deregisterSink; + m["peekSource"] = &IAmRoutingReceiverShadowDbus::peekSource; + m["deregisterSource"] = &IAmRoutingReceiverShadowDbus::deregisterSource; + m["registerCrossfader"] = &IAmRoutingReceiverShadowDbus::registerCrossfader; + m["deregisterCrossfader"] = &IAmRoutingReceiverShadowDbus::deregisterCrossfader; + m["peekSourceClassID"] = &IAmRoutingReceiverShadowDbus::peekSourceClassID; + m["peekSinkClassID"] = &IAmRoutingReceiverShadowDbus::peekSinkClassID; + m["hookInterruptStatusChange"] = &IAmRoutingReceiverShadowDbus::hookInterruptStatusChange; + m["hookDomainRegistrationComplete"] = &IAmRoutingReceiverShadowDbus::hookDomainRegistrationComplete; + m["hookSinkAvailablityStatusChange"] = &IAmRoutingReceiverShadowDbus::hookSinkAvailablityStatusChange; + m["hookSourceAvailablityStatusChange"] = &IAmRoutingReceiverShadowDbus::hookSourceAvailablityStatusChange; + m["hookDomainStateChange"] = &IAmRoutingReceiverShadowDbus::hookDomainStateChange; + m["hookTimingInformationChanged"] = &IAmRoutingReceiverShadowDbus::hookTimingInformationChanged; + m["sendChangedData"] = &IAmRoutingReceiverShadowDbus::sendChangedData; + m["confirmRoutingReady"] = &IAmRoutingReceiverShadowDbus::confirmRoutingReady; + m["confirmRoutingRundown"] = &IAmRoutingReceiverShadowDbus::confirmRoutingRundown; + return (m); +} +} -- cgit v1.2.1