--- /dev/null
+/*
+ * @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
Code Review / staging / basesystem.git / blobdiff