class CommandReceiver: public CommandReceiveInterface
{
public:
- CommandReceiver(DatabaseHandler* iDatabaseHandler, ControlSender* iControlSender, DBusWrapper* iDBusWrapper);
CommandReceiver(DatabaseHandler* iDatabaseHandler, ControlSender* iControlSender, SocketHandler* iSocketHandler);
CommandReceiver(DatabaseHandler* iDatabaseHandler, ControlSender* iControlSender, SocketHandler* iSocketHandler, DBusWrapper* iDBusWrapper);
virtual ~CommandReceiver();
virtual ~CommandSender();
am_Error_e startupInterface(CommandReceiveInterface* commandreceiveinterface);
am_Error_e stopInterface();
- void cbCommunicationReady();
- void cbCommunicationRundown();
- void cbNumberOfMainConnectionsChanged();
- void cbNumberOfSinksChanged();
- void cbNumberOfSourcesChanged();
+ am_Error_e cbCommunicationReady();
+ am_Error_e cbCommunicationRundown();
+ void cbNewMainConnection(const am_MainConnectionType_s mainConnection);
+ void cbRemovedMainConnection(const am_MainConnectionType_s mainConnection);
+ void cbNewSink(const am_SinkType_s sink);
+ void cbRemovedSink(const am_SinkType_s sink);
+ void cbNewSource(const am_SourceType_s source);
+ void cbRemovedSource(const am_SourceType_s source);
void cbNumberOfSinkClassesChanged();
void cbNumberOfSourceClassesChanged();
void cbMainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState);
- void cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s SoundProperty);
- void cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& SoundProperty);
+ void cbMainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s soundProperty);
+ void cbMainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s& soundProperty);
void cbSinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s& availability);
void cbSourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s& availability);
void cbVolumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume);
void cbSinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState);
- void cbSystemPropertyChanged(const am_SystemProperty_s& SystemProperty);
- void cbTimingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time);
+ void cbSystemPropertyChanged(const am_SystemProperty_s& systemProperty);
+ void cbTimingInformationChanged(const am_mainConnectionID_t mainConnectionID, const am_timeSync_t time);
uint16_t getInterfaceVersion() const;
am_Error_e getListPlugins(std::vector<std::string>& interfaces) const;
#ifdef UNIT_TEST
{
public:
ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, SocketHandler *iSocketHandler, Router* iRouter);
- ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, Router* iRouter);
virtual ~ControlReceiver();
am_Error_e getRoute(const bool onlyfree, const am_sourceID_t sourceID, const am_sinkID_t sinkID, std::vector<am_Route_s>& returnList);
am_Error_e connect(am_Handle_s& handle, am_connectionID_t& connectionID, const am_ConnectionFormat_e format, const am_sourceID_t sourceID, const am_sinkID_t sinkID);
#define DATABASEOBSERVER_H_
#include <audiomanagertypes.h>
+#include <SocketHandler.h>
+#include <queue>
namespace am
{
class TelnetServer;
class CommandSender;
class RoutingSender;
+
/**
* This class observes the Database and notifies other classes about important events, mainly the CommandSender.
*/
+
class DatabaseObserver
{
public:
- DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender);
- DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, TelnetServer *iTelnetServer);
+ DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler);
+ DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler, TelnetServer *iTelnetServer);
virtual ~DatabaseObserver();
void numberOfMainConnectionsChanged();
void numberOfSinkClassesChanged();
void sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState);
void systemPropertyChanged(const am_SystemProperty_s& SystemProperty);
void timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time);
+
+ void receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void* userData);
+ bool dispatcherCallback(const sh_pollHandle_t handle, void* userData);
+ bool checkerCallback(const sh_pollHandle_t handle, void* userData);
+
+ shPollFired_T<DatabaseObserver> receiverCallbackT;
+ shPollDispatch_T<DatabaseObserver> dispatcherCallbackT;
+ shPollCheck_T<DatabaseObserver> checkerCallbackT;
+
private:
+
+ enum do_msgID_e
+ {
+ MDO_cbNumberOfSinksChanged, //
+ MDO_cbNumberOfSourcesChanged, //
+ MDO_cbNumberOfMainConnectionsChanged, //
+ MDO_cbNumberOfSinkClassesChanged, //
+ MDO_cbNumberOfSourceClassesChanged, //
+ MDO_cbMainConnectionStateChanged, //
+ MDO_cbMainSinkSoundPropertyChanged, //
+ MDO_cbMainSourceSoundPropertyChanged, //
+ MDO_cbSinkAvailabilityChanged, //
+ MDO_cbSourceAvailabilityChanged, //
+ MDO_cbVolumeChanged, //
+ MDO_cbSinkMuteStateChanged, //
+ MDO_cbSystemPropertyChanged, //
+ MDO_cbTimingInformationChanged
+ };
+
+ struct do_connectionStateChanged_s
+ {
+ am_mainConnectionID_t connectionID;
+ am_ConnectionState_e connectionState;
+ };
+
+ struct do_mainSinkSoundPropertyChanged_s
+ {
+ am_sinkID_t sinkID;
+ am_MainSoundProperty_s SoundProperty;
+ };
+
+ struct do_mainSourceSoundPropertyChanged_s
+ {
+ am_sourceID_t sourceID;
+ am_MainSoundProperty_s SoundProperty;
+ };
+
+ struct do_sinkAvailabilityChanged_s
+ {
+ am_sinkID_t sinkID;
+ am_Availability_s availability;
+ };
+
+ struct do_sourceAvailabilityChanged_s
+ {
+ am_sourceID_t sourceID;
+ am_Availability_s availability;
+ };
+
+ struct do_volumeChanged_s
+ {
+ am_sinkID_t sinkID;
+ am_mainVolume_t volume;
+ };
+
+ struct do_sinkMuteStateChanged_s
+ {
+ am_sinkID_t sinkID;
+ am_MuteState_e muteState;
+ };
+
+ struct do_timingInformationChanged_s
+ {
+ am_mainConnectionID_t mainConnection;
+ am_timeSync_t time;
+ };
+
+ union do_parameter_u
+ {
+ do_connectionStateChanged_s connectionStateChanged;
+ do_mainSinkSoundPropertyChanged_s mainSinkSoundPropertyChanged;
+ do_mainSourceSoundPropertyChanged_s mainSourceSoundPropertyChanged;
+ do_sinkAvailabilityChanged_s sinkAvailabilityChanged;
+ do_sourceAvailabilityChanged_s sourceAvailabilityChanged;
+ do_volumeChanged_s volumeChanged;
+ do_sinkMuteStateChanged_s sinkMuteStateChanged;
+ do_timingInformationChanged_s timingInformationChanged;
+ am_SystemProperty_s systemProperty;
+ };
+
+ struct do_msg_s
+ {
+ do_msgID_e msgID;
+ do_parameter_u parameters;
+ };
+
+ void pipeCommand(const do_msg_s& message);
+
+ void commonConstructor(); //!< this is called from both constructors
CommandSender *mCommandSender; //!< pointer to the comandSender
RoutingSender* mRoutingSender; //!< pointer to the routingSender
TelnetServer* mTelnetServer; //!< pointer to the telnetserver
+ SocketHandler* mSocketHandler; //!< pointer to the sockethandler
+
+ int mPipe[2];
+ sh_pollHandle_t mHandle;
+ std::queue<do_msg_s> mQueue;
};
}
{
public:
RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler);
- RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, DBusWrapper *iDBusWrapper);
RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler, DBusWrapper *iDBusWrapper);
virtual ~RoutingReceiver();
void ackConnect(const am_Handle_s handle, const am_connectionID_t connectionID, const am_Error_e error);
using namespace am;
-CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSender *iControlSender, DBusWrapper *iDBusWrapper) :
- mDatabaseHandler(iDatabaseHandler), //
- mControlSender(iControlSender), //
- mDBusWrapper(iDBusWrapper)
-{
- assert(mDatabaseHandler!=NULL);
- assert(mDBusWrapper!=NULL);
- assert(mControlSender!=NULL);
-}
-
CommandReceiver::CommandReceiver(DatabaseHandler *iDatabaseHandler, ControlSender *iControlSender, SocketHandler *iSocketHandler) :
mDatabaseHandler(iDatabaseHandler), //
mControlSender(iControlSender), //
am_Error_e CommandReceiver::getSocketHandler(SocketHandler *& socketHandler) const
{
-#ifdef WITH_SOCKETHANDLER_LOOP
socketHandler = mSocketHandler;
return E_OK;
-#else
- return E_UNKNOWN;
-#endif /*WITH_SOCKETHANDLER_LOOP*/
}
uint16_t CommandReceiver::getInterfaceVersion() const
return E_OK;
}
+void am::CommandSender::cbNewMainConnection(const am_MainConnectionType_s mainConnection)
+{
+}
+
+void am::CommandSender::cbRemovedMainConnection(const am_MainConnectionType_s mainConnection)
+{
+}
+
+void am::CommandSender::cbNewSink(const am_SinkType_s sink)
+{
+}
+
+void am::CommandSender::cbRemovedSink(const am_SinkType_s sink)
+{
+}
+
+void am::CommandSender::cbNewSource(const am_SourceType_s source)
+{
+}
+
+void am::CommandSender::cbRemovedSource(const am_SourceType_s source)
+{
+}
+
void CommandSender::unloadLibraries(void)
{
std::vector<void*>::iterator iterator = mListLibraryHandles.begin();
assert(mRouter!=NULL);
}
-ControlReceiver::ControlReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, CommandSender *iCommandSender, Router* iRouter) :
- mDatabaseHandler(iDatabaseHandler), //
- mRoutingSender(iRoutingSender), //
- mCommandSender(iCommandSender), //
- mRouter(iRouter)
-{
- assert(mDatabaseHandler!=NULL);
- assert(mRoutingSender!=NULL);
- assert(mCommandSender!=NULL);
- assert(mRouter!=NULL);
-}
-
ControlReceiver::~ControlReceiver()
{
}
am_Error_e ControlReceiver::getSocketHandler(SocketHandler *& socketHandler)
{
-#ifdef WITH_SOCKETHANDLER_LOOP
socketHandler = mSocketHandler;
return E_OK;
-#else
- return E_UNKNOWN;
-#endif
}
void am::ControlReceiver::setCommandRundown()
DBusWrapper* DBusWrapper::mReference = NULL;
-DBusWrapper::DBusWrapper() :
- pDbusDispatchCallback(this, &DBusWrapper::dbusDispatchCallback), //
- pDbusFireCallback(this, &DBusWrapper::dbusFireCallback), //
- pDbusCheckCallback(this, &DBusWrapper::dbusCheckCallback), //
- pDbusTimerCallback(this, &DBusWrapper::dbusTimerCallback), //
- mDbusConnection(0), //
- mDBusError(), //
- mNodesList(), //
- mListTimerhandlePointer()
-{
- dbus_error_init(&mDBusError);
- logInfo("DBusWrapper::DBusWrapper Opening DBus connection");
- mDbusConnection = dbus_bus_get(DBUS_BUS_SESSION, &mDBusError);
- if (dbus_error_is_set(&mDBusError))
- {
- logError("DBusWrapper::DBusWrapper Error while getting the DBus");
- dbus_error_free(&mDBusError);
- }
- if (NULL == mDbusConnection)
- {
- logError("DBusWrapper::DBusWrapper DBus Connection is null");
- }
-
- //first, we are old enought to live longer then the connection:
- dbus_connection_set_exit_on_disconnect(mDbusConnection, FALSE);
-
- mObjectPathVTable.message_function = DBusWrapper::cbRootIntrospection;
- dbus_connection_register_object_path(mDbusConnection, DBUS_SERVICE_OBJECT_PATH, &mObjectPathVTable, this);
- int ret = dbus_bus_request_name(mDbusConnection, DBUS_SERVICE_PREFIX, DBUS_NAME_FLAG_DO_NOT_QUEUE, &mDBusError);
- if (dbus_error_is_set(&mDBusError))
- {
- logError("DBusWrapper::DBusWrapper Name Error",mDBusError.message);
- dbus_error_free(&mDBusError);
- }
- if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret)
- {
- logError("DBusWrapper::DBusWrapper Wrapper is not the Primary Owner",ret);
- exit(1);
- }
-}
-
DBusWrapper::DBusWrapper(SocketHandler* socketHandler) :
pDbusDispatchCallback(this, &DBusWrapper::dbusDispatchCallback), //
pDbusFireCallback(this, &DBusWrapper::dbusFireCallback), //
}
}
- logInfo("DatabaseHandler::enterSinkDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID);
+ logInfo("DatabaseHandler::enterSourceDB entered new source with name", sourceData.name, "domainID:", sourceData.domainID, "classID:", sourceData.sourceClassID, "visible:", sourceData.visible, "assigned ID:", sourceID);
am_Source_s source = sourceData;
source.sourceID = sourceID;
*/
#include "DatabaseObserver.h"
+#include <string.h>
+#include <cassert>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
#include "CommandSender.h"
#include "RoutingSender.h"
#include "TelnetServer.h"
-#include <cassert>
+#include "DLTWrapper.h"
using namespace am;
-DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender) :
+DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler) :
+ receiverCallbackT(this, &DatabaseObserver::receiverCallback), //
+ dispatcherCallbackT(this, &DatabaseObserver::dispatcherCallback), //
+ checkerCallbackT(this, &DatabaseObserver::checkerCallback), //
mCommandSender(iCommandSender), //
- mRoutingSender(iRoutingSender)
+ mRoutingSender(iRoutingSender), //
+ mSocketHandler(iSocketHandler), //
+ mPipe(), //
+ mHandle(), //
+ mQueue()
{
- assert(mCommandSender!=0);
- assert(mRoutingSender!=0);
+ commonConstructor();
}
-DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, TelnetServer *iTelnetServer) :
+DatabaseObserver::DatabaseObserver(CommandSender *iCommandSender, RoutingSender *iRoutingSender, SocketHandler *iSocketHandler, TelnetServer *iTelnetServer) :
+ receiverCallbackT(this, &DatabaseObserver::receiverCallback), //
+ dispatcherCallbackT(this, &DatabaseObserver::dispatcherCallback), //
+ checkerCallbackT(this, &DatabaseObserver::checkerCallback), //
mCommandSender(iCommandSender), //
mRoutingSender(iRoutingSender), //
- mTelnetServer(iTelnetServer)
+ mTelnetServer(iTelnetServer), //
+ mSocketHandler(iSocketHandler), //
+ mPipe(), //
+ mHandle(), //
+ mQueue()
+{
+ assert(mTelnetServer!=0);
+ commonConstructor();
+}
+
+void DatabaseObserver::pipeCommand(const do_msg_s & message)
+{
+ mQueue.push(message);
+
+ if (write(mPipe[1], &message.msgID, sizeof(do_msg_s)) == -1)
+ {
+ logError("DatabaseObserver::msgID pipe write failed, error code:", strerror(errno));
+ }
+}
+
+void DatabaseObserver::commonConstructor()
{
assert(mCommandSender!=0);
assert(mRoutingSender!=0);
- assert(mTelnetServer!=0);
+ assert(mSocketHandler!=0);
+ if (pipe(mPipe) == -1)
+ {
+ logError("RoutingReceiverAsyncShadow::setRoutingInterface could not create pipe!:");
+ throw "could not create pipe";
+ }
+
+ short event = 0;
+ event |= POLLIN;
+ mSocketHandler->addFDPoll(mPipe[0], event, NULL, &receiverCallbackT, &checkerCallbackT, &dispatcherCallbackT, NULL, mHandle);
}
DatabaseObserver::~DatabaseObserver()
void DatabaseObserver::newSink(am_Sink_s sink)
{
mRoutingSender->addSinkLookup(sink);
- mCommandSender->cbNumberOfSinksChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSinksChanged;
+ pipeCommand(msg);
+
}
void DatabaseObserver::newSource(am_Source_s source)
{
mRoutingSender->addSourceLookup(source);
- mCommandSender->cbNumberOfSourcesChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSourcesChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::newDomain(am_Domain_s domain)
void DatabaseObserver::removedSink(am_sinkID_t sinkID)
{
mRoutingSender->removeSinkLookup(sinkID);
- mCommandSender->cbNumberOfSinksChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSinksChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::removedSource(am_sourceID_t sourceID)
{
mRoutingSender->removeSourceLookup(sourceID);
- mCommandSender->cbNumberOfSourcesChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSourcesChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::removeDomain(am_domainID_t domainID)
void DatabaseObserver::numberOfMainConnectionsChanged()
{
- mCommandSender->cbNumberOfMainConnectionsChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfMainConnectionsChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::numberOfSinkClassesChanged()
{
- mCommandSender->cbNumberOfSinkClassesChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSinkClassesChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::numberOfSourceClassesChanged()
{
- mCommandSender->cbNumberOfSourceClassesChanged();
+ do_msg_s msg;
+ msg.msgID = MDO_cbNumberOfSourceClassesChanged;
+ pipeCommand(msg);
}
void DatabaseObserver::mainConnectionStateChanged(const am_mainConnectionID_t connectionID, const am_ConnectionState_e connectionState)
{
- mCommandSender->cbMainConnectionStateChanged(connectionID, connectionState);
+ do_msg_s msg;
+ msg.msgID = MDO_cbMainConnectionStateChanged;
+ msg.parameters.connectionStateChanged.connectionID = connectionID;
+ msg.parameters.connectionStateChanged.connectionState = connectionState;
+ pipeCommand(msg);
}
void DatabaseObserver::mainSinkSoundPropertyChanged(const am_sinkID_t sinkID, const am_MainSoundProperty_s SoundProperty)
{
- mCommandSender->cbMainSinkSoundPropertyChanged(sinkID, SoundProperty);
+ do_msg_s msg;
+ msg.msgID = MDO_cbMainSinkSoundPropertyChanged;
+ msg.parameters.mainSinkSoundPropertyChanged.sinkID = sinkID;
+ msg.parameters.mainSinkSoundPropertyChanged.SoundProperty = SoundProperty;
+ pipeCommand(msg);
}
void DatabaseObserver::mainSourceSoundPropertyChanged(const am_sourceID_t sourceID, const am_MainSoundProperty_s & SoundProperty)
{
- mCommandSender->cbMainSourceSoundPropertyChanged(sourceID, SoundProperty);
+ do_msg_s msg;
+ msg.msgID = MDO_cbMainSourceSoundPropertyChanged;
+ msg.parameters.mainSourceSoundPropertyChanged.sourceID = sourceID;
+ msg.parameters.mainSourceSoundPropertyChanged.SoundProperty = SoundProperty;
+ pipeCommand(msg);
}
void DatabaseObserver::sinkAvailabilityChanged(const am_sinkID_t sinkID, const am_Availability_s & availability)
{
- mCommandSender->cbSinkAvailabilityChanged(sinkID, availability);
+ do_msg_s msg;
+ msg.msgID = MDO_cbSinkAvailabilityChanged;
+ msg.parameters.sinkAvailabilityChanged.sinkID = sinkID;
+ msg.parameters.sinkAvailabilityChanged.availability = availability;
+ pipeCommand(msg);
}
void DatabaseObserver::sourceAvailabilityChanged(const am_sourceID_t sourceID, const am_Availability_s & availability)
{
- mCommandSender->cbSourceAvailabilityChanged(sourceID, availability);
+ do_msg_s msg;
+ msg.msgID = MDO_cbSourceAvailabilityChanged;
+ msg.parameters.sourceAvailabilityChanged.sourceID = sourceID;
+ msg.parameters.sourceAvailabilityChanged.availability = availability;
+ pipeCommand(msg);
}
void DatabaseObserver::volumeChanged(const am_sinkID_t sinkID, const am_mainVolume_t volume)
{
- mCommandSender->cbVolumeChanged(sinkID, volume);
+ do_msg_s msg;
+ msg.msgID = MDO_cbVolumeChanged;
+ msg.parameters.volumeChanged.sinkID = sinkID;
+ msg.parameters.volumeChanged.volume = volume;
+ pipeCommand(msg);
}
void DatabaseObserver::sinkMuteStateChanged(const am_sinkID_t sinkID, const am_MuteState_e muteState)
{
- mCommandSender->cbSinkMuteStateChanged(sinkID, muteState);
+ do_msg_s msg;
+ msg.msgID = MDO_cbSinkMuteStateChanged;
+ msg.parameters.sinkMuteStateChanged.sinkID = sinkID;
+ msg.parameters.sinkMuteStateChanged.muteState = muteState;
+ pipeCommand(msg);
}
void DatabaseObserver::systemPropertyChanged(const am_SystemProperty_s & SystemProperty)
{
- mCommandSender->cbSystemPropertyChanged(SystemProperty);
+ do_msg_s msg;
+ msg.msgID = MDO_cbSystemPropertyChanged;
+ msg.parameters.systemProperty = SystemProperty;
+ pipeCommand(msg);
}
void DatabaseObserver::timingInformationChanged(const am_mainConnectionID_t mainConnection, const am_timeSync_t time)
{
- mCommandSender->cbTimingInformationChanged(mainConnection, time);
+ do_msg_s msg;
+ msg.msgID = MDO_cbTimingInformationChanged;
+ msg.parameters.timingInformationChanged.mainConnection = mainConnection;
+ msg.parameters.timingInformationChanged.time = time;
+ pipeCommand(msg);
//todo:inform the controller via controlsender
}
+void DatabaseObserver::receiverCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
+{
+ (void) handle;
+ (void) userData;
+ //it is no really important what to read here, we will read the queue later...
+ char buffer[10];
+ if (read(pollfd.fd, buffer, 10) == -1)
+ {
+ logError("DatabaseObserver::receiverCallback could not read pipe!");
+ }
+}
+
+bool DatabaseObserver::dispatcherCallback(const sh_pollHandle_t handle, void *userData)
+{
+ (void) handle;
+ (void) userData;
+ do_msg_s msg;
+
+ msg = mQueue.front();
+ mQueue.pop();
+
+ switch (msg.msgID)
+ {
+ case MDO_cbNumberOfSinksChanged:
+ mCommandSender->cbNumberOfSinksChanged();
+ break;
+ case MDO_cbNumberOfSourcesChanged:
+ mCommandSender->cbNumberOfSourcesChanged();
+ break;
+ case MDO_cbNumberOfMainConnectionsChanged:
+ mCommandSender->cbNumberOfMainConnectionsChanged();
+ break;
+ case MDO_cbNumberOfSinkClassesChanged:
+ mCommandSender->cbNumberOfSinkClassesChanged();
+ break;
+ case MDO_cbNumberOfSourceClassesChanged:
+ mCommandSender->cbNumberOfSourceClassesChanged();
+ break;
+ case MDO_cbMainConnectionStateChanged:
+ mCommandSender->cbMainConnectionStateChanged(msg.parameters.connectionStateChanged.connectionID, msg.parameters.connectionStateChanged.connectionState);
+ break;
+ case MDO_cbMainSinkSoundPropertyChanged:
+ mCommandSender->cbMainSinkSoundPropertyChanged(msg.parameters.mainSinkSoundPropertyChanged.sinkID, msg.parameters.mainSinkSoundPropertyChanged.SoundProperty);
+ break;
+ case MDO_cbMainSourceSoundPropertyChanged:
+ mCommandSender->cbMainSourceSoundPropertyChanged(msg.parameters.mainSourceSoundPropertyChanged.sourceID, msg.parameters.mainSourceSoundPropertyChanged.SoundProperty);
+ break;
+ case MDO_cbSinkAvailabilityChanged:
+ mCommandSender->cbSinkAvailabilityChanged(msg.parameters.sinkAvailabilityChanged.sinkID, msg.parameters.sinkAvailabilityChanged.availability);
+ break;
+ case MDO_cbSourceAvailabilityChanged:
+ mCommandSender->cbSourceAvailabilityChanged(msg.parameters.sourceAvailabilityChanged.sourceID, msg.parameters.sourceAvailabilityChanged.availability);
+ break;
+ case MDO_cbVolumeChanged:
+ mCommandSender->cbVolumeChanged(msg.parameters.volumeChanged.sinkID, msg.parameters.volumeChanged.volume);
+ break;
+ case MDO_cbSinkMuteStateChanged:
+ mCommandSender->cbSinkMuteStateChanged(msg.parameters.sinkMuteStateChanged.sinkID, msg.parameters.sinkMuteStateChanged.muteState);
+ break;
+ case MDO_cbSystemPropertyChanged:
+ mCommandSender->cbSystemPropertyChanged(msg.parameters.systemProperty);
+ break;
+ case MDO_cbTimingInformationChanged:
+ mCommandSender->cbTimingInformationChanged(msg.parameters.timingInformationChanged.mainConnection, msg.parameters.timingInformationChanged.time);
+ break;
+ default:
+ logError("Something went totally wrong in DatabaseObserver::dispatcherCallback");
+ break;
+ }
+
+ if (mQueue.size() > 0)
+ return (true);
+ return (false);
+}
+
+bool DatabaseObserver::checkerCallback(const sh_pollHandle_t handle, void *userData)
+{
+ (void) handle;
+ (void) userData;
+ if (mQueue.size() > 0)
+ return (true);
+ return (false);
+}
+
using namespace am;
-am::RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler) :
+RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler) :
mDatabaseHandler(iDatabaseHandler), //
mRoutingSender(iRoutingSender), //
mControlSender(iControlSender), //
assert(mSocketHandler!=NULL);
}
-am::RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, DBusWrapper *iDBusWrapper) :
- mDatabaseHandler(iDatabaseHandler), //
- mRoutingSender(iRoutingSender), //
- mControlSender(iControlSender), //
- mDBusWrapper(iDBusWrapper) //
-{
- assert(mDatabaseHandler!=NULL);
- assert(mRoutingSender!=NULL);
- assert(mControlSender!=NULL);
- assert(mDBusWrapper!=NULL);
-}
-
-am::RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler, DBusWrapper *iDBusWrapper) :
+RoutingReceiver::RoutingReceiver(DatabaseHandler *iDatabaseHandler, RoutingSender *iRoutingSender, ControlSender *iControlSender, SocketHandler *iSocketHandler, DBusWrapper *iDBusWrapper) :
mDatabaseHandler(iDatabaseHandler), //
mRoutingSender(iRoutingSender), //
mControlSender(iControlSender), //
am_Error_e RoutingReceiver::peekSinkClassID(const std::string& name, am_sinkClass_t& sinkClassID)
{
- return mDatabaseHandler->peekSinkClassID(name,sinkClassID);
+ return mDatabaseHandler->peekSinkClassID(name, sinkClassID);
}
am_Error_e RoutingReceiver::peekSourceClassID(const std::string& name, am_sourceClass_t& sourceClassID)
{
- return mDatabaseHandler->peekSourceClassID(name,sourceClassID);
+ return mDatabaseHandler->peekSourceClassID(name, sourceClassID);
}
am_Error_e RoutingReceiver::getDBusConnectionWrapper(DBusWrapper *& dbusConnectionWrapper) const
am_Error_e RoutingReceiver::getSocketHandler(SocketHandler *& socketHandler) const
{
-#ifdef WITH_SOCKETHANDLER_LOOP
socketHandler = mSocketHandler;
return E_OK;
-#else
- return E_UNKNOWN;
-#endif
}
uint16_t RoutingReceiver::getInterfaceVersion() const
#ifdef WITH_TELNET
#include "TelnetServer.h"
#endif
-#ifdef WITH_SOCKETHANDLER_LOOP
-#include <SocketHandler.h>
-#endif
#ifdef WITH_DBUS_WRAPPER
#include <dbus/DBusWrapper.h>
#endif
+#include <SocketHandler.h>
#include "DatabaseHandler.h"
#include "ControlSender.h"
#include "CommandSender.h"
std::set_new_handler(&OutOfMemoryHandler);
//Instantiate all classes. Keep in same order !
-#ifdef WITH_SOCKETHANDLER_LOOP
SocketHandler iSocketHandler;
-#endif
+
#ifdef WITH_DBUS_WRAPPER
-#ifdef WITH_SOCKETHANDLER_LOOP
DBusWrapper iDBusWrapper(&iSocketHandler);
-#else /*WITH_SOCKETHANDLER_LOOP*/
- DBusWrapper iDBusWrapper;
-#endif /*WITH_SOCKETHANDLER_LOOP*/
#endif /*WITH_DBUS_WRAPPER */
DatabaseHandler iDatabaseHandler(databasePath);
Router iRouter(&iDatabaseHandler, &iControlSender);
#ifdef WITH_DBUS_WRAPPER
-#ifdef WITH_SOCKETHANDLER_LOOP
CommandReceiver iCommandReceiver(&iDatabaseHandler, &iControlSender, &iSocketHandler, &iDBusWrapper);
RoutingReceiver iRoutingReceiver(&iDatabaseHandler, &iRoutingSender, &iControlSender, &iSocketHandler, &iDBusWrapper);
ControlReceiver iControlReceiver(&iDatabaseHandler, &iRoutingSender, &iCommandSender, &iSocketHandler, &iRouter);
#ifdef WITH_TELNET
TelnetServer iTelnetServer(&iSocketHandler, &iCommandSender, &iCommandReceiver, &iRoutingSender, &iRoutingReceiver, &iControlSender, &iControlReceiver, &iDatabaseHandler, &iRouter, telnetport, maxConnections);
+ DatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
+#else /*WITH_TELNET*/
+ DatabaseObserver iObserver(&iCommandSender, &iSocketHandler, &iRoutingSender);
#endif
-#else /*WITH_SOCKETHANDLER_LOOP */
- CommandReceiver iCommandReceiver(&iDatabaseHandler,&iControlSender,&iDBusWrapper);
- RoutingReceiver iRoutingReceiver(&iDatabaseHandler,&iRoutingSender,&iControlSender,&iDBusWrapper);
- ControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender, &iRouter);
-#endif /*WITH_SOCKETHANDLER_LOOP*/
#else /*WITH_DBUS_WRAPPER*/
CommandReceiver iCommandReceiver(&iDatabaseHandler,&iControlSender,&iSocketHandler);
RoutingReceiver iRoutingReceiver(&iDatabaseHandler,&iRoutingSender,&iControlSender,&iSocketHandler);
ControlReceiver iControlReceiver(&iDatabaseHandler,&iRoutingSender,&iCommandSender,&iSocketHandler, &iRouter);
#ifdef WITH_TELNET
TelnetServer iTelnetServer(&iSocketHandler,telnetport,maxConnections);
+ DatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iSocketHandler, &iTelnetServer);
+#else /*WITH_TELNET*/
+ DatabaseObserver iObserver(&iCommandSender, &iSocketHandler, &iRoutingSender);
#endif
#endif /*WITH_DBUS_WRAPPER*/
-#ifdef WITH_TELNET
- DatabaseObserver iObserver(&iCommandSender, &iRoutingSender, &iTelnetServer);
-#else
- DatabaseObserver iObserver(&iCommandSender, &iRoutingSender);
-#endif
-
iDatabaseHandler.registerObserver(&iObserver);
//startup all the Plugins and Interfaces
//when the routingInterface is done, all plugins are loaded:
iControlSender.hookAllPluginsLoaded();
-#ifdef WITH_SOCKETHANDLER_LOOP
+ //start the mainloop here....
iSocketHandler.start_listenting();
-#endif /*WITH_SOCKETHANDLER_LOOP*/
-
-#ifdef WITH_DBUS_WRAPPER
-#ifdef WITH_SIMPLEDBUS_LOOP
- iDBusWrapper.dbusMainLoop();
-#endif/*WITH_SIMPLEDBUS_LOOP*/
-#endif /*WITH_DBUS_WRAPPER*/
close(fd0);
close(fd1);
#include <vector>
#include <set>
#include "DLTWrapper.h"
+#include <dbus/DBusWrapper.h>
+#include "MockInterfaces.h"
+#include "DatabaseHandler.h"
+#include "ControlReceiver.h"
+#include "RoutingReceiver.h"
+#include "DatabaseObserver.h"
+#include "ControlSender.h"
+#include "RoutingSender.h"
+#include "SocketHandler.h"
+#include "Router.h"
+#include "../RoutingInterfaceBackdoor.h"
+#include "../CommandInterfaceBackdoor.h"
+#include "../ControlInterfaceBackdoor.h"
+#include "../CommonFunctions.h"
using namespace am;
using namespace testing;
controlInterfaceTest::controlInterfaceTest() :
+ pSocketHandler(), //
pDBusWrapper((DBusWrapper*) 1), //
plistCommandPluginDirs(), //
plistRoutingPluginDirs(), //
pControlInterfaceBackdoor(), //
pControlSender(std::string("")), //
pRouter(&pDatabaseHandler,&pControlSender), //
- pDatabaseObserver(&pCommandSender, &pRoutingSender), //
+ pDatabaseObserver(&pCommandSender, &pSocketHandler, &pRoutingSender), //
pControlReceiver(&pDatabaseHandler, &pRoutingSender, &pCommandSender,&pRouter), //
pRoutingReceiver(&pDatabaseHandler, &pRoutingSender, &pControlSender, pDBusWrapper)
{
#include <gtest/gtest.h>
#include <gmock/gmock.h>
-#include <dbus/DBusWrapper.h>
-#include "MockInterfaces.h"
-#include "DatabaseHandler.h"
-#include "ControlReceiver.h"
-#include "RoutingReceiver.h"
-#include "DatabaseObserver.h"
-#include "ControlSender.h"
-#include "RoutingSender.h"
-#include "Router.h"
-#include "../RoutingInterfaceBackdoor.h"
-#include "../CommandInterfaceBackdoor.h"
-#include "../ControlInterfaceBackdoor.h"
-#include "../CommonFunctions.h"
+
+class DatbaseHandler;
+class SocketHandler;
+class RoutingSender;
+class CommandSender;
+class RoutingInterfaceBackdoor;
+class CommandInterfaceBackdoor;
+class ControlSender;
+class Router;
+class DatabaseObserver;
+class ControlReceiver;
+class RoutingReceiver;
+class CommonFunctions;
+
namespace am
{
public:
controlInterfaceTest();
~controlInterfaceTest();
+ SocketHandler pSocketHandler;
DBusWrapper* pDBusWrapper;
std::vector<std::string> plistCommandPluginDirs;
std::vector<std::string> plistRoutingPluginDirs;
OPTION( WITH_DBUS_WRAPPER
"Enable Dbus Wrapper Support" ON )
-OPTION( WITH_SOCKETHANDLER_LOOP
- "Enable SocketHandler Support (cannot work with SimpleDBusLoop)" ON )
-
-OPTION( WITH_SIMPLEDBUS_LOOP
- "Enable SimpleDBusLoop (requires DBus_Wrapper,cannot work with SocketHandler)" OFF )
-
OPTION( WITH_TESTS
"Build together with all available unitTest" ON )
CONFIGURE_FILE( ${CMAKE_SOURCE_DIR}/cmake/config.cmake ${CMAKE_SOURCE_DIR}/includes/config.h )
FIND_PACKAGE(PkgConfig)
-pkg_check_modules(DLT REQUIRED automotive-dlt)
+pkg_check_modules(DLT REQUIRED automotive-dlt>=2.2.0) #this is due to BUGFIX [GDLT-41]
IF(WITH_DOCUMENTATION)
find_package(Doxygen)
mCommandReceiveInterface->getListMainSinks(newListSinks);
std::sort(newListSinks.begin(), newListSinks.end(), sortBySinkID());
std::set_symmetric_difference(newListSinks.begin(), newListSinks.end(), mlistSinks.begin(), mlistSinks.end(), std::back_inserter(diffList), sortBySinkID());
- assert(diffList.size()==1);
if (mReady)
{
if (newListSinks.size() > mlistSinks.size())
{
- mDBUSMessageHandler.initSignal(std::string(MY_NODE), "SinkAdded");
- mDBUSMessageHandler.append(diffList[0]);
-
- log(&commandDbus, DLT_LOG_INFO, "send signal SinkAdded");
-
+ std::vector<am_SinkType_s>::iterator iter(diffList.begin());
+ for (;iter!=diffList.end();++iter)
+ {
+ mDBUSMessageHandler.initSignal(std::string(MY_NODE), "SinkAdded");
+ mDBUSMessageHandler.append(*iter);
+
+ log(&commandDbus, DLT_LOG_INFO, "send signal SinkAdded");
+ mDBUSMessageHandler.sendMessage();
+ }
}
else
{
- mDBUSMessageHandler.initSignal(std::string(MY_NODE), "SinkRemoved");
- mDBUSMessageHandler.append(diffList.begin()->sinkID);
-
- log(&commandDbus, DLT_LOG_INFO, "send signal SinkRemoved");
+ std::vector<am_SinkType_s>::iterator iter(diffList.begin());
+ for (;iter!=diffList.end();++iter)
+ {
+ mDBUSMessageHandler.initSignal(std::string(MY_NODE), "SinkAdded");
+ mDBUSMessageHandler.append(*iter);
+
+ log(&commandDbus, DLT_LOG_INFO, "send signal SinkAdded");
+ mDBUSMessageHandler.sendMessage();
+ }
}
- mDBUSMessageHandler.sendMessage();
}
mlistSinks = newListSinks;
#include <fcntl.h>
#include <sys/un.h>
#include <errno.h>
+#include <string>
#include "DLTWrapper.h"
using namespace am;
You will need some packages in order to comile the GENIVI AudioManager Daemon, these are:
-dbus (only when DBUS_WRAPPER==ON) [tested on version 1.2.16]
-sqlite3 [tested on version 3.6.22]
- -automotive-dlt [tested on version 2.2.0]
+ -automotive-dlt [greater 2.5.0]
-doxygen (only when WITH_DOCUMENTATION==ON) [tested on version 1.6.3]
to install them in a build environment like Ubuntu you can use:
sudo apt-get upgrade
sudo apt-get install libdbus-1-dev libsqlite3-dev doxygen libgtest-dev google-mock git cmake build-essential python2.6-dev
- git clone https://<kavi-account>:<kavi-password>@git.genivi.org/srv/git/DLT-daemon
+ git clone https://<kavi-account>:<kavi-password>@git.genivi.org/srv/git/AudioManager
In order to build the project (out of source build), please follow these instructions on the commandline:
# This could be handy for archiving the generated documentation or
# if some version control system is used.
-PROJECT_NUMBER = 0.9.30
+PROJECT_NUMBER = 0.9.32
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
# base path where the generated documentation will be put.
#cmakedefine DAEMONVERSION "@DAEMONVERSION@"
#cmakedefine WITH_DBUS_WRAPPER
-#cmakedefine WITH_SOCKETHANDLER_LOOP
-#cmakedefine WITH_SIMPLEDBUS_LOOP
#cmakedefine WITH_PPOLL
#cmakedefine WITH_TELNET
#cmakedefine GLIB_DBUS_TYPES_TOLERANT
projects / profile / ivi / audiomanager.git / commitdiff