summaryrefslogtreecommitdiff
path: root/AudioManagerUtilities/src/CAmDbusWrapper.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'AudioManagerUtilities/src/CAmDbusWrapper.cpp')
-rw-r--r--AudioManagerUtilities/src/CAmDbusWrapper.cpp317
1 files changed, 181 insertions, 136 deletions
diff --git a/AudioManagerUtilities/src/CAmDbusWrapper.cpp b/AudioManagerUtilities/src/CAmDbusWrapper.cpp
index 1881526..504bf38 100644
--- a/AudioManagerUtilities/src/CAmDbusWrapper.cpp
+++ b/AudioManagerUtilities/src/CAmDbusWrapper.cpp
@@ -38,36 +38,38 @@ namespace am
/**
* introspectio header
*/
-#define ROOT_INTROSPECT_XML \
-DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
-"<node>" \
-"<interface name='org.AudioManager.freedesktop.DBus.Introspectable'>" \
-"<method name='Introspect'>" \
-" <arg name='xml_data' type='s' direction='out'/>" \
-"</method>" \
-"</interface>" \
-
-CAmDbusWrapper* CAmDbusWrapper::mpReference = NULL;
-
-CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler, DBusBusType type, const std::string& prefix, const std::string& objectPath) :
- pDbusPrepareCallback(this,&CAmDbusWrapper::dbusPrepareCallback),
- pDbusDispatchCallback(this, &CAmDbusWrapper::dbusDispatchCallback),
- pDbusFireCallback(this, &CAmDbusWrapper::dbusFireCallback),
- pDbusCheckCallback(this, &CAmDbusWrapper::dbusCheckCallback),
- pDbusTimerCallback(this, &CAmDbusWrapper::dbusTimerCallback),
- mpDbusConnection(0),
- mDBusError(),
- mListNodes(),
- mpListTimerhandles(),
- mpSocketHandler(socketHandler),
- mDbusType(type)
+#define ROOT_INTROSPECT_XML \
+ DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \
+ "<node>" \
+ "<interface name='org.AudioManager.freedesktop.DBus.Introspectable'>" \
+ "<method name='Introspect'>" \
+ " <arg name='xml_data' type='s' direction='out'/>" \
+ "</method>" \
+ "</interface>" \
+
+CAmDbusWrapper *CAmDbusWrapper::mpReference = NULL;
+
+CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler *socketHandler, DBusBusType type, const std::string &prefix, const std::string &objectPath)
+ : pDbusPrepareCallback(this, &CAmDbusWrapper::dbusPrepareCallback)
+ , pDbusDispatchCallback(this, &CAmDbusWrapper::dbusDispatchCallback)
+ , pDbusFireCallback(this, &CAmDbusWrapper::dbusFireCallback)
+ , pDbusCheckCallback(this, &CAmDbusWrapper::dbusCheckCallback)
+ , pDbusTimerCallback(this, &CAmDbusWrapper::dbusTimerCallback)
+ , mpDbusConnection(0)
+ , mDBusError()
+ , mListNodes()
+ , mpListTimerhandles()
+ , mpSocketHandler(socketHandler)
+ , mDbusType(type)
{
- assert(mpSocketHandler!=0);
+ assert(mpSocketHandler != 0);
dbus_error_init(&mDBusError);
if (!dbus_threads_init_default())
+ {
logError("CAmDbusWrapper::CAmDbusWrapper threads init call failed");
+ }
logInfo("DBusWrapper::DBusWrapper Opening DBus connection of:", prefix, objectPath);
mpDbusConnection = dbus_bus_get(mDbusType, &mDBusError);
@@ -76,6 +78,7 @@ CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler, DBusBusType type
logError("DBusWrapper::DBusWrapper Error while getting the DBus");
dbus_error_free(&mDBusError);
}
+
if (NULL == mpDbusConnection)
{
logError("DBusWrapper::DBusWrapper DBus Connection is null");
@@ -85,21 +88,21 @@ CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler, DBusBusType type
logInfo("DBusWrapper::DBusWrapper DBus Connection is", mpDbusConnection);
}
- //then we need to adopt the dbus to our mainloop:
- //first, we are old enought to live longer then the connection:
+ // then we need to adopt the dbus to our mainloop:
+ // first, we are old enought to live longer then the connection:
dbus_connection_set_exit_on_disconnect(mpDbusConnection, FALSE);
- //we do not need the manual dispatching, since it is not allowed to call from a different thread. So leave it uncommented:
- //dbus_connection_set_dispatch_status_function
+ // we do not need the manual dispatching, since it is not allowed to call from a different thread. So leave it uncommented:
+ // dbus_connection_set_dispatch_status_function
- //add watch functions:
+ // add watch functions:
dbus_bool_t watch = dbus_connection_set_watch_functions(mpDbusConnection, addWatch, removeWatch, toogleWatch, this, NULL);
if (!watch)
{
logError("DBusWrapper::DBusWrapper Registering of watch functions failed");
}
- //add timer functions:
+ // add timer functions:
dbus_bool_t timer = dbus_connection_set_timeout_functions(mpDbusConnection, addTimeout, removeTimeout, toggleTimeout, this, NULL);
if (!timer)
{
@@ -112,35 +115,35 @@ CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler, DBusBusType type
return;
}
- //register callback for Introspectio
+ // register callback for Introspectio
mObjectPathVTable.message_function = CAmDbusWrapper::cbRootIntrospection;
dbus_connection_register_object_path(mpDbusConnection, objectPath.c_str(), &mObjectPathVTable, this);
int ret = dbus_bus_request_name(mpDbusConnection, prefix.c_str(), DBUS_NAME_FLAG_DO_NOT_QUEUE, &mDBusError);
if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER == ret)
{
- logInfo("DBusWrapper::DBusWrapper We own", prefix);
+ logInfo("DBusWrapper::DBusWrapper We own", prefix);
}
else
{
std::ostringstream sserror("DBusWrapper::DBusWrapper ");
switch (ret)
{
- case -1:
- sserror << "Couldn't acquire name " << prefix << ". DBus message: " << mDBusError.message;
- dbus_error_free(&mDBusError);
- break;
- case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
- sserror << "We are queued for " << prefix;
- break;
- case DBUS_REQUEST_NAME_REPLY_EXISTS:
- sserror << ":-( " << prefix << " already exists!";
- break;
- case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
- sserror << "Eh? We already own " << prefix;
- break;
- default:
- sserror << "Unknown result = " << ret;
- break;
+ case -1:
+ sserror << "Couldn't acquire name " << prefix << ". DBus message: " << mDBusError.message;
+ dbus_error_free(&mDBusError);
+ break;
+ case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
+ sserror << "We are queued for " << prefix;
+ break;
+ case DBUS_REQUEST_NAME_REPLY_EXISTS:
+ sserror << ":-( " << prefix << " already exists!";
+ break;
+ case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
+ sserror << "Eh? We already own " << prefix;
+ break;
+ default:
+ sserror << "Unknown result = " << ret;
+ break;
}
logError(sserror.str());
@@ -150,12 +153,12 @@ CAmDbusWrapper::CAmDbusWrapper(CAmSocketHandler* socketHandler, DBusBusType type
CAmDbusWrapper::~CAmDbusWrapper()
{
- //close the connection again
+ // close the connection again
logInfo("DBusWrapper::~DBusWrapper Closing DBus connection");
dbus_connection_unref(mpDbusConnection);
- //clean up all timerhandles we created but did not delete before
- std::vector<sh_timerHandle_t*>::iterator it = mpListTimerhandles.begin();
+ // clean up all timerhandles we created but did not delete before
+ std::vector<sh_timerHandle_t *>::iterator it = mpListTimerhandles.begin();
for (; it != mpListTimerhandles.end(); ++it)
{
delete *it;
@@ -170,7 +173,7 @@ CAmDbusWrapper::~CAmDbusWrapper()
* @param userdata pointer to the class that will handle the callback
* @param prefix before the path which is optional
*/
-void CAmDbusWrapper::registerCallback(const DBusObjectPathVTable* vtable, const std::string& path, void* userdata, const std::string& prefix)
+void CAmDbusWrapper::registerCallback(const DBusObjectPathVTable *vtable, const std::string &path, void *userdata, const std::string &prefix)
{
logInfo("DBusWrapper::registerCallback register callback:", path);
@@ -182,16 +185,17 @@ void CAmDbusWrapper::registerCallback(const DBusObjectPathVTable* vtable, const
logError("DBusWrapper::registerCallack error: ", mDBusError.message);
dbus_error_free(&mDBusError);
}
+
mListNodes.push_back(path);
}
/**
-* register signal watch callback to matching rule
-* @param handler pointer to the callback function
-* @param rule signal watch rule like "type='signal',interface='org.genivi.audiomanager.something'"
-* @param userdata userdata
-*/
-void CAmDbusWrapper::registerSignalWatch(DBusHandleMessageFunction handler, const std::string& rule, void* userdata)
+ * register signal watch callback to matching rule
+ * @param handler pointer to the callback function
+ * @param rule signal watch rule like "type='signal',interface='org.genivi.audiomanager.something'"
+ * @param userdata userdata
+ */
+void CAmDbusWrapper::registerSignalWatch(DBusHandleMessageFunction handler, const std::string &rule, void *userdata)
{
logInfo("DBusWrapper::registerSignalWatch register callback:", rule);
dbus_error_init(&mDBusError);
@@ -205,6 +209,7 @@ void CAmDbusWrapper::registerSignalWatch(DBusHandleMessageFunction handler, cons
dbus_error_free(&mDBusError);
}
}
+
/**
* internal callback for the root introspection
* @param conn
@@ -214,28 +219,29 @@ void CAmDbusWrapper::registerSignalWatch(DBusHandleMessageFunction handler, cons
*/
DBusHandlerResult CAmDbusWrapper::cbRootIntrospection(DBusConnection *conn, DBusMessage *msg, void *reference)
{
- //logInfo("DBusWrapper::~cbRootIntrospection called:");
+ // logInfo("DBusWrapper::~cbRootIntrospection called:");
- mpReference = (CAmDbusWrapper*) reference;
+ mpReference = (CAmDbusWrapper *)reference;
std::vector<std::string> nodesList = mpReference->mListNodes;
- DBusMessage * reply;
- DBusMessageIter args;
- dbus_uint32_t serial = 0;
+ DBusMessage *reply;
+ DBusMessageIter args;
+ dbus_uint32_t serial = 0;
if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect"))
{
std::vector<std::string>::iterator nodeIter = nodesList.begin();
- const char *xml = ROOT_INTROSPECT_XML;
- std::stringstream introspect;
+ const char *xml = ROOT_INTROSPECT_XML;
+ std::stringstream introspect;
introspect << std::string(xml);
for (; nodeIter != nodesList.end(); ++nodeIter)
{
introspect << "<node name='" << nodeIter->c_str() << "'/>";
}
+
introspect << "</node>";
reply = dbus_message_new_method_return(msg);
- std::string s = introspect.str();
- const char* string = s.c_str();
+ std::string s = introspect.str();
+ const char *string = s.c_str();
// add the arguments to the reply
dbus_message_iter_init_append(reply, &args);
@@ -249,6 +255,7 @@ DBusHandlerResult CAmDbusWrapper::cbRootIntrospection(DBusConnection *conn, DBus
{
logError("DBusWrapper::~cbRootIntrospection DBUS Out Of Memory!");
}
+
dbus_connection_flush(conn);
// free the reply
dbus_message_unref(reply);
@@ -265,58 +272,65 @@ DBusHandlerResult CAmDbusWrapper::cbRootIntrospection(DBusConnection *conn, DBus
* returns the dbus connection
* @param connection pointer to the connection
*/
-void CAmDbusWrapper::getDBusConnection(DBusConnection *& connection) const
+void CAmDbusWrapper::getDBusConnection(DBusConnection * &connection) const
{
connection = mpDbusConnection;
}
dbus_bool_t CAmDbusWrapper::addWatch(DBusWatch *watch, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
return (mpReference->addWatchDelegate(watch, userData));
}
-dbus_bool_t CAmDbusWrapper::addWatchDelegate(DBusWatch * watch, void* userData)
+dbus_bool_t CAmDbusWrapper::addWatchDelegate(DBusWatch *watch, void *userData)
{
- (void) userData;
- int16_t event = 0;
+ (void)userData;
+ int16_t event = 0;
sh_pollHandle_t handle = 0;
- uint flags = dbus_watch_get_flags(watch);
+ uint flags = dbus_watch_get_flags(watch);
/* no watch flags for disabled watches */
if (dbus_watch_get_enabled(watch))
{
if (flags & DBUS_WATCH_READABLE)
+ {
event |= POLLIN;
+ }
+
if (flags & DBUS_WATCH_WRITABLE)
+ {
event |= POLLOUT;
+ }
logInfo("DBusWrapper::addWatchDelegate entered new watch, fd=", dbus_watch_get_unix_fd(watch), "event flag=", event);
am_Error_e error = mpSocketHandler->addFDPoll(dbus_watch_get_unix_fd(watch), event, &pDbusPrepareCallback, &pDbusFireCallback, &pDbusCheckCallback, &pDbusDispatchCallback, watch, handle);
- //if everything is alright, add the watch and the handle to our map so we know this relationship
+ // if everything is alright, add the watch and the handle to our map so we know this relationship
if (error == E_OK && handle != 0)
{
mMapHandleWatch.insert(std::make_pair(watch, handle));
return (true);
}
+
logError("DBusWrapper::addWatchDelegate entering watch failed");
}
+
return (true);
}
void CAmDbusWrapper::removeWatch(DBusWatch *watch, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
mpReference->removeWatchDelegate(watch, userData);
}
void CAmDbusWrapper::removeWatchDelegate(DBusWatch *watch, void *userData)
{
- (void) userData;
- std::map<DBusWatch*, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
+ (void)userData;
+ std::map<DBusWatch *, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
iterator = mMapHandleWatch.find(watch);
if (iterator != mMapHandleWatch.end())
{
@@ -332,14 +346,14 @@ void CAmDbusWrapper::removeWatchDelegate(DBusWatch *watch, void *userData)
void CAmDbusWrapper::toogleWatch(DBusWatch *watch, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
mpReference->toogleWatchDelegate(watch, userData);
}
void CAmDbusWrapper::toogleWatchDelegate(DBusWatch *watch, void *userData)
{
- (void) userData;
+ (void)userData;
int16_t event = 0;
dbus_watch_get_unix_fd(watch);
uint flags = dbus_watch_get_flags(watch);
@@ -347,65 +361,75 @@ void CAmDbusWrapper::toogleWatchDelegate(DBusWatch *watch, void *userData)
if (dbus_watch_get_enabled(watch))
{
if (flags & DBUS_WATCH_READABLE)
+ {
event |= POLLIN;
+ }
+
if (flags & DBUS_WATCH_WRITABLE)
+ {
event |= POLLOUT;
+ }
}
- std::map<DBusWatch*, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
+
+ std::map<DBusWatch *, sh_pollHandle_t>::iterator iterator = mMapHandleWatch.begin();
iterator = mMapHandleWatch.find(watch);
if (iterator != mMapHandleWatch.end())
+ {
mpSocketHandler->updateEventFlags(iterator->second, event);
+ }
}
-dbus_bool_t CAmDbusWrapper::addTimeout(DBusTimeout *timeout, void* userData)
+dbus_bool_t CAmDbusWrapper::addTimeout(DBusTimeout *timeout, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
return (mpReference->addTimeoutDelegate(timeout, userData));
}
-dbus_bool_t CAmDbusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void* userData)
+dbus_bool_t CAmDbusWrapper::addTimeoutDelegate(DBusTimeout *timeout, void *userData)
{
(void)userData;
if (!dbus_timeout_get_enabled(timeout))
+ {
return (false);
+ }
- //calculate the timeout in timeval
+ // calculate the timeout in timeval
timespec pollTimeout;
- int localTimeout = dbus_timeout_get_interval(timeout);
- pollTimeout.tv_sec = localTimeout / 1000;
+ int localTimeout = dbus_timeout_get_interval(timeout);
+ pollTimeout.tv_sec = localTimeout / 1000;
pollTimeout.tv_nsec = (localTimeout % 1000) * 1000000;
- //prepare handle and callback. new is eval, but there is no other choice because we need the pointer!
- sh_timerHandle_t* handle = new sh_timerHandle_t;
+ // prepare handle and callback. new is eval, but there is no other choice because we need the pointer!
+ sh_timerHandle_t *handle = new sh_timerHandle_t;
mpListTimerhandles.push_back(handle);
- //add the timer to the pollLoop
+ // add the timer to the pollLoop
mpSocketHandler->addTimer(pollTimeout, &pDbusTimerCallback, *handle, timeout);
- //save the handle with dbus context
+ // save the handle with dbus context
dbus_timeout_set_data(timeout, handle, NULL);
return (true);
}
-void CAmDbusWrapper::removeTimeout(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::removeTimeout(DBusTimeout *timeout, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
mpReference->removeTimeoutDelegate(timeout, userData);
}
-void CAmDbusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void *userData)
{
- (void) userData;
- //get the pointer to the handle and remove the timer
- sh_timerHandle_t* handle = (sh_timerHandle_t*) dbus_timeout_get_data(timeout);
+ (void)userData;
+ // get the pointer to the handle and remove the timer
+ sh_timerHandle_t *handle = (sh_timerHandle_t *)dbus_timeout_get_data(timeout);
mpSocketHandler->removeTimer(*handle);
- //now go throught the timerlist and remove the pointer, free memory
- std::vector<sh_timerHandle_t*>::iterator it = mpListTimerhandles.begin();
+ // now go throught the timerlist and remove the pointer, free memory
+ std::vector<sh_timerHandle_t *>::iterator it = mpListTimerhandles.begin();
for (; it != mpListTimerhandles.end(); ++it)
{
if (*it == handle)
@@ -414,92 +438,111 @@ void CAmDbusWrapper::removeTimeoutDelegate(DBusTimeout *timeout, void* userData)
break;
}
}
+
delete handle;
- }
+}
-void CAmDbusWrapper::toggleTimeout(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::toggleTimeout(DBusTimeout *timeout, void *userData)
{
- mpReference = (CAmDbusWrapper*) userData;
- assert(mpReference!=0);
+ mpReference = (CAmDbusWrapper *)userData;
+ assert(mpReference != 0);
mpReference->toggleTimeoutDelegate(timeout, userData);
}
bool am::CAmDbusWrapper::dbusDispatchCallback(const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
+ (void)handle;
+ (void)userData;
bool returnVal = true;
dbus_connection_ref(mpDbusConnection);
if (dbus_connection_dispatch(mpDbusConnection) == DBUS_DISPATCH_COMPLETE)
+ {
returnVal = false;
+ }
+
dbus_connection_unref(mpDbusConnection);
- //logInfo("DBusWrapper::dbusDispatchCallback was called");
+ // logInfo("DBusWrapper::dbusDispatchCallback was called");
return (returnVal);
}
bool am::CAmDbusWrapper::dbusCheckCallback(const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
+ (void)handle;
+ (void)userData;
bool returnVal = false;
dbus_connection_ref(mpDbusConnection);
if (dbus_connection_get_dispatch_status(mpDbusConnection) == DBUS_DISPATCH_DATA_REMAINS)
+ {
returnVal = true;
+ }
+
dbus_connection_unref(mpDbusConnection);
- //logInfo("DBusWrapper::dbusCheckCallback was called");
+ // logInfo("DBusWrapper::dbusCheckCallback was called");
return (returnVal);
}
void am::CAmDbusWrapper::dbusFireCallback(const pollfd pollfd, const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
- assert(userData!=NULL);
+ (void)handle;
+ (void)userData;
+ assert(userData != NULL);
uint flags = 0;
if (pollfd.revents & POLLIN)
+ {
flags |= DBUS_WATCH_READABLE;
+ }
+
if (pollfd.revents & POLLOUT)
+ {
flags |= DBUS_WATCH_WRITABLE;
+ }
+
if (pollfd.revents & POLLHUP)
+ {
flags |= DBUS_WATCH_HANGUP;
+ }
+
if (pollfd.revents & POLLERR)
+ {
flags |= DBUS_WATCH_ERROR;
+ }
- DBusWatch *watch = (DBusWatch*) userData;
+ DBusWatch *watch = (DBusWatch *)userData;
dbus_connection_ref(mpDbusConnection);
dbus_watch_handle(watch, flags);
dbus_connection_unref(mpDbusConnection);
- //logInfo("DBusWrapper::dbusFireCallback was called");
+ // logInfo("DBusWrapper::dbusFireCallback was called");
}
-void CAmDbusWrapper::dbusPrepareCallback(const sh_pollHandle_t handle, void* userData)
+void CAmDbusWrapper::dbusPrepareCallback(const sh_pollHandle_t handle, void *userData)
{
- (void) handle;
- (void) userData;
+ (void)handle;
+ (void)userData;
dbus_connection_ref(mpDbusConnection);
while (dbus_connection_get_dispatch_status(mpDbusConnection) == DBUS_DISPATCH_DATA_REMAINS)
{
- dbus_connection_dispatch(mpDbusConnection);
- //logInfo("prepare was neccessary!");
+ dbus_connection_dispatch(mpDbusConnection);
+ // logInfo("prepare was neccessary!");
}
+
dbus_connection_unref(mpDbusConnection);
}
-void CAmDbusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void* userData)
+void CAmDbusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void *userData)
{
- (void) userData;
- //get the pointer to the handle and remove the timer
- sh_timerHandle_t* handle = (sh_timerHandle_t*) dbus_timeout_get_data(timeout);
+ (void)userData;
+ // get the pointer to the handle and remove the timer
+ sh_timerHandle_t *handle = (sh_timerHandle_t *)dbus_timeout_get_data(timeout);
- //stop or restart?
+ // stop or restart?
if (dbus_timeout_get_enabled(timeout))
{
- //calculate the timeout in timeval
+ // calculate the timeout in timeval
timespec pollTimeout;
- int localTimeout = dbus_timeout_get_interval(timeout);
- pollTimeout.tv_sec = localTimeout / 1000;
+ int localTimeout = dbus_timeout_get_interval(timeout);
+ pollTimeout.tv_sec = localTimeout / 1000;
pollTimeout.tv_nsec = (localTimeout % 1000) * 1000000;
mpSocketHandler->updateTimer(*handle, pollTimeout);
}
@@ -511,20 +554,22 @@ void CAmDbusWrapper::toggleTimeoutDelegate(DBusTimeout *timeout, void* userData)
void CAmDbusWrapper::dbusTimerCallback(sh_timerHandle_t handle, void *userData)
{
- assert(userData!=NULL);
- for (auto && timerHandle : mpListTimerhandles)
+ assert(userData != NULL);
+ for (auto &&timerHandle : mpListTimerhandles)
{
if (*timerHandle == handle)
{
- if (dbus_timeout_get_enabled((DBusTimeout*) userData))
+ if (dbus_timeout_get_enabled((DBusTimeout *)userData))
{
mpSocketHandler->restartTimer(handle);
}
- dbus_timeout_handle((DBusTimeout*) userData);
+
+ dbus_timeout_handle((DBusTimeout *)userData);
return;
}
}
+
logWarning("CAmDbusWrapper::dbusTimerCallback Unknown timer handle");
}
-}
+}