From 95c696f818b6840bcbefe6d376ff01fa02dfd772 Mon Sep 17 00:00:00 2001 From: Jens Lorenz Date: Tue, 3 Jul 2018 17:42:05 +0200 Subject: FOO: Issue #26 fix white space issues and apply new coding style Signed-off-by: Jens Lorenz --- AudioManagerUtilities/src/CAmDbusWrapper.cpp | 317 +++++++++++++++------------ 1 file changed, 181 insertions(+), 136 deletions(-) (limited to 'AudioManagerUtilities/src/CAmDbusWrapper.cpp') 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 \ -"" \ -"" \ -"" \ -" " \ -"" \ -"" \ - -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 \ + "" \ + "" \ + "" \ + " " \ + "" \ + "" \ + +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::iterator it = mpListTimerhandles.begin(); + // clean up all timerhandles we created but did not delete before + std::vector::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 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::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 << ""; } + introspect << ""; 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::iterator iterator = mMapHandleWatch.begin(); + (void)userData; + std::map::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::iterator iterator = mMapHandleWatch.begin(); + + std::map::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::iterator it = mpListTimerhandles.begin(); + // now go throught the timerlist and remove the pointer, free memory + std::vector::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"); } -} +} -- cgit v1.2.1