# 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)
/**
* 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,
#define _CAMSDBUSMESSAGEHANDLER_H_
-#include <audiomanagertypes.h>
#include <dbus/dbus.h>
-#include <dlt/dlt.h>
#include <vector>
#include <sstream>
#include <string>
#include <list>
+#include "audiomanagertypes.h"
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
* @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<am::am_EarlyData_s> 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
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);
dbus_uint32_t mSerial;
std::string mErrorName;
std::string mErrorMsg;
- DBusMessage* mDbusMessage;
- DBusMessage* mReveiveMessage;
- DBusConnection* mDBusConnection;
+ DBusMessage* mpDBusMessage;
+ DBusMessage* mpReveiveMessage;
+ DBusConnection* mpDBusConnection;
};
}
/**
* 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,
//#include "headers.h"
#include <dbus/dbus.h>
+#include <string>
+#include <vector>
+#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<am_SoundProperty_s> 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_ */
#define ROUTINGSENDER_H_
#include "routing/IAmRoutingSend.h"
-#include <dbus/dbus.h>
-#include <map>
#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<am_SoundProperty_s>& 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<am_SoundProperty_s>& 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<am_SoundProperty_s>& 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<am_SoundProperty_s>& 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<am_domainID_t,rs_lookupData_s> mapDomain_t;
+ typedef std::map<am_sinkID_t,rs_lookupData_s> mapSinks_t;
+ typedef std::map<am_sourceID_t,rs_lookupData_s> mapSources_t;
+ typedef std::map<am_connectionID_t,rs_lookupData_s> mapConnections_t;
+ typedef std::map<uint16_t,rs_lookupData_s> mapHandles_t;
+ mapDomain_t mMapDomains;
+ mapSinks_t mMapSinks;
+ mapSources_t mMapSources;
+ mapConnections_t mMapConnections;
+ mapHandles_t mMapHandles;
- DBusConnection* connection;
};
+}
#endif /* ROUTINGSENDER_H_ */
/**
* 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,
#ifndef _IAMROUTINGRECEIVERSHADOW_H_
#define _IAMROUTINGRECEIVERSHADOW_H_
-#include "routing/IAmRoutingSend.h"
#include <dbus/dbus.h>
-#include <dlt/dlt.h>
#include <map>
-#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<std::string,CallBackMethod> functionMap_t;
- functionMap_t mFunctionMap;
- CAmDbusMessageHandler mDBUSMessageHandler;
+ typedef void (IAmRoutingReceiverShadowDbus::*CallBackMethod)(DBusConnection *connection, DBusMessage *message);
+ IAmRoutingReceive* mRoutingReceiveInterface;
+ CAmDbusWrapper* mDBusWrapper;
+ CAmRoutingSenderDbus* mpRoutingSenderDbus;
+
+ typedef std::map<std::string, CallBackMethod> 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();
};
}
<node>
<interface name="org.genivi.audiomanager.RoutingReceiver">
-
<method name="ackConnect">
- <arg name="handle" type="i" direction="in" />
- <arg name="connectionID" type="i" direction="in" />
- <arg name="error" type="i" direction="in" />
- </method>
- <method name="ackDisconnect">
- <arg name="handle" type="i" direction="in" />
- <arg name="connectionID" type="i" direction="in" />
- <arg name="error" type="i" direction="in" />
- </method>
- <method name="ackSetSinkVolumeChange">
- <arg name="handle" type="i" direction="in" />
- <arg name="volume" type="i" direction="in" />
- <arg name="error" type="i" direction="in" />
- </method>
- <method name="ackSetSourceVolumeChange">
- <arg name="handle" type="i" direction="in" />
- <arg name="connectionID" type="i" direction="in" />
- <arg name="error" type="i" direction="in" />
- </method>
- <method name="ackSetSourceState">
- <arg name="handle" type="u" direction="in" />
- <arg name="error" type="n" direction="in" />
- </method>
- <method name="ackSetSinkSoundProperty">
- <arg name="handle" type="u" direction="in" />
- <arg name="error" type="n" direction="in" />
- </method>
- <method name="ackSetSourceSoundProperty">
- <arg name="handle" type="u" direction="in" />
- <arg name="error" type="n" direction="in" />
- </method>
- <method name="ackCrossFading">
- <arg name="handle" type="u" direction="in" />
- <arg name="hotsink" type="q" direction="in" />
- <arg name="error" type="n" direction="in" />
- </method>
- <method name="ackSourceVolumeTick">
- <arg name="handle" type="u" direction="in" />
- <arg name="source" type="q" direction="in" />
- <arg name="volume" type="n" direction="in" />
- </method>
- <method name="ackSinkVolumeTick">
- <arg name="handle" type="u" direction="in" />
- <arg name="sink" type="q" direction="in" />
- <arg name="volume" type="n" direction="in" />
- </method>
-
-
- <method name="peekDomain">
- <arg name="name" type="s" direction="in" />
- <arg name="domainid" type="q" direction="in" />
- </method>
- <method name="registerDomain">
- <arg name="domaindata" type="(qsssbbq)" direction="in" />
- <arg name="domainid" type="q" direction="in" />
- </method>
- <method name="deregisterDomain">
- <arg name="domainid" type="q" direction="in" />
- </method>
-
-
+ <arg name="handle" type="q" direction="in" />
+ <arg name="connectionID" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackDisconnect">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="connectionID" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSinkVolume">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="volume" type="i" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSourceVolume">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="volume" type="i" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSourceState">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSinkSoundProperties">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSinkSoundProperty">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSourceSoundProperties">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSetSourceSoundProperty">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackCrossFading">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="hotsink" type="n" direction="in" />
+ <arg name="error" type="q" direction="in" />
+ </method>
+ <method name="ackSourceVolumeTick">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="source" type="q" direction="in" />
+ <arg name="volume" type="n" direction="in" />
+ </method>
+ <method name="ackSinkVolumeTick">
+ <arg name="handle" type="q" direction="in" />
+ <arg name="sink" type="q" direction="in" />
+ <arg name="volume" type="n" direction="in" />
+ </method>
+ <method name="peekDomain">
+ <arg name="name" type="s" direction="in" />
+ <arg name="domainid" type="q" direction="out" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="registerDomain">
+ <arg name="domaindata" type="qsssbbq" direction="in" /> <!-- am_domainID_t domainID; std::string name; std::string busname; std::string nodename; bool early; bool complete; am_DomainState_e state; -->
+ <arg name="returnBusname" type="s" direction="in" /> <!-- the busname for all communication to this domain -->
+ <arg name="returnPath" type="s" direction="in" /> <!-- the path for all communication to this domain -->
+ <arg name="returnInterface" type="s" direction="in" /> <!-- the interface for all communication to this domain -->
+ <arg name="domainid" type="q" direction="out" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="deregisterDomain">
+ <arg name="domainid" type="q" direction="in" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="registerGateway">
+ <arg name="gatewayData" type="qsqqqqqa(q)a(q)a(b)" direction="in" /> <!-- am_gatewayID_t gatewayID; std::string name; am_sinkID_t sinkID; am_sourceID_t sourceID; am_domainID_t domainSinkID; am_domainID_t domainSourceID; am_domainID_t controlDomainID; std::vector<am_ConnectionFormat_e> listSourceFormats; std::vector<am_ConnectionFormat_e> listSinkFormats; std::vector<bool> convertionMatrix; -->
+ <arg name="gatewayID" type="q" direction="out" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="deregisterGateway">
+ <arg name="gatewayID" type="q" direction="in" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="peekSink">
+ <arg name="name" type="s" direction="in" />
+ <arg name="sinkID" type="q" direction="out" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="registerSink">
+ <arg name="sinkData" type="qsqqnb(nn)nna(nn)ana(nn)" direction="in" /> <!-- am_sinkID_t sinkID; std::string name; am_domainID_t domainID; am_sinkClass_t sinkClassID; am_volume_t volume; bool visible; am_Availability_s available; am_MuteState_e muteState;am_mainVolume_t mainVolume; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats; std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->
+ <arg name="sinkID" type="q" direction="out" />
+ <arg name="error" type="q" direction="out" />
+ </method>
+ <method name="deregisterSink">
+ <arg name="sinkID" type="q" direction="in" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="peekSource">
+ <arg name="name" type="s" direction="in" />
+ <arg name="sourceID" type="q" direction="out" />
+ <arg name="error" type="i" direction="out" />
+ </method>
<method name="registerSource">
- <arg name="soucedata" type="(qqsqqnb(qq)q)" direction="in" />
- <arg name="sourceid" type="q" direction="in" />
+ <arg name="sourceData" type="qqsqqnb(nn)qa(nn)ana(nn)" direction="in" /> <!-- am_sourceID_t sourceID; am_domainID_t domainID; std::string name; am_sourceClass_t sourceClassID; am_SourceState_e sourceState; am_volume_t volume; bool visible; am_Availability_s available; am_InterruptState_e interruptState; std::vector<am_SoundProperty_s> listSoundProperties; std::vector<am_ConnectionFormat_e> listConnectionFormats; std::vector<am_MainSoundProperty_s> listMainSoundProperties; -->
+ <arg name="sourceID" type="q" direction="out" />
+ <arg name="error" type="i" direction="out" />
</method>
-
- <method name="deregisterSource">
- <arg name="sourceid" type="q" direction="in" />
- </method>
-
- <signal name="signal_systemReady">
- </signal>
-
+ <method name="deregisterSource">
+ <arg name="sourceid" type="q" direction="in" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="registerCrossfader">
+ <arg name="crossfaderData" type="qsqqqq" direction="in" /> <!-- am_crossfaderID_t crossfaderID; std::string name; am_sinkID_t sinkID_A; am_sinkID_t sinkID_B; am_sourceID_t sourceID; am_HotSink_e hotSink; -->
+ <arg name="crossfaderID" type="q" direction="out" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="deregisterCrossfader">
+ <arg name="crossfaderID" type="q" direction="in" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="peekSourceClassID">
+ <arg name="name" type="s" direction="in" />
+ <arg name="sourceClassID" type="q" direction="out" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="peekSinkClassID">
+ <arg name="name" type="s" direction="in" />
+ <arg name="sinkClassID" type="q" direction="out" />
+ <arg name="error" type="i" direction="out" />
+ </method>
+ <method name="hookInterruptStatusChange">
+ <arg name="sourceID" type="q" direction="in" />
+ <arg name="interruptState" type="q" direction="in" />
+ </method>
+ <method name="hookDomainRegistrationComplete">
+ <arg name="domainID" type="q" direction="in" />
+ </method>
+ <method name="hookSinkAvailablityStatusChange">
+ <arg name="sinkID" type="q" direction="in" />
+ <arg name="availability" type="(nn)" direction="out"/>
+ </method>
+ <method name="hookSourceAvailablityStatusChange">
+ <arg name="sourceID" type="q" direction="in" />
+ <arg name="availability" type="(nn)" direction="out"/>
+ </method>
+ <method name="hookDomainStateChange">
+ <arg name="domainID" type="q" direction="in" />
+ <arg name="domainState" type="q" direction="out"/>
+ </method>
+ <method name="hookTimingInformationChanged">
+ <arg name="connectionID" type="q" direction="in" />
+ <arg name="delay" type="n" direction="out"/>
+ </method>
+ <method name="sendChangedData"> <!--am_EarlyDataType_e type; am_DataType_u sinksource; am_EarlyData_u data; -->
+ <arg name="earlyData_volumes" type="a(qqn)" direction="in" /> <!-- only the volumes as array -->
+ <arg name="earlyData_soundproperties" type="a(qq(nn))" direction="in" /> <!--only the soundproperties as value -->
+ </method>
+ <method name="confirmRoutingReady">
+ <arg name="domainID" type="q" direction="in" />
+ </method>
+ <method name="confirmRoutingRundown">
+ <arg name="domainID" type="q" direction="in" />
+ </method>
+ <signal name="setRoutingReady">
+ </signal>
+ <signal name="setRoutingRundown">
+ </signal>
</interface>
</node>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE node PUBLIC
+ "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN"
+ "http://standards.freedesktop.org/dbus/1.0/introspect.dtd">
+
+<node>
+ <interface name='org.pulseaudio.genivi.RoutingSender'>
+ <method name='asyncAbort'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncConnect'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='connectionID' type='q' direction='in' />
+ <arg name='sourceID' type='q' direction='in' />
+ <arg name='sinkID' type='q' direction='in' />
+ <arg name='connectionFormat' type='n' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncDisconnect'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='connectionID' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='setSinkVolume'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sinkID' type='q' direction='in' />
+ <arg name='volume' type='n' direction='in' />
+ <arg name='ramp' type='n' direction='in' />
+ <arg name='time' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='setSourceVolume'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sourceID' type='q' direction='in' />
+ <arg name='volume' type='n' direction='in' />
+ <arg name='ramp' type='n' direction='in' />
+ <arg name='time' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncSetSourceState'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sourceID' type='q' direction='in' />
+ <arg name='sourceState' type='n' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncSetSinkSoundProperties'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sinkID' type='q' direction='in' />
+ <arg name='listSoundProperties' type='a(nn)' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncSetSinkSoundProperty'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sinkID' type='q' direction='in' />
+ <arg name='soundProperty' type='(nn)' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncSetSourceSoundProperty'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sourceID' type='q' direction='in' />
+ <arg name='soundProperty' type='(nn)' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncSetSourceSoundProperties'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='sourceID' type='q' direction='in' />
+ <arg name='listSoundProperties' type='a(nn)' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='asyncCrossFade'>
+ <arg name='handle' type='q' direction='in' />
+ <arg name='crossfaderID' type='q' direction='in' />
+ <arg name='hotSink' type='q' direction='in' />
+ <arg name='rampType' type='q' direction='in' />
+ <arg name='time' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+ <method name='setDomainState'>
+ <arg name='domainID' type='q' direction='in' />
+ <arg name='domainState' type='q' direction='in' />
+ <arg name='error' type='n' direction='out' />
+ </method>
+</interface>
+</node>
/**
* 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,
*/
#include "CAmDbusMessageHandler.h"
-#include "CAmRoutingSenderDbus.h"
#include "config.h"
-
-#include <stdlib.h>
-#include <assert.h>
+#include <cstdlib>
+#include <cassert>
#include <vector>
+#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<am_Availablility_e>(getInt(structIter, true));
+ availability.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(structIter, false));
dbus_message_iter_next(&mDBusMessageIter);
}
- return (param);
+ return (availability);
}
-double CAmDbusMessageHandler::getDouble()
+std::vector<am_EarlyData_s> CAmRoutingDbusMessageHandler::getEarlyData()
{
- double param;
- if (DBUS_TYPE_DOUBLE != dbus_message_iter_get_arg_type(&mDBusMessageIter))
+ std::vector<am_EarlyData_s> 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<am_EarlyDataType_e>(getUInt(structIter, true));
+ if (earlyData.type==ED_SINK_VOLUME)
+ earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
+ else
+ earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
+ earlyData.data.volume = static_cast<am_volume_t>(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<am_EarlyDataType_e>(getUInt(structIter, true));
+ if (earlyData.type==ED_SINK_PROPERTY)
+ earlyData.sinksource.sink = static_cast<am_sinkID_t>(getUInt(structIter, true));
+ else
+ earlyData.sinksource.source = static_cast<am_sourceID_t>(getUInt(structIter, true));
+ dbus_message_iter_recurse(&structIter, &soundpropIter);
+ earlyData.data.soundProperty.type = static_cast<am_SoundPropertyType_e>(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<am_domainID_t>(getUInt());
+ domainData.name = getString();
+ domainData.busname = getString();
+ domainData.nodename = getString();
+ domainData.early = getBool();
+ domainData.complete = getBool();
+ domainData.state = static_cast<am_DomainState_e>(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<am_sourceID_t>(getUInt());
+ sourceData.domainID = static_cast<am_domainID_t>(getUInt());
+ sourceData.name = getString();
+ sourceData.sourceClassID = static_cast<am_sourceClass_t>(getUInt());
+ sourceData.sourceState = static_cast<am_SourceState_e>(getUInt());
+ sourceData.volume = static_cast<am_volume_t>(getInt());
+ sourceData.visible = getBool();
+ dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
+ sourceData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
+ sourceData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
+ dbus_message_iter_next(&mDBusMessageIter);
+ sourceData.interruptState = static_cast<am_InterruptState_e>(getUInt());
+ dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+ do
+ {
+ dbus_message_iter_recurse(&arrayIter, &structIter);
+ soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+ soundProperty.value = static_cast<int16_t>(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<am_ConnectionFormat_e>(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<am_MainSoundPropertyType_e>(getInt(structIter, true));
+ mainSoundProperty.value = static_cast<int16_t>(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<am_sinkID_t>(getUInt());
+ sinkData.name = getString();
+ sinkData.domainID = static_cast<am_domainID_t>(getUInt());
+ sinkData.sinkClassID = static_cast<am_sinkClass_t>(getUInt());
+ sinkData.volume = static_cast<am_volume_t>(getInt());
+ sinkData.visible = getBool();
+ dbus_message_iter_recurse(&mDBusMessageIter, &availIter);
+ sinkData.available.availability = static_cast<am_Availablility_e>(getInt(availIter, true));
+ sinkData.available.availabilityReason = static_cast<am_AvailabilityReason_e>(getInt(availIter, false));
+ dbus_message_iter_next(&mDBusMessageIter);
+ sinkData.muteState = static_cast<am_MuteState_e>(getInt());
+ sinkData.mainVolume = static_cast<am_mainVolume_t>(getInt());
+
+ dbus_message_iter_recurse(&mDBusMessageIter, &arrayIter);
+ do
+ {
+ dbus_message_iter_recurse(&arrayIter, &structIter);
+ soundProperty.type = static_cast<am_SoundPropertyType_e>(getInt(structIter, true));
+ soundProperty.value = static_cast<int16_t>(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<am_ConnectionFormat_e>(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<am_MainSoundPropertyType_e>(getInt(structIter, true));
+ mainSoundProperty.value = static_cast<int16_t>(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<am_gatewayID_t>(getUInt());
+ gatewayData.name = getString();
+ gatewayData.sinkID = static_cast<am_sinkID_t>(getUInt());
+ gatewayData.sourceID = static_cast<am_sourceID_t>(getUInt());
+ gatewayData.domainSinkID = static_cast<am_domainID_t>(getUInt());
+ gatewayData.domainSourceID = static_cast<am_domainID_t>(getUInt());
+ gatewayData.controlDomainID = static_cast<am_domainID_t>(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<am_ConnectionFormat_e>(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<am_ConnectionFormat_e>(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<am_MainSoundPropertyType_e>(getInt(structIter, true));
+ mainSoundProperty.value = static_cast<int16_t>(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<am::am_MainConnectionType_s>& listMainConnections)
+void CAm
RoutingDbusMessageHandler::append(const std::vector<am::am_MainConnectionType_s>& listMainConnections)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
- std::vector<am::am_MainConnectionType_s>::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);
-
+ std::vector<am::am_MainConnectionType_s>::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<am::am_SinkType_s> & listMainSinks)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkType_s>& listMainSinks)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
DBusMessageIter availIter;
- std::vector<am::am_SinkType_s>::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);
-
+ std::vector<am::am_SinkType_s>::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<am::am_SourceType_s> & listMainSources)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceType_s>& listMainSources)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
DBusMessageIter availIter;
- std::vector<am::am_SourceType_s>::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);
-
+ std::vector<am::am_SourceType_s>::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<am::am_MainSoundProperty_s> & listMainSoundProperties)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_MainSoundProperty_s>& listMainSoundProperties)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
- std::vector<am::am_MainSoundProperty_s>::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)
+ std::vector<am::am_MainSoundProperty_s>::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<am::am_SourceClass_s> & listSourceClasses)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SourceClass_s>& listSourceClasses)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
DBusMessageIter propIter;
DBusMessageIter innerIter;
- std::vector<am::am_SourceClass_s>::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<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
- for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
+ std::vector<am::am_SourceClass_s>::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<am::am_ClassProperty_s>::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<am::am_SinkClass_s> & listSinkClasses)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SinkClass_s>& listSinkClasses)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
DBusMessageIter propIter;
DBusMessageIter innerIter;
- std::vector<am::am_SinkClass_s>::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<am::am_ClassProperty_s>::const_iterator listInnerIterator=listIterator->listClassProperties.begin();
- for(;listInnerIterator<listIterator->listClassProperties.end();++listInnerIterator)
+ std::vector<am::am_SinkClass_s>::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<am::am_ClassProperty_s>::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<am::am_SystemProperty_s> & listSystemProperties)
+void CAmRoutingDbusMessageHandler::append(const std::vector<am::am_SystemProperty_s>& listSystemProperties)
{
DBusMessageIter arrayIter;
DBusMessageIter structIter;
- std::vector<am::am_SystemProperty_s>::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)
+ std::vector<am::am_SystemProperty_s>::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!";
+ }
+}
+
+}
/**
* 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,
*/
#include "CAmDbusSend.h"
-#include <dlt/dlt.h>
+#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<am_SoundProperty_s> listSoundProperties)
+{
+ DBusMessageIter arrayIter;
+ DBusMessageIter structIter;
+ std::vector<am_SoundProperty_s>::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);
+}
}
/**
* 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,
* For further information see http://www.genivi.org/.
*/
-#include "shared/CAmDltWrapper.h"
-#include "shared/CAmDbusWrapper.h"
#include "CAmRoutingSenderDbus.h"
+#include <cassert>
+#include <map>
#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()
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");
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<int16_t>(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<int16_t>(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<int16_t>(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<int16_t>(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<am_SoundProperty_s>& 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<am_SoundProperty_s>& 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<int16_t>(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<am_SoundProperty_s> & 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<am_SoundProperty_s> & 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);
+}
+}
/**
* 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,
* For further information see http://www.genivi.org/.
*/
-
-#include <audiomanagertypes.h>
+#include "IAmRoutingReceiverShadow.h"
#include <string.h>
#include <fstream>
#include <stdexcept>
#include <cassert>
-#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)
{
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);
+}
+}
projects / profile / ivi / audiomanager.git / commitdiff