diff options
Diffstat (limited to 'video_in_hal/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp')
| -rwxr-xr-x | video_in_hal/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp | 1558 |
1 files changed, 0 insertions, 1558 deletions
diff --git a/video_in_hal/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp b/video_in_hal/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp deleted file mode 100755 index 73ce838..0000000 --- a/video_in_hal/nsframework/notification_persistent_service/server/src/ns_npp_notification_manager.cpp +++ /dev/null @@ -1,1558 +0,0 @@ -/* - * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// \defgroup <<Group Tag>> <<Group Name>> -/// \ingroup tag_NS_NPPService -/// . -//////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// \ingroup tag_NS_NPPService -/// \brief This file contains implementation of singleton class CNotificationManager. -/// -//////////////////////////////////////////////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////////////////////////////////////////////// -// Include Files -//////////////////////////////////////////////////////////////////////////////////////////////////// - -#include <native_service/ns_np_service.h> -#include <native_service/ns_message_center_if.h> -#include <native_service/ns_np_service_protocol.h> -#include <algorithm> -#include <utility> -#include <string> -#include <vector> -#include "ns_npp_types.h" -#include "ns_npp_notificationpersistentservicelog.h" -#include "ns_npp_threads.h" -#include "ns_npp_notification.h" -#include "ns_npp_persistent_data.h" -#include "ns_npp_state_notification.h" -#include "ns_npp_regular_notification.h" -#include "ns_npp_notification_manager.h" -#include "ns_npp_state_persistence_notification.h" -#include "ns_npp_state_nor_persistence_notification.h" -#include "ns_npp_state_persistence_user_notification.h" - -#ifdef NPP_PROFILEINFO_ENABLE -#include <sstream> -#endif - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// CNotificationManager -/// Constructor of CNotificationManager class -//////////////////////////////////////////////////////////////////////////////////////////////////// -CNotificationManager::CNotificationManager() { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - m_pmNotificationList = new(std::nothrow) Notification_Type(); // LCOV_EXCL_BR_LINE 11: unexpected branch - - m_pvPersistentList = new(std::nothrow) std::vector<std::string>(); // LCOV_EXCL_BR_LINE 11: unexpected branch - - m_pvUserPersistentList = new(std::nothrow) std::vector<std::string>(); // LCOV_EXCL_BR_LINE 11: unexpected branch - - if (NULL == CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread = - McOpenSender(NS_NPP_IMMEDIATE_PERSIST_THREAD_NAME); - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// ~CNotificationManager -/// Destructor of CNotificationManager class -//////////////////////////////////////////////////////////////////////////////////////////////////// -CNotificationManager::~CNotificationManager() { // LCOV_EXCL_START 14: Resident process, global instance not released - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotification; - - CNotification *l_pNotification = NULL; - - // delete the members in map of Notification - if (NULL != m_pmNotificationList) { - if (!m_pmNotificationList->empty()) { - for (l_itNotification = m_pmNotificationList->begin(); - l_itNotification != m_pmNotificationList->end(); - l_itNotification++) { - l_pNotification = (*l_itNotification).second; - - if (NULL != l_pNotification) { - delete l_pNotification; - l_pNotification = NULL; - } - } - - // clear the map - m_pmNotificationList->clear(); - } - - delete m_pmNotificationList; - m_pmNotificationList = NULL; - } - - // delete the members in vector of persistent notification - if (NULL != m_pvPersistentList) { - if (!m_pvPersistentList->empty()) { - // clear the vector - m_pvPersistentList->clear(); - } - - delete m_pvPersistentList; - m_pvPersistentList = NULL; - } - - // delete the members in vector of user persistent notification - if (NULL != m_pvUserPersistentList) { - if (!m_pvUserPersistentList->empty()) { - // clear the vector - m_pvUserPersistentList->clear(); - } - - delete m_pvUserPersistentList; - m_pvUserPersistentList = NULL; - } - - if (NULL != CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread) { - McClose(CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread); - CStateNorPersistenceNotification::m_hNSImmediatePersistenceThread = NULL; - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); -} -// LCOV_EXCL_STOP - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// CreateNotificationObject -/// This function is used to get notification object from map. If doesn't exists, it create new -/// object as per type of notification. -//////////////////////////////////////////////////////////////////////////////////////////////////// -CNotification *CNotificationManager::CreateNotificationObject(const std::string &f_cnotificationname, - const UI_32 f_uimsglength, - const EFrameworkunifiedNotificationType f_enotificationtype, - const UI_32 f_uidelay) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // pointer of notification object - CNotification *l_pNotification = NULL; - - // iterator to find notification from map of CNotification - Notification_Iterator_Type l_itNotification; - - if (NULL == m_pmNotificationList || NULL == m_pvPersistentList || NULL == m_pvUserPersistentList) { // LCOV_EXCL_START 6: double check, m_pmNotificationList, m_pvPersistentList, m_pvUserPersistentList can't be NULL // NOLINT[whitespace/line_length] - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map/vector object is NULL"); // LCOV_EXCL_LINE 6: m_pmNotificationList, m_pvPersistentList, m_pvUserPersistentList can't be NULL // NOLINT[whitespace/line_length] - return NULL; - } - // LCOV_EXCL_STOP - - // check if notification already exists - l_itNotification = m_pmNotificationList->find(f_cnotificationname); - - // if exists remove previous entry - if (m_pmNotificationList->end() != l_itNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Removing previous entry of notification %s from map", f_cnotificationname.c_str()); - m_pmNotificationList->erase(l_itNotification); - } - - switch (f_enotificationtype) { - // if notification is regular notification - case eFrameworkunifiedNotificationVar: { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Regular Notification :: %s", f_cnotificationname.c_str()); - l_pNotification = new(std::nothrow) CRegularNotification(f_cnotificationname, - f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - break; - } - - // if notification is state notification - case eFrameworkunifiedStateVar: { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "State Notification :: %s", f_cnotificationname.c_str()); - l_pNotification = new(std::nothrow) CStateNotification(f_cnotificationname, - f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - break; - } - - // if notification is persistence notification - case eFrameworkunifiedPersistedStateVar: { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "PersistedState Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_pNotification = new(std::nothrow) CStatePersistenceNotification(f_cnotificationname, - f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function - // insert notification in persistent notification vector - m_pvPersistentList->push_back(f_cnotificationname); - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory not allocated"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] - } - - break; - } - - // if notification is user persistence notification - case eFrameworkunifiedPersistedStateUserVar: { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "PersistedStateUser Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_pNotification = new(std::nothrow) CStatePersistenceUserNotification(f_cnotificationname, - f_uimsglength); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function - // insert notification in user persistent notification vector - m_pvUserPersistentList->push_back(f_cnotificationname); - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NULL pointer error"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] - } - - break; - } - - // if notification is immediate persistence notification - case eFrameworkunifiedImmediatePersistedStateVar: { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Immediate PersistedState Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_pNotification = new(std::nothrow) CStateNorPersistenceNotification(f_cnotificationname, - f_uimsglength, - f_uidelay); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - break; - } - - default: - break; - } - - if (NULL != l_pNotification) { - // insert notification in notification map - m_pmNotificationList->insert(make_pair(f_cnotificationname, l_pNotification)); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object creation failed for %s.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_pNotification; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// SearchNotification -/// This function is used to search whether notification object is present in map or not. -/// If present it sends the reference. -//////////////////////////////////////////////////////////////////////////////////////////////////// -CNotification *CNotificationManager::SearchNotification(const std::string &f_cnotificationname) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotification; - - if (NULL == m_pmNotificationList || f_cnotificationname.empty()) { // LCOV_EXCL_BR_LINE 6: double check, m_pmNotificationList can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map pointer is NULL"); // LCOV_EXCL_LINE 6: m_pmNotificationList can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - } else { - // check if this notification's object present in map - l_itNotification = m_pmNotificationList->find(f_cnotificationname); - - // if notification found in map - if (m_pmNotificationList->end() != l_itNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification found in map :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // get the notification object pointer from map - l_pNotification = (*l_itNotification).second; - } else { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Notification not found :: %s", f_cnotificationname.c_str()); - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_pNotification; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// SearchPersistenceNotification -/// This function is used to search for the given persistent notification in map. -//////////////////////////////////////////////////////////////////////////////////////////////////// -CStateNotification *CNotificationManager::SearchPersistenceNotification(const std::string &f_cnotificationname) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // pointer of notification object - CNotification *l_pNotification = NULL; - CStateNotification *l_pStateNotification = NULL; - - // search the notification in the map - l_pNotification = SearchNotification(f_cnotificationname); - - if (NULL != l_pNotification) { - if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType() || - eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType() || - eFrameworkunifiedImmediatePersistedStateVar == l_pNotification->GetNotificationType()) { - l_pStateNotification = static_cast<CStateNotification *>(l_pNotification); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "There is no persistence notification registered with name :: %s", - f_cnotificationname.c_str()); - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_pStateNotification; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnRegisterEvents -/// This function creates notification object depending on its type and if already created it adds -/// the service name to the list in the notification object. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnRegisterEvents(const std::string &f_cservicename, - const std::string &f_cnotificationname, - const UI_32 f_uimsglength, - const EFrameworkunifiedNotificationType f_enotificationtype, - const UI_32 f_uidelay) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - - if (f_cservicename.empty() || f_cnotificationname.empty()) { - l_estatus = eFrameworkunifiedStatusInvldParam; - } else { - // get the notification object from map or create new object - l_pNotification = SearchNotification(f_cnotificationname); - - // if new notification is registered - if (NULL == l_pNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Create new notification object :: %s", f_cnotificationname.c_str()); - - // create the new notification object depending on type and insert in map and vector - l_pNotification = CreateNotificationObject(f_cnotificationname, - f_uimsglength, - f_enotificationtype, - f_uidelay); - - if (NULL != l_pNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Set Notification publisher %s for notification %s", f_cservicename.c_str(), - f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" - - // set publisher name - l_estatus = l_pNotification->SetEventPublisher(f_cservicename); - } - } else { // if notification object already exists - EFrameworkunifiedNotificationType l_eNotificationType = l_pNotification->GetNotificationType(); - - // <<notification type is eFrameworkunifiedUnknown - // if some service had already subscribed to the notification before registering it.>> - if (eFrameworkunifiedUnknown == l_eNotificationType) { - // creates new notification object depending on the type and insert it in notification map - l_estatus = ChangeNotificationType(l_pNotification, f_cservicename, f_cnotificationname, f_uimsglength, - f_enotificationtype, f_uidelay); - - // delete the old notification object - delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch - l_pNotification = NULL; - } else { // notification is already registered by some service - // update the notification property, if re-registered by the same publisher - if (f_cservicename == l_pNotification->GetPublisherName() || // if re-register by service - "" == l_pNotification->GetPublisherName()) { // if previously unregistered by service - // if type is same just update the length of notification data - if (l_eNotificationType == f_enotificationtype) { - if (l_pNotification->GetMaxMessageSize() != f_uimsglength) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, - "Updating max size of notification %s to %d from %d", f_cnotificationname.c_str(), - f_uimsglength, l_pNotification->GetMaxMessageSize()); - l_estatus = l_pNotification->ResetMaxMessageSize(f_uimsglength); - } - - if ("" == l_pNotification->GetPublisherName()) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, - "Updating publisher name of notification %s to %s from %s", f_cservicename.c_str(), - f_cnotificationname.c_str(), l_pNotification->GetPublisherName().c_str()); - l_pNotification->SetEventPublisher(f_cservicename); - } - } else if (eFrameworkunifiedImmediatePersistedStateVar != l_eNotificationType && - eFrameworkunifiedImmediatePersistedStateVar != f_enotificationtype) { - // else create new notification object depending on the type and delete the old one - // note: do not change immediate notification type - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Changing type of notfn %s from %d to %d", f_cnotificationname.c_str(), - l_eNotificationType, f_enotificationtype); - - std::vector<std::string>::iterator l_itNotificationName; - - // remove the notification name from the persistent list of notification(if any) - if (eFrameworkunifiedPersistedStateVar == l_eNotificationType) { - l_itNotificationName = find(m_pvPersistentList->begin(), m_pvPersistentList->end(), f_cnotificationname); - - if (m_pvPersistentList->end() != l_itNotificationName) { - m_pvPersistentList->erase(l_itNotificationName); - } - } else if (eFrameworkunifiedPersistedStateUserVar == l_eNotificationType) { - l_itNotificationName = find(m_pvUserPersistentList->begin(), - m_pvUserPersistentList->end(), - f_cnotificationname); - - if (m_pvUserPersistentList->end() != l_itNotificationName) { - m_pvUserPersistentList->erase(l_itNotificationName); - } - } else { - // do nothing - } - - // creates new notification object depending on the new type and insert it in map and delete the old one - l_estatus = ChangeNotificationType(l_pNotification, f_cservicename, f_cnotificationname, f_uimsglength, - f_enotificationtype, f_uidelay); - - // delete the old notification object - delete l_pNotification; - l_pNotification = NULL; - } else { - // do nothing - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notfn: %s already registered by %s, skipping register request by %s", - f_cnotificationname.c_str(), l_pNotification->GetPublisherName().c_str(), f_cservicename.c_str()); - - l_estatus = eFrameworkunifiedStatusFail; - } - } - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// ChangeNotificationType -/// This function creates new notification object depending on the type and replaces the old one. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::ChangeNotificationType(CNotification *f_pnotification, - const std::string &f_cservicename, - const std::string &f_cnotificationname, - const UI_32 f_uimsglength, - const EFrameworkunifiedNotificationType f_enotificationtype, - const UI_32 f_uidelay) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNewNotification = NULL; - - if (NULL != f_pnotification) { // LCOV_EXCL_BR_LINE 6: f_pnotification can't be NULL - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Create New Notification :: %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // create new notification object as per notification type - l_pNewNotification = CreateNotificationObject(f_cnotificationname, f_uimsglength, f_enotificationtype, f_uidelay); - - if (NULL != l_pNewNotification) { - l_estatus = l_pNewNotification->SetEventPublisher(f_cservicename); - - // assign subscribers list to newly created notification - l_pNewNotification->SetNewSubscribersList(f_pnotification); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, - "Error creating notification object for notification:%s", - f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" - l_estatus = eFrameworkunifiedStatusNullPointer; - } - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_pnotification can't be NULL - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnUnRegisterEvents -/// This function removes the name of the service from the notification object. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnUnRegisterEvents(const std::string &f_cservicename, - const std::string &f_cnotificationname) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - std::vector<std::string> *l_pvPersistentList = NULL; - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotification; - - if (f_cservicename.empty() || f_cnotificationname.empty()) { - l_estatus = eFrameworkunifiedStatusInvldParam; - } else { - // check if this notification's object present in map - l_itNotification = m_pmNotificationList->find(f_cnotificationname); - - // if notification found in map - if (m_pmNotificationList->end() != l_itNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification found in map"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // get the notification object pointer from map - l_pNotification = (*l_itNotification).second; - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: f_pnotification can't be NULL - if (eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType()) { - l_pvPersistentList = m_pvUserPersistentList; - } else if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType()) { - l_pvPersistentList = m_pvPersistentList; - } - - // reset the publisher name - l_estatus = l_pNotification->ResetEventPublisher(f_cservicename); - - if (eFrameworkunifiedStatusOK == l_estatus) { - // if no other service is subscribed to this notification and no service is registered - // to this notification remove the notification object from map - if (!l_pNotification->IsServiceRegistered() && - l_pNotification->IsSubscribersListEmpty()) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Deleting Notification Object"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // delete the notification - delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch - l_pNotification = NULL; - - m_pmNotificationList->erase(l_itNotification); - - if (l_pvPersistentList) { - // find the notification in vector - std::vector<std::string>::iterator l_itNotificationName; - - l_itNotificationName = find(l_pvPersistentList->begin(), - l_pvPersistentList->end(), - f_cnotificationname); - - if (l_pvPersistentList->end() != l_itNotificationName) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification name from vector"); - l_pvPersistentList->erase(l_itNotificationName); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Persistent list empty"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Services still registered or subscriber list empty"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s is not registered by service %s", - f_cnotificationname.c_str(), f_cservicename.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - // LCOV_EXCL_START 6: f_pnotification can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not registered", f_cnotificationname.c_str()); - - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - l_estatus = eFrameworkunifiedStatusFail; - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnPublishEvent -/// This function stores the published data in the notification object in case of state and -/// persistent notification. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnPublishEvent(const std::string &f_cservicename, - const std::string &f_cnotificationname, - PVOID f_pmessage, - const UI_32 f_uimsgsize) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - - if (f_cservicename.empty() || f_cnotificationname.empty()) { // LCOV_EXCL_BR_LINE 6: f_cservicename and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_cservicename and f_cnotificationname can't be empty - } else { - // get the notification object from map - l_pNotification = SearchNotification(f_cnotificationname); - - if (NULL != l_pNotification) { - // publish the notification - if (eFrameworkunifiedStatusOK != (l_estatus = l_pNotification->Publish(f_cservicename, - f_pmessage, - f_uimsgsize))) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error publishing notification %s published by %s, status: %d", - f_cnotificationname.c_str(), f_cservicename.c_str(), l_estatus); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification not registered"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - l_estatus = eFrameworkunifiedStatusNullPointer; - } - } - - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnSubscribeToEvent -/// This function adds the name of the application to subscribers list in notification object. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnSubscribeToEvent(const std::string &f_csubscribername, - const std::string &f_cnotificationname) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotification; - - CNotification *l_pNotification = NULL; - - if (f_cnotificationname.empty() || f_csubscribername.empty()) { - l_estatus = eFrameworkunifiedStatusInvldParam; - } else if (NULL == m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6 m_pmNotificationList can't be NULL - // LCOV_EXCL_START 6: m_pmNotificationList can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "map pointer is NULL"); - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } else { - // get the notification object from map or create new object - l_pNotification = SearchNotification(f_cnotificationname); - - if (NULL == l_pNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "CNotification object created for %s", f_cnotificationname.c_str()); - - l_pNotification = new(std::nothrow) CNotification(f_cnotificationname, 0); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - - m_pmNotificationList->insert(make_pair(f_cnotificationname, l_pNotification)); - } - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: double check, l_pNotification can't be NULL - // add subscribers name in subscribers list of notification - l_estatus = l_pNotification->AddEventReciever(f_csubscribername); - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory not allocated for l_pNotification"); // LCOV_EXCL_LINE 6: double check, l_pNotification can't be NULL // NOLINT[whitespace/line_length] - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnUnSubscribeFromEvent -/// This function removes the name of the application from the subscribers list in notification object. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnUnSubscribeFromEvent(const std::string &f_csubscribername, - const std::string &f_cnotificationname) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotificationType; - - std::vector<std::string> *l_pvPersistentList = NULL; - - if (f_cnotificationname.empty() || f_csubscribername.empty()) { - l_estatus = eFrameworkunifiedStatusInvldParam; - } else if (NULL == m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6: m_pmNotificationList can't be NULL - // LCOV_EXCL_START 6: m_pmNotificationList can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification list pointer is NULL"); - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } else { - // check if this notification's object present in map - l_itNotificationType = m_pmNotificationList->find(f_cnotificationname); - - // if notification found in map - if (m_pmNotificationList->end() != l_itNotificationType) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Notification %s found in map", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - l_pNotification = (*l_itNotificationType).second; - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL - if (eFrameworkunifiedPersistedStateUserVar == l_pNotification->GetNotificationType()) { - l_pvPersistentList = m_pvUserPersistentList; - } else if (eFrameworkunifiedPersistedStateVar == l_pNotification->GetNotificationType()) { - l_pvPersistentList = m_pvPersistentList; - } - - // removes the subscribers name from subscribers list of notification - l_estatus = l_pNotification->DeleteEventReciever(f_csubscribername); - - // if no other service is subscribed to this notification and no service is registered - // to this notification remove the notification object from map - if (!l_pNotification->IsServiceRegistered() && - l_pNotification->IsSubscribersListEmpty()) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification Object from map"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // delete notification object from map - delete l_pNotification; // LCOV_EXCL_BR_LINE 11: unexpected branch - l_pNotification = NULL; - - m_pmNotificationList->erase(l_itNotificationType); - - if (l_pvPersistentList) { - // find notification in vector - std::vector<std::string>::iterator l_itNotificationName; - l_itNotificationName = find(l_pvPersistentList->begin(), - l_pvPersistentList->end(), - f_cnotificationname); - - if (l_pvPersistentList->end() != l_itNotificationName) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification from vector"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_pvPersistentList->erase(l_itNotificationName); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Persistent list Empty."); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } - } else { - // LCOV_EXCL_START 6: l_pNotification can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Notification %s not registered", f_cnotificationname.c_str()); - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } - - } else { - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_estatus = eFrameworkunifiedStatusFail; - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NPGetPersistentNotificationData -/// -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NPGetPersistentNotificationData(const std::string &f_cnotificationname, - PVOID f_pnotificationdata, - const UI_32 f_uidatasize) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - CStateNotification *l_pStateNotification = NULL; - const CPersistentData *l_pPersistentData = NULL; - - if (f_cnotificationname.empty() || NULL == f_pnotificationdata) { // LCOV_EXCL_BR_LINE 6: f_pnotificationdata can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusInvldParam; // LCOV_EXCL_LINE 6: f_pnotificationdata can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - } else { - l_pNotification = SearchNotification(f_cnotificationname); - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 200: f_cnotificationname must be NTFY_NPPService_UserChange, NTFY_NPPService_UserChange must be registered in FrameworkunifiedOnEntry() by itself. // NOLINT[whitespace/line_length] - const EFrameworkunifiedNotificationType l_eNotificationType = l_pNotification->GetNotificationType(); - - if (eFrameworkunifiedStateVar == l_eNotificationType || - eFrameworkunifiedPersistedStateVar == l_eNotificationType || - eFrameworkunifiedPersistedStateUserVar == l_eNotificationType || - eFrameworkunifiedImmediatePersistedStateVar == l_eNotificationType) { // LCOV_EXCL_BR_LINE 200: NTFY_NPPService_UserChange's type is eFrameworkunifiedPersistedStateVar. // NOLINT[whitespace/line_length] - l_pStateNotification = static_cast<CStateNotification *>(l_pNotification); - - l_pPersistentData = l_pStateNotification->GetPersistentData(); - - if (NULL != l_pPersistentData) { - if (f_uidatasize >= l_pPersistentData->m_uiMsgSize) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data Size %d", l_pPersistentData->m_uiMsgSize); - - if (NULL != l_pPersistentData->m_pMessage) { - std::memcpy(f_pnotificationdata, l_pPersistentData->m_pMessage, l_pPersistentData->m_uiMsgSize); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification data is NULL"); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, - "Smaller buffer size %d is received for notification data of size %d", f_uidatasize, - l_pPersistentData->m_uiMsgSize); - } - } else { - l_estatus = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, - "Persistent data object is NULL for notification %s", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - // LCOV_EXCL_START 200: NTFY_NPPService_UserChange's type is eFrameworkunifiedPersistedStateVar. - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Get notification data failed, Notification %s is registered as type %d", - f_cnotificationname.c_str(), l_eNotificationType); - // LCOV_EXCL_STOP - } - } else { - // LCOV_EXCL_START 200: f_cnotificationname must be NTFY_NPPService_UserChange, NTFY_NPPService_UserChange must be registered in FrameworkunifiedOnEntry() by itself. // NOLINT[whitespace/line_length] - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found.", f_cnotificationname.c_str()); - // LCOV_EXCL_STOP - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceServiceOnGetPersistentData -/// This function is used to get the persistent data stored related to notification. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceServiceOnGetPersistentData(const std::string &f_cnotificationname, - const std::string &f_creceivername) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - CStateNotification *l_pStateNotification = NULL; - const CPersistentData *l_pPersistentData = NULL; - - if (f_cnotificationname.empty() || f_creceivername.empty()) { // LCOV_EXCL_BR_LINE 6: f_creceivername can't be NULL and f_cnotificationname can't be empty // NOLINT[whitespace/line_length] - // LCOV_EXCL_START 6: f_creceivername can't be NULL and f_cnotificationname can't be empty - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusInvldParam; - // LCOV_EXCL_STOP - } else { - // open the receiver message queue - HANDLE l_hReceiverMq = McOpenSender(f_creceivername.c_str()); - - if (NULL == l_hReceiverMq) { // LCOV_EXCL_BR_LINE 4: NSFW error case - // LCOV_EXCL_START 4: NSFW error case. - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - // catastrophic failure! - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Failed to open MessageQ %s ", f_creceivername.c_str()); - l_estatus = eFrameworkunifiedStatusFail; - // LCOV_EXCL_STOP - } else { - // get the notification object from map or create new object - l_pNotification = SearchNotification(f_cnotificationname); - - if (NULL != l_pNotification) { - l_pStateNotification = static_cast<CStateNotification *>(l_pNotification); - - if (NULL != l_pStateNotification) { // LCOV_EXCL_BR_LINE 5: fail safe for static_cast<CStateNotification *> - l_pPersistentData = l_pStateNotification->GetPersistentData(); - - if (NULL != l_pPersistentData) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data Size %d", l_pPersistentData->m_uiMsgSize); - - if (NULL == l_pPersistentData->m_pMessage) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Sending Data is NULL"); - } - - // sent the notification data to requester - l_estatus = McSend(l_hReceiverMq, - AppName, - NPS_GET_PERS_DATA_ACK, - l_pPersistentData->m_uiMsgSize, - l_pPersistentData->m_pMessage); - FRAMEWORKUNIFIEDLOG(ZONE_PRD_INFO2, __FUNCTION__, "Persistent data found for notification %s. " - "Sent NPS_GET_PERS_DATA_ACK to %s. Status: %d." - , f_cnotificationname.c_str(), f_creceivername.c_str(), l_estatus); - } else { // In case of failure, we send back a failure ACK - l_estatus = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No persistent data found for notification %s. " - , f_cnotificationname.c_str()); - } - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not found", f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - l_estatus = eFrameworkunifiedStatusInvldParam; - } - // Close the mq handle - McClose(l_hReceiverMq); - l_hReceiverMq = NULL; - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceGetPersistentNotificationData -/// This function is used to get the list of persistent notifications and data associated with it. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceGetPersistentNotificationData(std::vector<CNotificationsToPersist *> - *f_pvpersistnotification, - const EFrameworkunifiedNotificationType f_enotificationtype, - UI_32 f_uinotificationpersistentservicepersistcategoryflag) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - CStateNotification *l_pStateNotification = NULL; - CStatePersistenceNotification *l_pStatePersistenceNotification = NULL; - - std::string l_cNotificationName = ""; - CNotificationsToPersist *l_pNotificationsToPersist = NULL; - const CPersistentData *l_pPData = NULL; - - std::vector<std::string> *l_pvPersistentList = NULL; - - // iterator for retrieving notifications from map of notifications - Notification_Iterator_Type l_itNotification; - - if (eFrameworkunifiedPersistedStateUserVar == f_enotificationtype) { - l_pvPersistentList = m_pvUserPersistentList; - } else if (eFrameworkunifiedPersistedStateVar == f_enotificationtype) { // LCOV_EXCL_BR_LINE 6: f_enotificationtype must be eFrameworkunifiedPersistedStateUserVar or eFrameworkunifiedPersistedStateVar // NOLINT[whitespace/line_length] - l_pvPersistentList = m_pvPersistentList; - } - - // copy all the notification data in map to received vector - if (NULL != f_pvpersistnotification && NULL != l_pvPersistentList) { // LCOV_EXCL_BR_LINE 6: f_pvpersistnotification and l_pvPersistentList can't be null // NOLINT[whitespace/line_length] - for (UI_32 l_uiCount = 0; - l_uiCount < l_pvPersistentList->size(); - l_uiCount++) { - // get the persistent notification name from vector - l_cNotificationName = l_pvPersistentList->at(l_uiCount); - - // search for notification in map - l_itNotification = m_pmNotificationList->find(l_cNotificationName); - - // notification found in map - if (m_pmNotificationList->end() != l_itNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Persistent Notification: %s", l_cNotificationName.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - - // get notification object from map - l_pNotification = (*l_itNotification).second; - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL - if (eFrameworkunifiedPersistedStateVar == f_enotificationtype) { - l_pStatePersistenceNotification = static_cast<CStatePersistenceNotification *>(l_pNotification); - - // get the notification's default data - if ((eFrameworkunifiedUserData == l_pStatePersistenceNotification->GetPersistentCategory() && - (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedUserData)) || - (eFrameworkunifiedFactoryData == l_pStatePersistenceNotification->GetPersistentCategory() && - (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedFactoryData)) || - (eFrameworkunifiedFactoryCustomerData == l_pStatePersistenceNotification->GetPersistentCategory() && - (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedFactoryCustomerData)) || - (eFrameworkunifiedDealerData == l_pStatePersistenceNotification->GetPersistentCategory() && - (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedDealerData))) { - l_pPData = l_pStatePersistenceNotification->GetDefaultPersistentData(); - } else { - l_pStateNotification = l_pStatePersistenceNotification; - - // get the published notification data - if (l_pStateNotification->IsPublished()) { - l_pPData = l_pStateNotification->GetPersistentData(); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification not published"); - } - } - } else { - l_pStateNotification = static_cast<CStateNotification *>(l_pNotification); - - // if not to reset userdata - if (0 == (f_uinotificationpersistentservicepersistcategoryflag & eFrameworkunifiedUserData)) { - if (l_pStateNotification->IsPublished()) { - l_pPData = l_pStateNotification->GetPersistentData(); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification not published"); - } - } - } - - if ((NULL != l_pStateNotification) && (NULL != l_pPData)) { - l_pNotificationsToPersist = CreateNotificationObjectToPersist(l_pStateNotification, l_pPData); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - - // insert the persistent data in map - f_pvpersistnotification->push_back(l_pNotificationsToPersist); // LCOV_EXCL_BR_LINE 11: unexpected branch - - l_pPData = NULL; - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "no data is stored in notification %s", l_cNotificationName.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object is NULL for %s", l_cNotificationName.c_str()); // LCOV_EXCL_LINE 6: l_pNotification can't be NULL // NOLINT[whitespace/line_length] - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Non Persistent Notification: %s", l_cNotificationName.c_str()); - } - } - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - l_estatus = eFrameworkunifiedStatusNullPointer; // LCOV_EXCL_LINE 6: f_pvpersistnotification and l_pvPersistentList can't be null // NOLINT[whitespace/line_length] - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// CreateNotificationObjectToPersist -/// Creates the CNotificationsToPersist object from notification object and the persistent data. -//////////////////////////////////////////////////////////////////////////////////////////////////// -CNotificationsToPersist *CNotificationManager::CreateNotificationObjectToPersist(CStateNotification - *f_pStateNotification, - const CPersistentData *f_pdata) { - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotificationsToPersist *l_pNotificationsToPersist = NULL; - CPersistentData *l_pData = NULL; - - if (NULL != f_pStateNotification && NULL != f_pdata) { // LCOV_EXCL_BR_LINE 6: f_pStateNotification and f_pdata can't be NULL // NOLINT[whitespace/line_length] - if (f_pStateNotification->GetMaxMessageSize() >= f_pdata->m_uiMsgSize) { - l_pNotificationsToPersist = new(std::nothrow) CNotificationsToPersist(); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - - if (NULL != l_pNotificationsToPersist) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function - l_pNotificationsToPersist->m_pPersistentData = new(std::nothrow) CPersistentData(); // LCOV_EXCL_BR_LINE 11: unexpected branch // NOLINT[whitespace/line_length] - l_pData = l_pNotificationsToPersist->m_pPersistentData; - - if (NULL != l_pData) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function - l_pNotificationsToPersist->m_cNotificationName = f_pStateNotification->GetNotificationName(); - l_pNotificationsToPersist->m_uiMaxMsgLength = f_pStateNotification->GetMaxMessageSize(); - l_pNotificationsToPersist->m_ePersistentType = f_pStateNotification->GetNotificationType(); - - if (eFrameworkunifiedPersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { - l_pNotificationsToPersist->m_ePersistCategory = (static_cast<CStatePersistenceNotification *> - (f_pStateNotification))->GetPersistentCategory(); - } - - l_pNotificationsToPersist->m_cPublisherName = f_pStateNotification->GetPublisherName(); - - l_pData->m_uiMsgSize = f_pdata->m_uiMsgSize; - l_pData->m_pMessage = new(std::nothrow) CHAR[l_pNotificationsToPersist->m_uiMaxMsgLength]; - - if (NULL != l_pData->m_pMessage) { // LCOV_EXCL_BR_LINE 5: It's impossible to mock new() function - std::memset(l_pData->m_pMessage, 0, l_pNotificationsToPersist->m_uiMaxMsgLength); - std::memcpy(l_pData->m_pMessage, f_pdata->m_pMessage, f_pdata->m_uiMsgSize); - } - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "memory not allocated for l_pNotificationsToPersist"); // LCOV_EXCL_LINE 5: It's impossible to mock new() function // NOLINT[whitespace/line_length] - } - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, - "Error persisting notfn, Data size of notification %s is %d greater than max registered size %d", - f_pStateNotification->GetNotificationName().c_str(), - f_pdata->m_uiMsgSize, f_pStateNotification->GetMaxMessageSize()); - } - } else { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid parameter received"); // LCOV_EXCL_LINE 6: f_pStateNotification and f_pdata can't be NULL // NOLINT[whitespace/line_length] - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_pNotificationsToPersist; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceSetPersistentNotificationData -/// This function is used to create the persistent notifications object and fill the data related -/// with it on system load. -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetPersistentNotificationData(std::vector<CNotificationsToPersist *> - *f_pvpersistnotification) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CStateNotification *l_pNotification = NULL; - CNotificationsToPersist *l_pNotificationsToPersist = NULL; - - std::vector<std::string> *l_pvPersistentList = NULL; - - Persistent_Iterator_Type l_itPersistentData; - - // store all the notification data received in vector to map of CNotification and to vector of - // persistent notification in case of persistent and user persistent notification - if (NULL != f_pvpersistnotification) { // LCOV_EXCL_BR_LINE 6: double check, f_pvpersistnotification can't be NULL - for (UI_32 l_uiCount = 0; - l_uiCount < f_pvpersistnotification->size(); - l_uiCount++) { - // get the persistent data object - l_pNotificationsToPersist = f_pvpersistnotification->at(l_uiCount); - - if (NULL != l_pNotificationsToPersist) { // LCOV_EXCL_BR_LINE 6: double check, l_pNotificationsToPersist can't be NULL // NOLINT[whitespace/line_length] - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Persistent Type %d", l_pNotificationsToPersist->m_ePersistentType); - - if (eFrameworkunifiedPersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentState Notification"); - - l_pNotification = new(std::nothrow) CStatePersistenceNotification( - l_pNotificationsToPersist->m_cNotificationName, - l_pNotificationsToPersist->m_uiMaxMsgLength, - l_pNotificationsToPersist->m_ePersistCategory); - - l_pvPersistentList = m_pvPersistentList; - } else if (eFrameworkunifiedPersistedStateUserVar == l_pNotificationsToPersist->m_ePersistentType) { - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentStateUser Notification"); - - l_pNotification = new(std::nothrow) CStatePersistenceUserNotification( - l_pNotificationsToPersist->m_cNotificationName, - l_pNotificationsToPersist->m_uiMaxMsgLength); - - l_pvPersistentList = m_pvUserPersistentList; - } else if (eFrameworkunifiedImmediatePersistedStateVar == l_pNotificationsToPersist->m_ePersistentType) { // LCOV_EXCL_BR_LINE 6: l_pNotificationsToPersist->m_ePersistentType must be eFrameworkunifiedPersistedStateVar, eFrameworkunifiedPersistedStateUserVar, eFrameworkunifiedImmediatePersistedStateVar // NOLINT[whitespace/line_length] - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "PersistentStateUser Notification"); - - l_pNotification = new(std::nothrow) CStateNorPersistenceNotification( - l_pNotificationsToPersist->m_cNotificationName, - l_pNotificationsToPersist->m_uiMaxMsgLength, - l_pNotificationsToPersist->m_uiDelay, - l_pNotificationsToPersist->m_ePersistCategory); - } - - if (NULL != l_pNotification) { // LCOV_EXCL_BR_LINE 6: l_pNotification can't be NULL - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Insert persistent notification object in map"); - - l_pNotification->SetPersistentData(l_pNotificationsToPersist->m_pPersistentData->m_pMessage, - l_pNotificationsToPersist->m_pPersistentData->m_uiMsgSize); - - l_pNotification->SetEventPublisher(l_pNotificationsToPersist->m_cPublisherName); - - if (NULL != m_pmNotificationList) { // LCOV_EXCL_BR_LINE 6: double check, m_pmNotificationList can't be NULL - m_pmNotificationList->insert(make_pair(l_pNotificationsToPersist->m_cNotificationName, l_pNotification)); - - if (NULL != l_pvPersistentList) { - l_pvPersistentList->push_back(l_pNotificationsToPersist->m_cNotificationName); - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Inserted persistent notification object in map"); - } - FRAMEWORKUNIFIEDLOG(ZONE_NPP_INFO, __FUNCTION__, "Inserted persistent notification object in vector"); - } else { - // LCOV_EXCL_START 6: double check, m_pmNotificationList can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - delete l_pNotification; - l_pNotification = NULL; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object not inserted in map/vector"); - // LCOV_EXCL_STOP - } - } else { - // LCOV_EXCL_START 6: l_pNotification can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "notification object is NULL"); - - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } - } else { - // LCOV_EXCL_START 6: double check, l_pNotificationsToPersist can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pNotificationsToPersist is NULL"); - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } - } - } else { - // LCOV_EXCL_START 6: double check, f_pvpersistnotification can't be NULL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Persistent data pointer is NULL"); - - l_estatus = eFrameworkunifiedStatusNullPointer; - // LCOV_EXCL_STOP - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// RemoveUserSpecificNotificationEntry -/// This function is used to remove the user persistent notifications entry -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::RemoveUserSpecificNotificationEntry() { // LCOV_EXCL_START 100: never be used - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - std::string l_cNotificationName; - - std::vector<std::string>::iterator l_itNotificationName; - - // iterator to find notification from map of notifications - Notification_Iterator_Type l_itNotification; - - CNotification *l_pNotification = NULL; - - for (l_itNotificationName = m_pvUserPersistentList->begin() ; l_itNotificationName < m_pvUserPersistentList->end() ; - l_itNotificationName++) { - l_cNotificationName = *(l_itNotificationName); - - // check if this notification's object present in map - l_itNotification = m_pmNotificationList->find(l_cNotificationName); - - if (m_pmNotificationList->end() != l_itNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification found in map"); - - // get the notification object pointer from map - l_pNotification = (*l_itNotification).second; - - if (NULL != l_pNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification Object"); - - // delete the notification - delete l_pNotification; - l_pNotification = NULL; - - m_pmNotificationList->erase(l_itNotification); - - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Deleting Notification name from vector"); - m_pvUserPersistentList->erase(l_itNotificationName); - - l_itNotificationName = m_pvUserPersistentList->begin(); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification not found."); - - l_estatus = eFrameworkunifiedStatusFail; - } - } - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} -// LCOV_EXCL_STOP - -EFrameworkunifiedStatus CNotificationManager::GetNotificationInfo(const std::string &f_cnotificationname, // LCOV_EXCL_START 100: never be used // NOLINT[whitespace/line_length] - CNotificationsToPersist *&f_pnotificationstopersist) { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - CNotification *l_pNotification = NULL; - CStateNotification *l_pStateNotification = NULL; - const CPersistentData *l_pPData = NULL; - - l_pNotification = SearchNotification(f_cnotificationname); - l_pStateNotification = static_cast<CStateNotification *>(l_pNotification); - - if (NULL != l_pStateNotification) { - if (l_pStateNotification->IsPublished()) { - l_pPData = l_pStateNotification->GetPersistentData(); - - if (NULL != l_pPData) { - f_pnotificationstopersist = new(std::nothrow) CNotificationsToPersist(); - - if (NULL == f_pnotificationstopersist) { - l_estatus = eFrameworkunifiedStatusNullPointer; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error for f_pnotificationstopersist"); - } - - if (eFrameworkunifiedStatusOK == l_estatus) { - f_pnotificationstopersist->m_pPersistentData = new(std::nothrow) CPersistentData(); - - if (NULL == f_pnotificationstopersist->m_pPersistentData) { - l_estatus = eFrameworkunifiedStatusNullPointer; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation error for f_pnotificationstopersist->m_pPersistentData"); - } - } - - if (eFrameworkunifiedStatusOK == l_estatus) { - f_pnotificationstopersist->m_cNotificationName = l_pStateNotification->GetNotificationName(); - f_pnotificationstopersist->m_uiMaxMsgLength = l_pStateNotification->GetMaxMessageSize(); - f_pnotificationstopersist->m_cPublisherName = l_pStateNotification->GetPublisherName(); - f_pnotificationstopersist->m_ePersistentType = l_pStateNotification->GetNotificationType(); - - if (eFrameworkunifiedPersistedStateVar == f_pnotificationstopersist->m_ePersistentType) { - f_pnotificationstopersist->m_ePersistCategory = (static_cast<CStatePersistenceNotification *> - (l_pStateNotification))->GetPersistentCategory(); - } - - if (eFrameworkunifiedImmediatePersistedStateVar == f_pnotificationstopersist->m_ePersistentType) { - CStateNorPersistenceNotification *l_pStateNorPersistenceNotification = - static_cast<CStateNorPersistenceNotification *>(l_pStateNotification); - f_pnotificationstopersist->m_uiDelay = l_pStateNorPersistenceNotification->GetPersistenceDelay(); - f_pnotificationstopersist->m_ePersistCategory = (static_cast<CStateNorPersistenceNotification *> - (l_pStateNotification))->GetPersistentCategory(); - } - - f_pnotificationstopersist->m_pPersistentData->m_pMessage = new(std::nothrow) - CHAR[f_pnotificationstopersist->m_uiMaxMsgLength]; - std::memset(f_pnotificationstopersist->m_pPersistentData->m_pMessage, 0, - f_pnotificationstopersist->m_uiMaxMsgLength); - std::memcpy(f_pnotificationstopersist->m_pPersistentData->m_pMessage, - l_pPData->m_pMessage, l_pPData->m_uiMsgSize); - - f_pnotificationstopersist->m_pPersistentData->m_uiMsgSize = l_pPData->m_uiMsgSize; - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "No data is stored in notification %s", f_cnotificationname.c_str()); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Notification %s not published", f_cnotificationname.c_str()); - } - } else { - l_estatus = eFrameworkunifiedStatusNullPointer; - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} -// LCOV_EXCL_STOP - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceSetDefaultPersistentNotificationData -/// This function is used to set the default data of persistent notification -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetDefaultPersistentNotificationData(const std::string &f_cnotificationname, - PVOID f_pmessage, - const UI_32 f_uimsgsize) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // pointer of notification object - CStateNotification *l_pStateNotification = SearchPersistenceNotification(f_cnotificationname); - - if (NULL != l_pStateNotification) { - l_estatus = l_pStateNotification->SetDefaultPersistentData(f_pmessage, f_uimsgsize); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unable to set default notification data for %s, notification does not exists", - f_cnotificationname.c_str()); - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentserviceSetPersistentCategory -/// This function is used to set the persistent type of persistent notification -//////////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentserviceSetPersistentCategory(const std::string &f_cnotificationname, - const EFrameworkunifiedPersistCategory f_epersistcategory) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - // pointer of notification object - CStateNotification *l_pStateNotification = SearchPersistenceNotification(f_cnotificationname); - - if (NULL != l_pStateNotification) { - EFrameworkunifiedNotificationType l_eNotificationType = l_pStateNotification->GetNotificationType(); - - if (eFrameworkunifiedPersistedStateVar == l_eNotificationType) { - l_estatus = (static_cast<CStatePersistenceNotification *>(l_pStateNotification))->SetPersistentCategory( - f_epersistcategory); - } else if (eFrameworkunifiedImmediatePersistedStateVar == l_eNotificationType) { - l_estatus = (static_cast<CStateNorPersistenceNotification *>(l_pStateNotification))->SetPersistentCategory( - f_epersistcategory); - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Cannot set category %d for notification %s of type %d", f_epersistcategory, - f_cnotificationname.c_str(), l_eNotificationType); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, - "Cannot set category %d for %s, Either not registered or not a persistent notification", - f_epersistcategory, f_cnotificationname.c_str()); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT[whitespace/line_length] - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -//////////////////////////////////////////////////////////////////////////////////////////////// -/// NotificationpersistentservicePublishImmediateNotification -/// This function publish the immediate notification f_cnotificationname to all its subscribers. -/// This API is called when service updates the immediate notification data in persistent memory -/// using synchronous API. -//////////////////////////////////////////////////////////////////////////////////////////////// -EFrameworkunifiedStatus CNotificationManager::NotificationpersistentservicePublishImmediateNotification(const std::string &f_cservicename, - const std::string &f_cnotificationname, - PVOID f_pmessage, - const UI_32 f_uimsgsize) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - if (f_cservicename.empty() || f_cnotificationname.empty()) { - l_estatus = eFrameworkunifiedStatusInvldParam; - } else { - // get the notification object from map - CStateNotification *l_pStateNotf = SearchPersistenceNotification(f_cnotificationname); - - if (NULL != l_pStateNotf) { - if (eFrameworkunifiedImmediatePersistedStateVar == l_pStateNotf->GetNotificationType()) { - CStateNorPersistenceNotification *l_pImmediateNotf = - static_cast<CStateNorPersistenceNotification *>(l_pStateNotf); - - // publish the notification - if (eFrameworkunifiedStatusOK != (l_estatus = l_pImmediateNotf->PublishNotification(f_cservicename, - f_pmessage, - f_uimsgsize))) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error publishing notification %s published by %s, status: %d", - f_cnotificationname.c_str(), f_cservicename.c_str(), l_estatus); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s is not registered as immediate persistence by service %s", - f_cnotificationname.c_str(), f_cservicename.c_str()); - } - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification %s not registered by service %s", f_cnotificationname.c_str(), - f_cservicename.c_str()); - - l_estatus = eFrameworkunifiedStatusNullPointer; - } - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -#ifdef NPP_PROFILEINFO_ENABLE - -EFrameworkunifiedStatus CNotificationManager::GetNotificationProfilingData(std::string &f_cnotificationprofileInfo) { - EFrameworkunifiedStatus l_estatus = eFrameworkunifiedStatusOK; - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); - - Notification_Iterator_Type l_itNotification; - NotifReceiver_Iterator_Type l_itNotifReceiver_Iterator; - - CNotification *l_pNotification = NULL; - NotifReceiver_Type *l_pSubscriberList = NULL; - - std::stringstream ss; - UI_32 l_uiSubscriberCnt = 0; - - std::string l_cPublisher = ""; - std::string l_cNotification = ""; - - try { - if (NULL == m_pmNotificationList) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification List m_pmNotificationList is NULL in notification manager"); - l_estatus = eFrameworkunifiedStatusFail; - } - - if (eFrameworkunifiedStatusOK == l_estatus && m_pmNotificationList->empty()) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification List m_pmNotificationList Empty in notification manager"); - l_estatus = eFrameworkunifiedStatusFail; - } - - if (eFrameworkunifiedStatusOK == l_estatus) { - f_cnotificationprofileInfo.append("Application Name,"); - f_cnotificationprofileInfo.append("Notification Name,"); - f_cnotificationprofileInfo.append("Type,"); - f_cnotificationprofileInfo.append("Length,"); - f_cnotificationprofileInfo.append("Subscribed By,"); - f_cnotificationprofileInfo.append("Subscribers Count"); - - for (l_itNotification = m_pmNotificationList->begin(); - l_itNotification != m_pmNotificationList->end(); - l_itNotification++) { - l_pNotification = (*l_itNotification).second; - if (NULL == l_pNotification) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification object ptr is NULL"); - l_estatus = eFrameworkunifiedStatusFail; - } else { - l_cPublisher = l_pNotification->GetPublisherName(); - if (l_cPublisher.empty()) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Publisher name empty"); - l_estatus = eFrameworkunifiedStatusFail; - } - - l_cNotification = l_pNotification->GetNotificationName(); - if (l_cNotification.empty()) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Notification name empty"); - l_estatus = eFrameworkunifiedStatusFail; - } - - l_pSubscriberList = l_pNotification->GetSubscriberList(); - if (NULL == l_pSubscriberList) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Subscribers List ptr is NULL"); - l_estatus = eFrameworkunifiedStatusFail; - } - } - - if (eFrameworkunifiedStatusOK == l_estatus) { - f_cnotificationprofileInfo.append("\n"); - - f_cnotificationprofileInfo.append(l_cPublisher); - f_cnotificationprofileInfo.append(","); - - f_cnotificationprofileInfo.append(l_cNotification); - f_cnotificationprofileInfo.append(","); - - switch (l_pNotification->GetNotificationType()) { - case eFrameworkunifiedNotificationVar : { - f_cnotificationprofileInfo.append("Regular"); - } - break; - - case eFrameworkunifiedStateVar : { - f_cnotificationprofileInfo.append("State"); - } - break; - - case eFrameworkunifiedPersistedStateVar : { - f_cnotificationprofileInfo.append("PersistenceState"); - } - break; - - case eFrameworkunifiedPersistedStateUserVar : { - f_cnotificationprofileInfo.append("UserPersistenceState"); - } - break; - - case eFrameworkunifiedImmediatePersistedStateVar : { - f_cnotificationprofileInfo.append("ImmediatePersistenceState"); - } - break; - - case eFrameworkunifiedUnknown: { - f_cnotificationprofileInfo.append("Unknown"); - } - break; - - default: - break; - } - f_cnotificationprofileInfo.append(","); - - ss << l_pNotification->GetMaxMessageSize(); - f_cnotificationprofileInfo.append(ss.str()); - ss.str(""); - f_cnotificationprofileInfo.append(",\""); - - l_uiSubscriberCnt = 0; - for (l_itNotifReceiver_Iterator = l_pSubscriberList->begin(); - l_pSubscriberList->end() != l_itNotifReceiver_Iterator;) { - f_cnotificationprofileInfo.append(l_itNotifReceiver_Iterator->first); - ++l_uiSubscriberCnt; - - ++l_itNotifReceiver_Iterator; - - if (l_pSubscriberList->end() != l_itNotifReceiver_Iterator) { - f_cnotificationprofileInfo.append(","); - } - } - - f_cnotificationprofileInfo.append("\","); - - ss << l_uiSubscriberCnt; - f_cnotificationprofileInfo.append(ss.str()); - ss.str(""); - } - - l_estatus = eFrameworkunifiedStatusOK; - } - } - } catch (std::exception &exp) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Exception:: %s", exp.what()); - l_estatus = eFrameworkunifiedStatusFail; - } - - FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); - return l_estatus; -} - -#endif |