path: root/systemservice/system_manager/server/src/ss_system_manager_callbacks.cpp

/*
 * @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.
 */

///////////////////////////////////////////////////////////////////////////////
/// \ingroup  tag_SystemManager
/// \brief    This file provides support for System Manager business logic.
///
///////////////////////////////////////////////////////////////////////////////
#include <system_service/ss_heartbeat_service_protocol.h>
#include <system_service/ss_system_manager_if.h>
#include <system_service/ss_system_manager_if_local.h>
#include <native_service/frameworkunified_multithreading.h>
#include <sys/wait.h>
#include <system_service/ss_system_manager_notifications.h>
#include <system_service/ss_system_manager_notifications_local.h>
#include <native_service/frameworkunified_framework_if.h>
#include <system_service/ss_services.h>
#include <system_service/ss_power_service_if.h>
#include <processlauncher/ProcessLauncher.h>
#include <processlauncher/ss_sm_process_launcher_protocol.h>
#include <processlauncher/ss_sm_process_launcher.h>
#include <heartbeat/ss_hb_thread.h>

#include <system_service/ss_power_service_notifications.h>
#include <system_service/ss_power_service_protocol.h>

#include <native_service/ns_np_service.h>
#include <native_service/ns_np_service_protocol.h>
#include <native_service/ns_backup.h>

#include <stub/ss_diag.h>

#include <system_service/ss_error_message.h>
#include <system_service/ss_test_clients.h>
#include <system_service/ss_templates.h>
#include <native_service/ns_plogger_if.h>

#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <string>

#include "ss_system_manager_callbacks.h"
#include "ss_system_manager.h"
#include "ss_sm_systemmanagerlog.h"
#include "ss_sm_config.h"

using namespace std;  // NOLINT

extern SS_String GetStr(SS_SMModuleState f_enum);

template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE)> EFrameworkunifiedStatus SysMgrCallback(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  C * pObj = static_cast<C *>(&CSystemManager::GetInstance());
  if (pObj) {  // LCOV_EXCL_BR_LINE 5 : new error
    l_eStatus = (pObj->*M)(hApp);
  }
  return l_eStatus;
}

template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE, UI_32)>
EFrameworkunifiedStatus SysMgrCbType2(HANDLE hApp, UI_32 f_UI_32) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  C * pObj = static_cast<C *>(&CSystemManager::GetInstance());
  if (pObj) {  // LCOV_EXCL_BR_LINE 5 : new error
    l_eStatus = (pObj->*M)(hApp, f_UI_32);
  }
  return l_eStatus;
}

template<typename C, BOOL (C::*M)(UI_32)>
BOOL SysMgrCbType3(UI_32 f_UI_32) {
  BOOL l_bValue = FALSE;
  C * pObj = static_cast<C *>(&CSystemManager::GetInstance());
  if (pObj) {  // LCOV_EXCL_BR_LINE 5 : new error
    l_bValue = (pObj->*M)(f_UI_32);
  }
  return l_bValue;
}

enum {
  POWERON = TRUE,
  POWEROFF = FALSE
};

VOID CSystemManager::LogGroupModulesState(UI_32 f_groupId, std::string pStr) {
  if (IS_ZONE_SET(ZONE_INFO)) {  // LCOV_EXCL_BR_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
    // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

    GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(f_groupId);
    if (l_GroupIterator == m_MapProclaunchGrps.end()) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             " Error: Group %d not found; 'm_MapProclaunchGrps' is empty",
             f_groupId);
    } else {
      std::string sIsOKFlag;
      TEXT(__FUNCTION__, " Group %d/%s, %ld modules: %s, %s", f_groupId,
          l_GroupIterator->second.name.c_str(),
          l_GroupIterator->second.modules.size(), pStr.c_str(),
          GetStr(m_SMCurrentState).c_str());

      ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
      for (int i = 1;
          l_ModuleListIterator != l_GroupIterator->second.modules.end();
          l_ModuleListIterator++, i++) {
        sIsOKFlag = GetModuleCondition(l_ModuleListIterator) ? " " :  // 'blank' means OK
            "X";  // 'X' means state mismatch

        TEXT(__FUNCTION__,
          "   %2d: %-24s Start Req'd: %-5s %s %-24s %3dms, %3dms, %d",
          i, l_ModuleListIterator->name.c_str(),
        l_ModuleListIterator->is_start_required ?
                "TRUE" : "FALSE", sIsOKFlag.c_str(),
        l_ModuleListIterator->ModuleStateStr().c_str(),
        static_cast<SI_16>(l_ModuleListIterator->m_startReason.GetDelta()),
        static_cast<SI_16>(l_ModuleListIterator->m_stopReason.GetDelta()),
        l_ModuleListIterator->pid);
      }
    }
    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
    // LCOV_EXCL_STOP
  }
}  // End of VOID CSystemManager::LogGroupModulesState( UI_32 f_groupId, std::string pStr)

VOID CSystemManager::LogAllGroupModulesState(std::string pStr) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  std::string l_sIsOKFlag;
  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();

  std::stringstream l_comStream;

  l_comStream << pStr << "," << GetStr(m_SMCurrentState);

  std::string l_comStr = l_comStream.str();
  SystemmanagerLogString(ZONE_STATE, __FUNCTION__, l_comStr);

  while (l_GroupIterator != m_MapProclaunchGrps.end()) {
    std::stringstream l_tblStream;
    l_tblStream << "G" << l_GroupIterator->second.id << "/" << l_GroupIterator->second.name;

    ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();

    for (int i = 1;
        l_ModuleListIterator != l_GroupIterator->second.modules.end();
        l_ModuleListIterator++, i++) {
      // Since NPPService exceptionally transitions to STARTED when StartReq'd = N, it is not checked
      l_sIsOKFlag =
          GetModuleCondition(l_ModuleListIterator)
              | (FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIterator->name) ?
              " " :  // 'blank' means OK
              "X";   // 'X' means state mismatch

      std::string l_isStartReqd = l_ModuleListIterator->is_start_required ? "T" : "F";

      l_tblStream << endl << " " << std::setw(2) << std::right << i << ":"
          << l_ModuleListIterator->pid << " "
          << l_ModuleListIterator->name << " " << "StartReq:"
          << l_isStartReqd << " " << l_sIsOKFlag
          << l_ModuleListIterator->ModuleStateStr();

      if (l_ModuleListIterator->is_start_required && (FRAMEWORKUNIFIED_NS_NPSERVICE != l_ModuleListIterator->name)) {  // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set // NOLINT(whitespace/line_length)
        l_tblStream << " "
            << static_cast<SI_32>(l_ModuleListIterator->m_startReason.GetDelta())
            << "ms "
            << static_cast<SI_32>(l_ModuleListIterator->m_stopReason.GetDelta())
            << "ms";
      }
    }

    l_GroupIterator++;

    // Outputs each GROUP so that buffers do not overflow.
    std::string l_logMsgStr = l_tblStream.str();
    SystemmanagerLogString(ZONE_STATE, __FUNCTION__, l_logMsgStr);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}  // End of VOID CSystemManager::LogAllGroupModulesState(std::string pStr)

BOOL CSystemManager::GetModuleCondition(ModuleLaunchListIter & f_ModuleIter) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL l_bIsModuleStateGood = TRUE;

  switch (m_SMCurrentState) {  // LCOV_EXCL_BR_LINE 6: As no values are passed into the default case
  case SS_SM_READY_TO_LAUNCH_APP:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_INVALID);
    break;

  case SS_SM_APPS_LAUNCH_IN_PROGRESS:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED);
    break;

  case SS_SM_APPS_LAUNCHED_READY_TO_START:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED);
    break;

  case SS_SM_APPS_START_IN_PROGRESS:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED)
        || (f_ModuleIter->is_start_required
            && (f_ModuleIter->IsModuleState(MODULE_STATE_START_SENT)
                || f_ModuleIter->IsModuleState(
                    MODULE_STATE_STARTED)))
        || (!f_ModuleIter->is_start_required
            && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED)
                || f_ModuleIter->IsModuleState(
                    MODULE_STATE_CONNECTED)));
    break;

  case SS_SM_APPS_START_COMPLETE:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED) == TRUE))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
    break;

  case SS_SM_APPS_PRE_START_IN_PROGRESS:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_START_PRE_SENT) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
    break;

    case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_STOP_PRE_SENT) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
      break;

    case SS_SM_APPS_PRE_RUN_COMPLETE:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
      break;

    case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_START_BACKGROUND_SENT) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
      break;

    case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_SENT) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
      break;
    case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:
      l_bIsModuleStateGood =
          ((f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED) == TRUE)
              || (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED) == TRUE)
              || ((f_ModuleIter->is_start_required == TRUE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE)))
              || ((f_ModuleIter->is_start_required == FALSE)
                  && ((f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)
                      || (f_ModuleIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)))) ? (BOOL) TRUE : (BOOL) FALSE;
      break;

  case SS_SM_APPS_STOPPING_AT__CWORD56__REQ:
  case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED)
        || (f_ModuleIter->is_start_required
            && (f_ModuleIter->IsModuleState(MODULE_STATE_STOP_SENT)
                || f_ModuleIter->IsModuleState(
                    MODULE_STATE_STOPPED)))
        || (!f_ModuleIter->is_start_required
            && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED)
                || f_ModuleIter->IsModuleState(
                    MODULE_STATE_CONNECTED)));
    break;

  case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ:
  case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ:
    l_bIsModuleStateGood = f_ModuleIter->IsModuleState(MODULE_STATE_SKIPPED)
        || f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCH_FAILED)
        || (f_ModuleIter->is_start_required
            && f_ModuleIter->IsModuleState(MODULE_STATE_STOPPED))
        || (!f_ModuleIter->is_start_required
            && (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHED)
                || f_ModuleIter->IsModuleState(
                    MODULE_STATE_CONNECTED)));
    break;

    // default:  Don't code a 'default' here - let the compiler
    // issue a warning ( set via -Wall or -Wswitch ) when the set of
    // enumerations changes - then the maintainer will
    // automagically know to update this switch statement.
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_bIsModuleStateGood;
}  // End of BOOL CSystemManager::GetModuleCondition( ModuleLaunchListIter & f_ModuleIter )

/*****************************************************************************
 @ingroup: CSystemManager
 @brief: Post Termination handler
 @note: .
 @param void
 @return void
*****************************************************************************/
EFrameworkunifiedStatus CSystemManager::SendRequestToHeartBeat(HANDLE hApp,
        EHBProtocolMessages tRequest, VOID *tReqMessageData,
        UI_32 u32SizeofMessage) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  BOOL bValid = FALSE;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  switch (tRequest) {
  case SS_HEARTBEAT_START:
    bValid = TRUE;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_START");
    break;

  case SS_HEARTBEAT_STOP:
    bValid = TRUE;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_STOP");
    tReqMessageData = NULL;
    break;

  case SS_HEARTBEAT_DELETE_MODULE_ENTRY:
    bValid = TRUE;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_DELETE_MODULE_ENTRY");
    break;

  case SS_HEARTBEAT_APPEND_MODULE_ENTRY:
    bValid = TRUE;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SS_HEARTBEAT_APPEND_MODULE_ENTRY");
    break;

  default:
    bValid = FALSE;
    l_eStatus = eFrameworkunifiedStatusInvldParam;
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error : Ignored Invalid message id 0x%X", tRequest);
    break;
  }

  if (TRUE == bValid) {  // LCOV_EXCL_BR_LINE 200:tRequest cannot be default, so bValid cannot be false
    if (INVALID_HANDLE != m_hHeartbeatThread.m_ThreadHdl) {  // LCOV_EXCL_BR_LINE 200:m_ThreadHdl cannot be null
      if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl, tRequest, u32SizeofMessage, tReqMessageData))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
        // LCOV_EXCL_START 4: nsfw error
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_ERROR("FrameworkunifiedSendChild()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        // LCOV_EXCL_STOP
      }
    } else {
      // LCOV_EXCL_START 200: m_ThreadHdl cannot be null
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      l_eStatus = eFrameworkunifiedStatusInvldHandle;
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error : Invalid Heartbeat Thread Handle, cannot send message");
      // LCOV_EXCL_STOP
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnModuleConnectWaitTimeout
///  SM maintains timer (40 sec) to check if all modules opened session with him whoever requires Start.
///  This timer is common to all modules. After timeout it checks the status of every module in group map.
///  If a module requires start and does not connect, SM will initiate error event logging followed by Soft Reset
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnModuleConnectWaitTimeout(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  static SI_32 l_NumTimesChecked = 0;
  {
    char l_cFormat[] = " Received from (Timer expiration %d)";
    char l_cBuf[sizeof(l_cFormat) + 1];
    snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked + 1);
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, l_cBuf);
  }

  std::string l_ProcName;

  SetCmdHist("SM_TIMER_MODULE_CONNECT_WAIT_TIMER", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  BOOL l_bModuleConnMissed = false;

  GroupLaunchMap::reverse_iterator l_grp_riter = m_MapProclaunchGrps.rbegin();

  ModuleLaunchList::reverse_iterator l_mod_riter;

  if (l_grp_riter == m_MapProclaunchGrps.rend()) {  // LCOV_EXCL_BR_LINE 200: group cannot be empty
    // LCOV_EXCL_START 200: group cannot be empty
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Group Map is Empty");  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
    l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
    // LCOV_EXCL_STOP
  } else {
    // scan the group map in reverse order
    for (; l_grp_riter != m_MapProclaunchGrps.rend(); l_grp_riter++) {
      l_mod_riter = l_grp_riter->second.modules.rbegin();
      for (; l_mod_riter != l_grp_riter->second.modules.rend();
          l_mod_riter++) {
        SMModuleState l_ModuleState = l_mod_riter->GetModuleState();
        // if the module is still in MODULE_STATE_LAUNCHED state at
        // this point though it requires start something is wrong with
        // the module. SM initiates error event logging followed by
        // soft rest
        if (l_mod_riter->is_start_required
            && ((l_ModuleState == MODULE_STATE_INVALID)
                || (l_ModuleState == MODULE_STATE_SKIPPED)
                || (l_ModuleState == MODULE_STATE_LAUNCHING)
                || (l_ModuleState == MODULE_STATE_LAUNCHED)
                || (l_ModuleState == MODULE_STATE_LAUNCH_FAILED))) {
          FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
              " Module %s/%s is not connected",
              l_mod_riter->name.c_str(),
              l_mod_riter->ModuleStateStr().c_str());
          l_bModuleConnMissed = true;
          l_ProcName.assign(l_mod_riter->name);

          if (l_ModuleState == MODULE_STATE_LAUNCHED) {
            CALL_AND_LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
                l_mod_riter->SetPriority(  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
                    m_SystemManagerPriority - 1));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          }
        }
      }
    }
  }

  PreLaunchModuleListIter l_itr;
  for (l_itr = m_PreLaunchModuleList.begin();
      m_PreLaunchModuleList.end() != l_itr; l_itr++) {
    if ((-1 == l_itr->pid) && (l_itr->critical)) {  // LCOV_EXCL_BR_LINE 200: all prelaunch mode is not critical  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_START 200: all prelaunch mode is not critical
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Module %s is not launched",  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          l_itr->name.c_str());  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      l_bModuleConnMissed = true;
      l_ProcName.assign(l_itr->name);
    }
    // LCOV_EXCL_STOP
  }

  l_NumTimesChecked++;
  if (true == l_bModuleConnMissed) {
    if (l_NumTimesChecked < m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck) {
      char l_cFormat[] =
          " l_NumTimesChecked %d < ModuleConnectionNumTimesToCheck %d, "
              "will re-check in %d seconds. ";
      char l_cBuf[sizeof(l_cFormat) + 1 + 1 + 1];
      snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked,
          m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck,
          m_SMConfig.MCConfig.ModuleConnectionTimeOutSec);
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, l_cBuf);

    } else {
      l_eStatus = eFrameworkunifiedStatusBadConnection;
      char l_cFormat[] =
          " Module connection timeout for %s and "
              "l_NumTimesChecked %d == ModuleConnectionNumTimesToCheck %d. "
              " Stopping ModuleConnectTimeOut timer and resetting _CWORD102_.";
      char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP + 1 + 1];
      snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_ProcName.c_str(),
          l_NumTimesChecked,
          m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck);
      LOG_ERROR(l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

      m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER]); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

      SMLoggingInfo l_loggingInfo; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_GENERIC_ERR; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

      // initiate error event logging
      l_eStatus = ErrorEventEnqueue(hApp, eErrorEventTypeModConnFailed,
          l_ProcName, eErrorEventResetTypeHard, l_loggingInfo);
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: ModConnFailed %s",
          l_ProcName.c_str());
      fprintf(stderr, "SS_SysManager/%s/Error: ModConnFailed %s\n", // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
          __FUNCTION__, l_ProcName.c_str()); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
          "ErrorEventEnqueue(eErrorEventTypeModConnFailed)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
    }
  } else {
    char l_cFormat[] =
        " l_NumTimesChecked = %d, ModuleConnectionNumTimesToCheck = %d. "
            "All modules connected. Stopping ModuleConnectTimeOut timer.";
    char l_cBuf[sizeof(l_cFormat) + 1 + 1];
    snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_NumTimesChecked,
        m_SMConfig.MCConfig.ModuleConnectionNumTimesToCheck);
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, l_cBuf);

    m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER]); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnModuleConnectWaitTimeout( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnClientStartMonitorTimerExpiry
///
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnClientStartMonitorTimerExpiry(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from group %d"
    //, m_ActiveGroupId);
      , m_SystemStarter.get_id());

  char cBuf[100];
  SetCmdHist("SM_TIMER_CLIENT_START_MONITOR", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  // sprintf( cBuf, "ProcessGroupAsStarted(%d)", m_ActiveGroupId);
  sprintf(cBuf, "ProcessGroupAsStarted(%d)", m_SystemStarter.get_id());  // NOLINT
  l_eStatus = ProcessGroupAsStarted(hApp, m_SystemStarter.get_id());
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");


  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup send_power_request_complete_response
/// send power request completion response to power
///
/// \param [in]
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::send_power_request_complete_response(HANDLE hApp, std::string pStr) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  // send Wake-up complete response to Power
  l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession,
      SS_SM_WAKEUP_MODULES_CMPL_RSPN, sizeof(wakeInfo), (PVOID) & m_Wake);
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_WAKEUP_MODULES_CMPL_RSPN)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  LogAllGroupModulesState(pStr);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::send_power_request_complete_response( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnNPPStatusCheckMonitorTimerExpiry
///
/// \brief Called when NPP fails to provide a ready status in the specified.
///        amount of time.  This function will periodically request a new status
///        ACK from NPP service until one is received. See OnNPPReadyStatusCallback().
///
///        Note: NPP usually pushes a ready event to SM and the reversion to
///              polling the NPP ready ACK is for additional robustness. Failure
///              to receive an NPP ready ACK will prevent system startup.
///
/// \param [in] hApp - Handle to framework application.
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnNPPStatusCheckMonitorTimerExpiry(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  SetCmdHist("SM_TIMER_NPP_STATUS_CHECK_MONITOR", m_TimerCmdHist, // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_bIsNPP_ServicesStarted is '%s'",
      GetStr(m_bIsNPP_ServicesStarted).c_str());

  if (FALSE == m_bIsNPP_ServicesStarted) {
    l_eStatus = FrameworkunifiedNPGetReadyStatusOfNPP(hApp);
    LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "FrameworkunifiedNPGetReadyStatusOfNPP()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnNPPReadyStatusCallback
///
/// \brief Called when NPP returns a status ACK indicating that the service is
///        operational and ready to respond to subsequent requests.
///
/// \param [in] hApp - Handle to framework application.
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnNPPReadyStatusCallback(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("NPS_GET_READYSTATUS_ACK", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  l_eStatus = OnNPPReadyEventCallback(hApp);
  LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnNPPReadyEventCallback()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CSystemManager::OnNPPReadyEventCallback(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", l_moduleName);

  SetCmdHist("NPS_NPP_READY_EVENT", m_SMCmdHist, m_SMHistIter, l_moduleName); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  if (TRUE == m_bIsNPP_ServicesStarted) {
    l_eStatus = eFrameworkunifiedStatusMsgNotProcessed;
    LOG_ERROR("TRUE == m_bIsNPP_ServicesStarted");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    ModuleLaunchListIter l_ModuleListIter;
    m_bIsNPP_ServicesStarted = TRUE;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_bIsNPP_ServicesStarted set 'TRUE'");
    m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR]);

    UI_32 l_cbCmdIdArrayNPPService[] = { NPS_NPP_READY_EVENT, NPS_GET_READYSTATUS_ACK };

    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE, l_cbCmdIdArrayNPPService, static_cast<UI_32>(_countof(l_cbCmdIdArrayNPPService))))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
      // LCOV_EXCL_START 4: nsfw error code
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      LOG_ERROR("FrameworkunifiedDetachCallbacksFromDispatcher()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_STOP
    } else if (eFrameworkunifiedStatusOK != (l_eStatus = register_all_notification_callbacks(hApp))) {    // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
      // LCOV_EXCL_START 4: nsfw error code
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      LOG_ERROR("register_all_notification_callbacks()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_STOP
    } else if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) {  // LCOV_EXCL_BR_LINE 200:NPP always in launch map  //NOLINT (whitespace/line_length)
      // LCOV_EXCL_START 200 : NPP service always in launch map
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          " Error: Module %s not found in Group Launch Map",  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          l_moduleName);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_STOP
    } else {
      l_ModuleListIter->SetModuleState(MODULE_STATE_STARTED);

      if (m_oSystemLauncher.get_id() == 1) {
        m_oSystemLauncher.advance_id();
      }

      l_eStatus = OnLaunchGroup(hApp);
      LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnLaunchGroup(hApp)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
      if (eFrameworkunifiedStatusOK == l_eStatus) {   // LCOV_EXCL_BR_LINE 200: OnLaunchGroup() return ok
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " successful");
      }
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnNPPReadyEventCallback( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnBackupMgrAvailCallback
/// BackupManager Availability Notification Callback
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnBackupMgrAvailCallback(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (sizeof(ServiceAvailability) != FrameworkunifiedGetMsgLength(hApp)) {  // LCOV_EXCL_BR_LINE 4: nsfw error
    // LCOV_EXCL_START 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
    l_eStatus = eFrameworkunifiedStatusFail;
  } else if (strcmp(FrameworkunifiedGetLastNotification(hApp), NTFY_BackupMgr_Availability) != 0) {  // LCOV_EXCL_BR_LINE 200:cannot be false //NOLINT (whitespace/line_length)
    // LCOV_EXCL_START 200: cannot be false
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    l_eStatus = eFrameworkunifiedStatusFail;
    // LCOV_EXCL_STOP
  } else {
    m_bIsBackupAvail = FrameworkunifiedIsServiceAvailable(hApp);
    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "BackupAvail:%s", m_bIsBackupAvail ? "T" : "F");

    l_eStatus = OnLaunchGroup(hApp);
    LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "OnLaunchGroup(hApp)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnBackupMgrAvailCallback(HANDLE hApp)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnPowerRequestCallback
/// PowerRequest callback handler
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnPowerRequestCallback(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  Pwr_ServiceSetInterface tServiceIf;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)

  SetCmdHist("SS_SM_POWER_REQUEST_MSG", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp));

  //  OnSystemManagerDebugDump(hApp);
  // ReadMsg():                                                        *
  //     Check hApp ptr, msg size, msg reception, read msg if all ok.  *
  //     Report any errors found.                                      *
  //                                                                   *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, tServiceIf))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
    // LCOV_EXCL_START 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else {
    // NOTE: interface_unified always set userMode as 0. so don't use m_lastUserMode.
    m_lastUserMode = tServiceIf.data.powerRequestMsg.userMode;
    //
    // 2012 December 04 Temporary hack ( I hope ) to set m_Wake to nominal
    // values. At present, the 'Power Request Message Response' is sent
    // back to Power Services via the 'send_power_request_complete_response()'
    // function, which uses m_Wake.
    m_Wake.powerupType =
        m_SSBool_to_PowerTypeEnumMap[m_SSUserMode_to_SSBoolEnumMap[m_lastUserMode]];

    m_Wake.up.factor = tServiceIf.data.powerRequestMsg.startupReason;

    if (epswfINVALID != m_Wake.up.factor) {
      m_StartUpReason = m_Wake.up.factor;
    }

    m_userModeChangeReason = tServiceIf.data.powerRequestMsg.userModeChangeReason;
    m_Wake.up.userModeChangeReason = m_userModeChangeReason;

    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "UserMode:%s, SM State:%s",
        GetStr(m_lastUserMode).c_str(),
        GetStr(m_SMCurrentState).c_str());
    FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "UserMode:%s, SM State:%s",
        GetStr(m_lastUserMode).c_str(),
        GetStr(m_SMCurrentState).c_str());
    CALL_AND_LOG_STATUS(PublishPowerOnOffNotification(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

    switch (m_SMCurrentState) {  // LCOV_EXCL_BR_LINE 6: As not all cases can be passed through
      case SS_SM_READY_TO_LAUNCH_APP:
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: Received a PowerRequest command while still in "
            "the '%s' state !!!",
            GetStr(m_SMCurrentState).c_str());
        l_eStatus = eFrameworkunifiedStatusErrOther;
        break;

      case SS_SM_APPS_LAUNCH_IN_PROGRESS:
        // When Start is received while processes are launching, we
        // need to send the Start request later, once the 'Open
        // Session Request' is received from the application.
        //*****
        // Deliberate commenting-out of case-break to allow this case to
        // use following case's logic.
        // break;
        //*****

      case SS_SM_APPS_LAUNCHED_READY_TO_START:
      case SS_SM_APPS_START_COMPLETE:
      case SS_SM_APPS_PRE_RUN_COMPLETE:
      case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:
      case SS_SM_APPS_START_IN_PROGRESS:
      case SS_SM_APPS_PRE_START_IN_PROGRESS:
      case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
      case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
      case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
        FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "Startup Reason is '%s'", GetStr(m_StartUpReason).c_str());
        if ((m_userModeChangeReason == epsumcrPARKING_B)
            || ((m_userModeChangeReason == epsumcrPRE_BA) && (m_SMCurrentState == SS_SM_APPS_PRE_RUN_COMPLETE))
            || ((m_userModeChangeReason == epsumcrNORMAL) && (m_SMCurrentState == SS_SM_APPS_START_COMPLETE))
            || ((m_userModeChangeReason == epsumcrBACKGROUND_BA)
                && (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE))) {
          // send the Power Request complete response to PowerService
          // LCOV_EXCL_BR_START 15: Excluded due to inlined functions
          CALL_AND_LOG_STATUS_IF_ERRORED(send_power_request_complete_response(hApp, "Power Request"));
          // LCOV_EXCL_BR_STOP 15: Excluded due to inlined functions
        } else {
          //
          // Publish the UserMode 'Off' notification now for those
          // applications that need immediate notification ( HMI )
          if (m_lastUserMode == epsumOFF) {
            CALL_AND_LOG_STATUS(PublishUserModeNotification(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          }

          CALL_AND_LOG_STATUS(BeginStartup(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        }
        break;

      case SS_SM_APPS_STOPPING_AT__CWORD56__REQ:
      case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ:
        // Abort the Stop.
        // Reset System Manager to handle (re)starting as if this is a
        // nominal start.
        m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR]);

        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Aborted %s, resetting to %s,"
            " restarting Application groups at group %d",
            GetStr(m_SMCurrentState).c_str(),
            GetStr(SS_SM_APPS_START_IN_PROGRESS).c_str()
            , m_SystemStarter.get_id());

        CALL_AND_LOG_STATUS(BeginStartup(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

        break;

      case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ:
      case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ:  // LCOV_EXCL_START 8: As no value is set
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
              " Warning: System Manager state is %d/'%s', ignoring "
              "PowerRequest command", m_SMCurrentState,
              GetStr(m_SMCurrentState).c_str());
          break;
      }  // LCOV_EXCL_STOP
    }
    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
    return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnPowerRequestCallback( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
/// Begin the Startup process
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::BeginStartup(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if ((m_userModeChangeReason != epsumcrPARKING_B) &&
      (m_userModeChangeReason != epsumcrPRE_BA) &&
      (m_userModeChangeReason != epsumcrNORMAL) &&
      (m_userModeChangeReason != epsumcrBACKGROUND_BA)) {
    // Not a power state transition request.
    return eFrameworkunifiedStatusOK;
  }

  switch (m_userModeChangeReason) {  // LCOV_EXCL_BR_LINE 6: Excluded because it has been guarded to prevent out-of-range values from entering immediately before.
  case epsumcrPRE_BA:
    // LCOV_EXCL_BR_START 6: This function is an internal function, and it is guarded so that the value outside the range is not entered by the caller, so it is excluded.
    if ((m_SMCurrentState == SS_SM_APPS_START_COMPLETE) || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE)) {
      // LCOV_EXCL_BR_STOP 6: This function is an internal function, and it is guarded so that the value outside the range is not entered by the caller, so it is excluded.
      m_SystemStarter.to_end();
      SMSetState(hApp, SS_SM_APPS_PRE_STOP_IN_PROGRESS);
    } else {
      m_SystemStarter.to_begin();
      SMSetState(hApp, SS_SM_APPS_PRE_START_IN_PROGRESS);
    }
    break;
  case epsumcrNORMAL:
    m_SystemStarter.to_begin();
    SMSetState(hApp, SS_SM_APPS_START_IN_PROGRESS);
    break;
  case epsumcrBACKGROUND_BA:
    if (m_SMCurrentState == SS_SM_APPS_START_COMPLETE) {
      m_SystemStarter.to_end();
      SMSetState(hApp, SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS);
    } else {
      m_SystemStarter.to_begin();
      SMSetState(hApp, SS_SM_APPS_BACKGROUND_START_IN_PROGRESS);
    }
    break;
  default:
    break;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      " Starting 'Start Resp Monitor' Timer with '%d' sec",
      m_SMConfig.MCConfig.ModuleStartRespTimeOutSec);

  m_GroupLaunchTimer->StartTimer(
      m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER],
      m_SMConfig.MCConfig.ModuleStartRespTimeOutSec, 0, 0, 0);

  l_eStatus = start_all_modules_of_group(hApp, m_SystemStarter.get_id());
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: start_all_modules_of_group(%d) errored: %d/'%s'",
        m_SystemStarter.get_id(), l_eStatus, GetStr(l_eStatus).c_str());
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::BeginStartup( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnWakeupCallback
/// WakeUp callback handler
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnWakeupCallback(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "Received from %s", FrameworkunifiedGetMsgSrc(hApp));

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnWakeupCallback( HANDLE hApp )
// LCOV_EXCL_STOP

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnModuleStartCompleteResponse
/// Start Response\Ack Handlers
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnModuleStartCompleteResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("system_manager protocol completion response", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  ModuleLaunchListIter l_ModuleListIter;
  std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
  l_eStatus = GetModuleIterator(l_moduleName.c_str(), l_ModuleListIter);
  if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 200:always be eFrameworkunifiedStatusOK
    // LCOV_EXCL_START 200: always be eFrameworkunifiedStatusOK
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Module %s not found in Group Launch Map",
        l_moduleName.c_str());
    // LCOV_EXCL_STOP
  } else {
    switch (m_SMCurrentState) {  // LCOV_EXCL_BR_LINE 200: cannot be SS_SM_READY_TO_LAUNCH_APP
    case SS_SM_READY_TO_LAUNCH_APP:
      // LCOV_EXCL_START 200: cannot be SS_SM_READY_TO_LAUNCH_APP
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: Received while in the '%s' state !!!",
          GetStr(m_SMCurrentState).c_str());
      l_eStatus = eFrameworkunifiedStatusErrOther;
      break;
      // LCOV_EXCL_STOP

    case SS_SM_APPS_LAUNCH_IN_PROGRESS:
    case SS_SM_APPS_LAUNCHED_READY_TO_START:
    case SS_SM_APPS_START_IN_PROGRESS:
    case SS_SM_APPS_PRE_START_IN_PROGRESS:
    case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
    case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
    case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
      {
        const SMModuleState l_state = InProgressStateToState();  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
        if (l_state != MODULE_STATE_INVALID) {
          const PCSTR l_loglist[] = {"start", "pre start", "pre stop", "background start", "background stop", ""};
          PCSTR l_logtxt;
          switch (l_state) {  // LCOV_EXCL_BR_LINE 6: As no other value is returned
          case MODULE_STATE_STARTED:
            l_logtxt = l_loglist[0];
            break;
          case MODULE_STATE_STARTED_PRE:
            l_logtxt = l_loglist[1];
            break;
          case MODULE_STATE_STOPPED_PRE:
            l_logtxt = l_loglist[2];
            break;
          case MODULE_STATE_STARTED_BACKGROUND:
            l_logtxt = l_loglist[3];
            break;
          case MODULE_STATE_STOPPED_BACKGROUND:
            l_logtxt = l_loglist[4];
            break;
          // LCOV_EXCL_START 6: As no other value is returned
          default:
            AGL_ASSERT_NOT_TESTED();
            l_logtxt = l_loglist[5];
            break;
          // LCOV_EXCL_STOP 6: As no other value is returned
          }
          l_eStatus = ModuleCompleteResponse(hApp, l_ModuleListIter, l_state,  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
                                             SysMgrCbType3<CSystemManager, &CSystemManager::IsGroupStarted>,
                                             SysMgrCbType2<CSystemManager, &CSystemManager::ProcessGroupAsStarted>,
                                             l_logtxt);
        }
      }
      break;

    case SS_SM_APPS_STOPPING_AT__CWORD56__REQ:
    case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ:
    case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ:
    case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ:
      // SystemManager changed state while this module was starting;
      // tell this module to stop.
      if (!l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_SENT)
          && !l_ModuleListIter->IsModuleState(MODULE_STATE_STOPPED)) {
        T_SS_SM_STOP_DataStructType l_SM_STOP_Struct;
        l_SM_STOP_Struct.shutdownTrigger = m_shutdownTrigger;
        l_SM_STOP_Struct.lastUserMode = m_lastUserMode;

        CALL_AND_LOG_STATUS(                               // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
            l_ModuleListIter->SendMsgAndUpdateState(
                &l_SM_STOP_Struct));
      }
      break;
    default:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Received while in the '%s' state !!!", GetStr(m_SMCurrentState).c_str());
      l_eStatus = eFrameworkunifiedStatusErrOther;
      break;
    }        // End switch ( m_SMCurrentState )
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnModuleStartCompleteResponse( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup ModuleCompleteResponse
/// Start Response\Ack Handlers
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::ModuleCompleteResponse(HANDLE hApp,
        ModuleLaunchListIter f_ModuleListIter, SMModuleState f_moduleState,
        FncCbType3 f_isGroupDoneFnc, FncCbType2 f_groupDoneFnc,
        PCSTR f_sCompleteTypeText) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      " Received from %s, m_SystemStarter.get_id() is %d",
      l_moduleName.c_str()
      , m_SystemStarter.get_id());

  f_ModuleListIter->SetModuleState(f_moduleState);
  if (f_ModuleListIter->group_id != m_SystemStarter.get_id()) {
    // In PastModel002, it is assumed that there is no service that returns a FrameworkunifiedOnStop reply after the NPP service.
    // However, since _CWORD71_ does not assume this, completion of waiting for termination of the CRITICAL service must be
    // judged even when services other than the Group1 service terminate last.
    // Initially, SS_SM_WAITING_FOR_CRITICAL_APPS_AT_XXXX should be handled separately by ProcessModuleStopCompleteResponse(),
    // but this is limited to ModuleCompleteResponse in order to avoid code deviation from PastModel002 and limit the scope of effect.
    // LCOV_EXCL_BR_START 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ  // NOLINT(whitespace/line_length)
    if ((MODULE_STATE_STOPPED == f_moduleState)
        && ((m_SMCurrentState
            == SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ)
            || (m_SMCurrentState
                == SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ))) {
    // LCOV_EXCL_BR_STOP 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_START 200 : m_SMCurrentState can't be SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ and SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ  // NOLINT(whitespace/line_length)
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      check_all_groups_have_stopped(hApp);
      // LCOV_EXCL_STOP
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
          " %s ( group %d ) received out-of-synch; m_SystemStarter.get_id() is %d",
          l_moduleName.c_str(), f_ModuleListIter->group_id
          , m_SystemStarter.get_id());
    }
  } else {
    if ((*f_isGroupDoneFnc)(f_ModuleListIter->group_id)) {  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
      l_eStatus = (*f_groupDoneFnc)(hApp, f_ModuleListIter->group_id); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    } else if (IS_ZONE_SET(ZONE_INFO)) {  // LCOV_EXCL_BR_LINE 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
      // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      TEXT(__FUNCTION__,  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          " Group %d %s incomplete, m_SystemStarter.get_id() is %d",  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          f_ModuleListIter->group_id, f_sCompleteTypeText  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          , m_SystemStarter.get_id());  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      char cBuf[100];
      sprintf(cBuf, "%s incomplete", f_sCompleteTypeText);  // NOLINT
      LogGroupModulesState(f_ModuleListIter->group_id, cBuf);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_STOP
    }
  }

  const SMModuleState l_transition_state = InProgressStateToState();  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
  if (l_transition_state == f_moduleState) {  // LCOV_EXCL_BR_LINE 6:  As no other value is returned
    if (have_all_services_start_completed(l_transition_state) == TRUE) {
      if ((m_SMCurrentState == SS_SM_APPS_PRE_START_IN_PROGRESS)
          || (m_SMCurrentState == SS_SM_APPS_PRE_STOP_IN_PROGRESS)) {
        SMSetState(hApp, SS_SM_APPS_PRE_RUN_COMPLETE);  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
      } else if ((m_SMCurrentState == SS_SM_APPS_BACKGROUND_START_IN_PROGRESS)
          || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS)) {
        SMSetState(hApp, SS_SM_APPS_BACKGROUND_RUN_COMPLETE);  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
      } else {
        SMSetState(hApp, SS_SM_APPS_START_COMPLETE);  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
      }
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ModuleCompleteResponse(

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnStartRespMonitorTimeout
///  SM maintains timer to check if all modules sent start response to him whoever requires Start.
///  This timer is common to all modules. After timeout it checks the status of every module in group map.
///  If a module sent start and does not respond, SM will initiate error event logging followed by Soft Reset
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnStartRespMonitorTimeout(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  std::string l_ProcName;
  BOOL l_isStartRespNotReceived = false;

  SetCmdHist("SM_TIMER_START_RESP_MONITOR_WAIT_TIMER", m_TimerCmdHist,
      m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp));
  GroupLaunchMap::reverse_iterator l_grp_riter = m_MapProclaunchGrps.rbegin();
  ModuleLaunchList::reverse_iterator l_mod_riter;

  if (l_grp_riter == m_MapProclaunchGrps.rend()) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Group Map is Empty");
  } else {
    // scan the group map in reverse order
    for (; l_grp_riter != m_MapProclaunchGrps.rend(); l_grp_riter++) {
      l_mod_riter = l_grp_riter->second.modules.rbegin();
      for (; l_mod_riter != l_grp_riter->second.modules.rend(); l_mod_riter++) {
        // if a module sent start and not received response from module SM wait for "ModuleStartRespTimeout"
        // and initiated error event
        // logging followed by soft reset

        if (l_mod_riter->is_start_required) {
          if (l_mod_riter->IsModuleState(MODULE_STATE_START_SENT)) {
            FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
                " Module [%s] did not respond(%s) to SM in allocated time [%d] sec",
                l_mod_riter->name.c_str(),
                l_mod_riter->ModuleStateStr().c_str(),
                m_SMConfig.MCConfig.ModuleStartRespTimeOutSec);
            l_isStartRespNotReceived = true;
            l_ProcName.assign(l_mod_riter->name);
          }
        }
      }
    }
  }

  if (true == l_isStartRespNotReceived) {
    char l_cFormat[] = " Error. Module '%s' start response timeout.";
    char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP];
    snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat, l_ProcName.c_str());
    TEXT(__FUNCTION__, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
    FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, l_cBuf);

    SMLoggingInfo l_loggingInfo;
    l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_GENERIC_ERR;

    // initate error event logging
    l_eStatus = ErrorEventEnqueue(hApp, eErrorEventTypeStartRespFailed,
        l_ProcName, eErrorEventResetTypeHard, l_loggingInfo);
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: StartRespFailed %s", l_ProcName.c_str());
    fprintf(stderr, "SS_SysManager/%s/Error: StartRespFailed %s\n",
        __FUNCTION__, l_ProcName.c_str());
    LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
        "ErrorEventEnqueue(eErrorEventTypeStartRespFailed)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__,
        " All modules returned Start Response.");

    l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl,
        SS_HEARTBEAT_AVAIL_CHECK_REQ, 0, NULL);
    SS_ASERT(l_eStatus == eFrameworkunifiedStatusOK);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnStartRespMonitorTimeout(HANDLE hApp)
// LCOV_EXCL_STOP

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnShutdownCompleteMonitorTimeout
///  SM maintains timer to check if all modules sent start response to him whoever requires Start.
///  This timer is common to all modules. After timeout it checks the status of every module in group map.
///  If a module sent start and does not respond, SM will initiate error event logging followed by Soft Reset
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnShutdownCompleteMonitorTimeout(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: Reset Timeout");

  l_eStatus = SecureChipOff();
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: SecureChipOff Failed");
  }

  m_ResetFactor = PSM_FACTOR_AGL_WITH_HISTORY;

  l_eStatus = perform_force_reset(hApp);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnShutdownCompleteMonitorTimeout(HANDLE hApp)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup start_all_modules_of_group
/// Send START to all modules of the given group
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(
      f_ui32GroupNumber);
  if (l_GroupIterator == m_MapProclaunchGrps.end()) {  // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR,
        __FUNCTION__
        , " Error: Group %d not found; 'm_MapProclaunchGrps' is empty",
        f_ui32GroupNumber);
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusInvldParam;  // LCOV_EXCL_LINE 6: Because the condition cannot be set
  } else {
    T_SS_SM_START_DataStructType f_startupData(m_StartUpReason,
        m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType],
        m_DataResetMode, m_startUpConfirmationMsg.securityStatus,
        m_startUpConfirmationMsg.wakeupType, m_DramBackupStatus,
        m_ResetStatus, m_ResetCount);

    UI_32 l_numModulesMessaged = 0;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
        " Attempting to send Start Requests to Group %d/'%s'",
        f_ui32GroupNumber, l_GroupIterator->second.name.c_str());

    for (ModuleLaunchListIter l_ModuleListIterator =
        l_GroupIterator->second.modules.begin();
        l_ModuleListIterator != l_GroupIterator->second.modules.end();
        l_ModuleListIterator++) {
      //
      // Every branch below must ZONE_INFO log how it dispenses w/
      // the module.
      //  Note: ModuleLaunchParams::SetModuleState() performs that
      //    ZONE_INFO logging internally.
      if (!l_ModuleListIterator->is_start_required) {
        if (FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIterator->name) {
          const SMModuleState l_transition_state = InProgressStateToState();  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
          l_ModuleListIterator->SetModuleState(l_transition_state);  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
        } else {
          // Not an error
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
              " %s 'is_start_required' is False;"
                  " leaving state as '%s'",
              l_ModuleListIterator->name.c_str(),
              l_ModuleListIterator->ModuleStateStr().c_str());
        }
        l_eStatus = eFrameworkunifiedStatusOK;
      } else if (NULL == l_ModuleListIterator->hsession) {  // LCOV_EXCL_BR_LINE 6: hsession can not be null.
        l_eStatus = eFrameworkunifiedStatusOK;  // Log a message. But its not a failure
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: NULL == hsession;"
            " %s not connected yet",
            l_ModuleListIterator->name.c_str());
      } else {
        switch (l_ModuleListIterator->GetModuleState()) {  // LCOV_EXCL_BR_LINE 6: As not all cases can be passed through
        case MODULE_STATE_INVALID:
        case MODULE_STATE_SKIPPED:
        case MODULE_STATE_LAUNCH_FAILED:
          // LCOV_EXCL_START 6: Because the state of the corresponding variable cannot be set
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          l_eStatus = eFrameworkunifiedStatusOK;  // Log a message. But its not a failure
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
              " %s is %s, NOT sending system_manager protocol message",
              l_ModuleListIterator->name.c_str(),
              l_ModuleListIterator->ModuleStateStr().c_str());
          break;
          // LCOV_EXCL_STOP

        case MODULE_STATE_START_SENT:
        case MODULE_STATE_START_PRE_SENT:
        case MODULE_STATE_STOP_PRE_SENT:
        case MODULE_STATE_START_BACKGROUND_SENT:
        case MODULE_STATE_STOP_BACKGROUND_SENT:
          l_eStatus = eFrameworkunifiedStatusOK;
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
              " %s is %s, NOT sending system_manager protocol message",
              l_ModuleListIterator->name.c_str(),
              l_ModuleListIterator->ModuleStateStr().c_str());
          l_numModulesMessaged++;
          break;

        case MODULE_STATE_LAUNCHING:
        case MODULE_STATE_LAUNCHED:
          // LCOV_EXCL_START 6: Because the state of the corresponding variable cannot be set
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          l_eStatus = eFrameworkunifiedStatusOK;  // Log a message. But its not a failure
          FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
              " %s is %s, NOT sending system_manager protocol message",
              l_ModuleListIterator->name.c_str(),
              l_ModuleListIterator->ModuleStateStr().c_str());
          break;
          // LCOV_EXCL_STOP

        case MODULE_STATE_CONNECTED:
        case MODULE_STATE_STARTED:
        case MODULE_STATE_START_FAILED:
        case MODULE_STATE_STOP_FAILED:
        case MODULE_STATE_STOP_SENT:
        case MODULE_STATE_STOPPED:
        case MODULE_STATE_STARTED_PRE:
        case MODULE_STATE_START_PRE_FAILED:
        case MODULE_STATE_STOPPED_PRE:
        case MODULE_STATE_STOP_PRE_FAILED:
        case MODULE_STATE_STARTED_BACKGROUND:
        case MODULE_STATE_START_BACKGROUND_FAILED:
        case MODULE_STATE_STOPPED_BACKGROUND:
        case MODULE_STATE_STOP_BACKGROUND_FAILED:
          {
            const UI_32 l_iCmd = InProgressStateToSendMsg();  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
            if (l_iCmd != SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX) {  // LCOV_EXCL_BR_LINE 6: Excluded due to value never returned at present
              // LCOV_EXCL_BR_START 15: Excluded due to inlined functions
              CALL_AND_LOG_STATUS_IF_ERRORED(l_ModuleListIterator->SendMsgAndUpdateState(l_iCmd, &f_startupData));
              // LCOV_EXCL_BR_STOP 15: Excluded due to inlined functions
              l_numModulesMessaged++;
            }
          }
          break;
          // default:  Don't code a 'default' here - let the compiler
          // detect when the set of module_state enumerations changes -
          // then the System Service's System Manager maintainer will
          // automagically know to update this switch statement.
        }
      }
    }

    if (0 == l_numModulesMessaged) {
      LogGroupModulesState(f_ui32GroupNumber, " Warning: NO modules were sent system_manager protocol message");  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)

      char l_cBuf[100];
      snprintf(l_cBuf, sizeof(l_cBuf), "ProcessGroupAsStarted(%d)", l_GroupIterator->second.id);
      l_eStatus = ProcessGroupAsStarted(hApp, l_GroupIterator);
      LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
    } else {
      m_GroupLaunchTimer->StartTimer(
          m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR],
          SS_CLIENT_START_MONITOR_TIMER_CONFIG, 0, 0, 0);
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::start_all_modules_of_group(HANDLE hApp, UI_32 f_ui32GroupNumber)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup start_all_modules_of_group
/// mark the specified group as started. If there is another group to start,
/// do so, else send Start Complete Response to the Start Requester.
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted(HANDLE hApp, UI_32 f_groupId) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(f_groupId);
  if (l_GroupIterator == m_MapProclaunchGrps.end()) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Group %d not found; 'm_MapProclaunchGrps' is empty", f_groupId);
    l_eStatus = eFrameworkunifiedStatusInvldParam;
  } else {
    l_eStatus = ProcessGroupAsStarted(hApp, l_GroupIterator);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted( HANDLE hApp, UI_32 f_groupId )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup start_all_modules_of_group
/// mark the specified group as started. If there is another group to start,
/// do so, else send Start Complete Response to the Start Requester.
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted(HANDLE hApp,
        GroupLaunchMapIter f_GroupIterator) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  UI_32 l_groupID = m_SystemStarter.get_id();


  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR]);

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      " Group %d/%s start completed, m_SystemStarter.get_id() is %d",
      f_GroupIterator->second.id, f_GroupIterator->second.name.c_str(),
      l_groupID);

  if (f_GroupIterator->second.id != l_groupID) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO,
        __FUNCTION__
        , " The just-started group ( %d/%s ) is not the current Active "
            " Group ( %d ); not starting next group's modules",
        f_GroupIterator->second.id,
        f_GroupIterator->second.name.c_str(), l_groupID);
  } else {
    if ((m_SMCurrentState == SS_SM_APPS_START_IN_PROGRESS)
        || (m_SMCurrentState == SS_SM_APPS_PRE_START_IN_PROGRESS)
        || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_START_IN_PROGRESS)) {
      // check if WakeUp Level has been achieved
      if (m_SystemStarter.is_end() == FALSE) {
        // Start modules from next group
        l_groupID = m_SystemStarter.advance_id();  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
        char l_cBuf[100] = {0};
        snprintf(l_cBuf, sizeof(l_cBuf), "start_all_modules_of_group(%u)", l_groupID);
        l_eStatus = start_all_modules_of_group(hApp, l_groupID);  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
        LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);   // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
      }
    } else if ((m_SMCurrentState == SS_SM_APPS_PRE_STOP_IN_PROGRESS)
        || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS)) {
      if (m_SystemStarter.is_begin() == FALSE) {
        // Stop modules from next group
        l_groupID = m_SystemStarter.decrement_id();  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
        char l_cBuf[100] = {0};
        snprintf(l_cBuf, sizeof(l_cBuf), "stop_all_modules_of_group(%u)", l_groupID);
        l_eStatus = start_all_modules_of_group(hApp, l_groupID);  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
        LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);   // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
      }
    } else {
      // MISRA C++-2008 Rule 6-4-2
      // NOP
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupAsStarted( GroupLaunchMapIter f_GroupIterator )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup calculate_max_shutdown_time
/// Calculate maximum shutdown time of apps critical to shutdown
/// from the launch group map
///
/// \param [in]
///
/// \return UI_32
/// Max Value of critical shutdown apps shutdown time
///////////////////////////////////////////////////////////////////////////////
UI_32 CSystemManager::calculate_max_shutdown_time() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  UI_32 l_MaxShutdownTimeValue = 0;
  std::string moduleName;

  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
  for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) {
    ModuleLaunchListIter l_ModuleListIterator =
        l_GroupIterator->second.modules.begin();
    for (; l_ModuleListIterator != l_GroupIterator->second.modules.end();
        l_ModuleListIterator++) {
      if (l_ModuleListIterator->shutdown_critical) {
        if (l_MaxShutdownTimeValue < l_ModuleListIterator->shutdown_wait_time) {
          moduleName = l_ModuleListIterator->name;
          l_MaxShutdownTimeValue = l_ModuleListIterator->shutdown_wait_time;
        }
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Max time: Module %s, time %d s",
      moduleName.c_str(), l_MaxShutdownTimeValue);
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_MaxShutdownTimeValue;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnShutdownModulesRequest
/// Send Shutdown to all modules in reverse order of group
///
/// \param [in]
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnShutdownModulesRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__,
      " Received from %s, m_SystemStarter.get_id() is %d",
      FrameworkunifiedGetMsgSrc(hApp)
      , m_SystemStarter.get_id());

  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "m_SystemStarter.get_id() is %d", m_SystemStarter.get_id());

  SetCmdHist("SS_SM_SHUTDOWN_MODULES", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  Pwr_ServiceSetInterface l_tServiceSetIf;
  // ReadMsg():                              *
  //   Check hApp ptr, msg size, msg reception, read msg if all ok.    *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, l_tServiceSetIf))) {   // LCOV_EXCL_BR_LINE 4: nsfw error
    // LCOV_EXCL_START 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else {
    BOOL isImmShutdown = FALSE;

    // If the Shutdown is not completed after the Shutdown is requested, it is forcibly reset.
    m_GroupLaunchTimer->StartTimer(
        m_aTimerIDs[eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR],
        SM_SHUTDOWN_COMPLETE_MONITOR_TIMEOUT, 0, 0, 0);

    if (m_isImmResetReq) {
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " ImmReset");
      isImmShutdown = TRUE;
    }

    switch (l_tServiceSetIf.data.shutdownRequestMsg.lastUserMode) {
    case epsumINVALID:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: shutdownRequestMsg.lastUserMode == epsumINVALID");
      l_eStatus = eFrameworkunifiedStatusInvldParam;
      break;

    case epsumOFF:
    case epsumON: {
      switch (m_SMCurrentState) {
      case SS_SM_READY_TO_LAUNCH_APP:
      case SS_SM_APPS_LAUNCH_IN_PROGRESS:
      case SS_SM_APPS_LAUNCHED_READY_TO_START:
        isImmShutdown = TRUE;
      case SS_SM_APPS_START_COMPLETE:
      case SS_SM_APPS_START_IN_PROGRESS:
      case SS_SM_APPS_PRE_START_IN_PROGRESS:
      case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
      case SS_SM_APPS_PRE_RUN_COMPLETE:
      case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
      case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
      case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:

        if (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger ==
                                                            epssdmsdtIGN_OFF) {
          m_ResetCount = 0;
          if (PowerHalSetResetInfo(AGL_RESET_COUNTER, m_ResetCount)) {  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
              "Could not back up m_ResetCount(%lu) to power_hal", m_ResetCount);
          }

          if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, 0)) {  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
              "Could not reset AGL_ERRLOG_COUNTER");
          }
        }
        if (!m_isPrevErrEventCompleted
            || ((!((m_SMCurrentState == SS_SM_APPS_START_COMPLETE)
                || (m_SMCurrentState == SS_SM_APPS_PRE_RUN_COMPLETE)
                || (m_SMCurrentState == SS_SM_APPS_BACKGROUND_RUN_COMPLETE)))
                && (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger
                    == epssdmsdtIGN_OFF
                    || l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger
                        == epssdmsdtNORMAL_RESET))) {
          FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "shutdown pending");
          if (!m_dqDeferMsg.empty()) {
            SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          } else {
            SM_POWER_EVENT_INFO deferMsg(SS_SM_SHUTDOWN_MODULES, l_tServiceSetIf);
            m_dqDeferMsg.push(deferMsg);
          }
        } else {
          // The shutdownTrigger has already been validated by
          // Power::OnShutdownRequestMsg()
          m_shutdownTrigger = l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger;
          m_lastUserMode = l_tServiceSetIf.data.shutdownRequestMsg.lastUserMode;

          // Notify services ShutDownTrigger the FrameworkunifiedOnStop, if dataResetMode is configured
          // When using FastSleep, be aware that it may be overwritten here
          switch (m_DataResetMode) {
          case e_SS_SM_DATA_RESET_MODE_FACTORY:
            m_shutdownTrigger = epssdmsdtFACTORY_DATA_RESET;
            break;
          case e_SS_SM_DATA_RESET_MODE_USER:
            m_shutdownTrigger = epssdmsdtUSER_DATA_RESET;
            break;
          default:
            break;
          }

          if (isImmShutdown) {
            m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER]);

            // Do not use m_shutdownTrigger because it is updated on DataReset
            switch (l_tServiceSetIf.data.shutdownRequestMsg.shutdownTrigger) {
            case epssdmsdtGENERIC_ERROR_RESET:
            case epssdmsdtFATAL_ERROR_RESET:
              CALL_AND_LOG_STATUS((*m_pfStopCompleteHandler)(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
              break;
            default:
              FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
                  " Warning: Received a Shutdown command while in "
                  "the '%s' state - returning Shutdown "
                  "Response msg now",
                  GetStr(m_SMCurrentState).c_str());

              CALL_AND_LOG_STATUS(SendShutdownResponseMessage(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
              break;
            }

          } else {
            InitiateAllGroupsShutdown(hApp);
          }
        }
        break;

      case SS_SM_APPS_STOPPING_AT__CWORD56__REQ:
      case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ:
      case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ:
      case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ:
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
            " Warning: Received a Shutdown command while already in "
            "the '%s' state !!!",
            GetStr(m_SMCurrentState).c_str());
        break;
      }  // End switch ( m_SMCurrentState )
      break;
    }  // End case epsumOFF | epsumON
    }  // End switch (m_lastUserMode )
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnShutdownModulesRequest( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SendSystemModeInfoResponse
/// send SystemModeInfo to
/// _CWORD56_ ( via Power Service-> PSMShadow ) as an IPC 'Start Notification'
/// message, informing _CWORD56_ of the startup state of the _CWORD102_.
///
/// \param [in] HANDLE hApp
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::SendSystemModeInfoResponse(HANDLE hApp, EPWR_STARTUP_STAGE_TYPE f_startupStage) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  SystemModeInfo l_SystemModeInfo;

  memcpy(&l_SystemModeInfo, &m_SystemModeInfo, sizeof(l_SystemModeInfo));

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "stage:%d", f_startupStage);
  l_SystemModeInfo.startupStage = f_startupStage;

  l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_SYSTEM_MODE_INFO_RSPN,
      sizeof(l_SystemModeInfo), (PVOID) & l_SystemModeInfo);

  if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 4: NSFW error case.
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: SendSystemModeInfoResponse(%s) errored: 0x%X",
        GetStr(l_SystemModeInfo.startupStage).c_str(), l_eStatus);
  } else {
    // LCOV_EXCL_START 4: NSFW error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
        " SendSystemModeInfoResponse(%s) successful",
        GetStr(l_SystemModeInfo.startupStage).c_str());
    // LCOV_EXCL_STOP
  }

  LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_SM_SYSTEM_MODE_INFO_RSPN)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::SendSystemModeInfoResponse( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnSystemModeInfoRequest
/// Handle System Mode Info request. Send System Mode Info read from NVM
///
/// \param [in] HANDLE hApp
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnSystemModeInfoRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
  m_isRcvModeInfo = TRUE;

  SetCmdHist("SS_SM_SYSTEM_MODE_INFO_REQ", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp));

  if (m_SystemModeInfo.startupStage == epssusfINVALID) {
    // Transitioning to SYSTEM_SERVICES_STARTED if startupStage == INVALID
    m_SystemModeInfo.startupStage = epssusSYSTEM_SERVICES_STARTED;
  }

  l_eStatus = SendSystemModeInfoResponse(hApp, epssusSYSTEM_SERVICES_STARTED);
  LOG_STATUS(l_eStatus, "SendSystemModeInfoResponse()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  if (TRUE == m_isRstPending) {
    ESMCpuResetReason l_resetReason = m_rstPendingInfo.resetReason;
    std::string l_messageStr = m_rstPendingInfo.messageStr;

    m_isRstPending = FALSE;
    m_rstPendingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_INVALID;
    memset(m_rstPendingInfo.messageStr, 0, sizeof(m_rstPendingInfo.messageStr));

    l_eStatus = PerformCpuReset(hApp, l_resetReason, l_messageStr);
    LOG_STATUS(l_eStatus, "PerformCpuReset()");  // LCOV_EXCL_BR_LINE 6: Because it is executed only once and cannot see all branches
  }

  if (m_SystemModeInfo.startupStage == epssusALL_SERVICES_LAUNCHED) {
    // If startupStage == ALL_SERVICES_LAUNCHED
    // Notify here because Launch of all SVCs is completed first.
    l_eStatus = SendSystemModeInfoResponse(hApp, epssusALL_SERVICES_LAUNCHED);
    LOG_STATUS(l_eStatus, "SendSystemModeInfoResponse()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnSystemModeInfoRequest( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnInitCompReportCallback
/// Handle InitComp report.
///
/// \param [in] HANDLE hApp
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnInitCompReportCallback(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("SS_SM_INITCOMP_REP", m__CWORD56_CmdHist, m__CWORD56_HistIter, FrameworkunifiedGetMsgSrc(hApp));

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnInitCompReportCallback( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup have_all_services_start_completed
///  check if state of all services is MODULE_STATE_STARTED
///
/// \param [in]
///
///
/// \return BOOL
/// Success ==> TRUE
/// Failure ==> FALSE
///////////////////////////////////////////////////////////////////////////////
BOOL CSystemManager::have_all_services_start_completed(const SMModuleState f_moduleState) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL bIsStartCompleted = TRUE;
  SMModuleState l_failedState = MODULE_STATE_INVALID;

  switch (f_moduleState) {
    case MODULE_STATE_STARTED:
      l_failedState = MODULE_STATE_START_FAILED;
      break;
    case MODULE_STATE_STARTED_PRE:
      l_failedState = MODULE_STATE_START_PRE_FAILED;
      break;
    case MODULE_STATE_STOPPED_PRE:
      l_failedState = MODULE_STATE_STOP_PRE_FAILED;
      break;
    case MODULE_STATE_STARTED_BACKGROUND:
      l_failedState = MODULE_STATE_START_BACKGROUND_FAILED;
      break;
    case MODULE_STATE_STOPPED_BACKGROUND:
      l_failedState = MODULE_STATE_STOP_BACKGROUND_FAILED;
      break;
    default:
      bIsStartCompleted = FALSE;
      break;
  }
  if (l_failedState != MODULE_STATE_INVALID) {
    GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
    for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) {
      ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
      for (; l_ModuleListIterator != l_GroupIterator->second.modules.end(); l_ModuleListIterator++) {
        if ((l_ModuleListIterator->is_start_required == TRUE)
            && ((l_ModuleListIterator->IsModuleState(f_moduleState) == FALSE)  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
                && (l_ModuleListIterator->IsModuleState(MODULE_STATE_SKIPPED) == FALSE)  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
                && (l_ModuleListIterator->IsModuleState(l_failedState) == FALSE))) {  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
          // Allow _SKIPPED/START_FAILED for StartRespMonitor conditions
          bIsStartCompleted = FALSE;
          break;
        }
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return bIsStartCompleted;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup is_critical_service_stopped
///
///
/// \param [in]
///
///
/// \return BOOL
/// Success ==> TRUE
/// Failure ==> FALSE
///////////////////////////////////////////////////////////////////////////////
BOOL CSystemManager::is_service_shutdown_ready(ModuleLaunchListIter &modIte) {
  if (((modIte->shutdown_critical && modIte->is_start_required)
      || (modIte->name == FRAMEWORKUNIFIED_NS_NPSERVICE))
      && modIte->IsModuleState(MODULE_STATE_STOPPED) == FALSE) {
    // Not shutdown_ready if NPP or shutdown_critical services are not STOPPED.
    return FALSE;
  }
  return TRUE;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup have_critical_services_stopped
///  check if state of all critical services is MODULE_STATE_STOPPED
///
/// \param [in]
///
///
/// \return BOOL
/// Success ==> TRUE
/// Failure ==> FALSE
///////////////////////////////////////////////////////////////////////////////
BOOL CSystemManager::have_critical_services_stopped() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  uint numStoppingModules = 0;

  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
  for (; l_GroupIterator != m_MapProclaunchGrps.end(); l_GroupIterator++) {
    ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
    for (; l_ModuleListIterator != l_GroupIterator->second.modules.end(); l_ModuleListIterator++) {
      if (l_ModuleListIterator->IsModuleState(MODULE_STATE_STOP_SENT)
          && l_ModuleListIterator->shutdown_critical) {
        numStoppingModules++;
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (numStoppingModules == 0);
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup perform_force_reset
///
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::perform_force_reset(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "+");

  // Since initialization must be performed by the PSMs during FactReset, do not NaviDet them as much as possible.
  if (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode) {
    fprintf(stderr,
        "SS_SysManager/%s/NO NAVIDET!! but SendShutdownComp for FactReset\n", __FUNCTION__);
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        "NO NAVIDET!! but SendShutdownComp for FactReset");
    CALL_AND_LOG_STATUS(send_shutdown_complete_response(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    sleep(60);
  } else if (access("/nv/BS/ss/system_manager/rwdata/ss_debug", F_OK) == 0) {
    fprintf(stderr, "SS_SysManager/%s/NO NAVIDET!! but SendShutdownComp\n", __FUNCTION__);
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NO NAVIDET!! but SendShutdownComp");
    CALL_AND_LOG_STATUS(send_shutdown_complete_response(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    sleep(60);
  }

  fflush(stderr);
  usleep(100 * 1000);

  if (0 == PsmNaviResetPower(hApp, m_ResetFactor)) {  // LCOV_EXCL_BR_LINE 200: power_hal if, can not to be error.
    SS_ASERT_ERRNO(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    usleep(300 * 1000);
    fprintf(stderr, "SS_SysManager/%s/Error: Not Reset !!!\n", __FUNCTION__);
    l_eStatus = eFrameworkunifiedStatusFail;
  }

  send_shutdown_complete_response(hApp);  // Try to NAVI_RESET even if ignored

  FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "-");
  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
/// \ingroup send_shutdown_complete_response
///
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::send_shutdown_complete_response(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  CALL_AND_LOG_STATUS(ResetModulesStateToConnected(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  SMSetState(hApp, SS_SM_APPS_LAUNCHED_READY_TO_START);
  // m_ActiveGroupId = SS_SM_INITIAL_GROUP;

  // all the modules have stopped, send Shutdown Response to Power Service
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      " All critical services have stopped, Active Group ID is now %d",
      m_SystemStarter.get_id());
#if 1
    CALL_AND_LOG_STATUS(SendShutdownResponseMessage(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
#else
  //
  // Normal, production flow is to call SendShutdownResponseMessage(), which
  // sends the Shutdown Response message to the _CWORD56_, causing the _CWORD56_ to
  // remove power from the _CWORD102_ before queued-up FRAMEWORKUNIFIEDLOG messages can be  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  // processed by SS_LoggerService.
  //
  // Optional development flow is to NOT call SendShutdownResponseMessage(),
  // thus giving the _CWORD102_ time to process its FRAMEWORKUNIFIEDLOG messages. Since this is an  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  // abnormal, 'bad' condition of NOT sending a Shutdown Response message to
  // the _CWORD56_, be very obvious about this state by displaying both
  // compile-time and run-time warning messages.
  //
#warning NOT calling SendShutdownResponseMessage(hApp) !
  FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      " Warning: SendShutdownResponseMessage( hApp ) "
      "#def'f out; ShutdownResponse NOT sent to _CWORD56_");
#endif

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
///
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::SendShutdownResponseMessage(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession,  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      SS_SM_SHUTDOWN_MODULES_CMPL_RSPN, 0, (PVOID) NULL);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
      "FrameworkunifiedSendMsg(PowerService,SS_SM_SHUTDOWN_MODULES_CMPL_RSPN)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::SendShutdownResponseMessage( HANDLE hApp )


PsmFactorT CSystemManager::GetResetFactor(PCSTR f_module_name, BOOL f_user_reset) {
  PsmFactorT  l_reset_factor = PSM_FACTOR_NONE;
  EFrameworkunifiedStatus l_eStatus;
  ModuleLaunchListIter l_moduleIter;
  l_eStatus = GetModuleIterator(f_module_name, l_moduleIter);  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    LOG_ERROR("GetModuleIterator()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    l_reset_factor = GetResetFactor(l_moduleIter, f_user_reset);
  }
  return l_reset_factor;
}   // End of PsmFactorT CSystemManager::GetResetFactor(PCSTR f_module_name)


PsmFactorT CSystemManager::GetResetFactor(const ModuleLaunchListIter f_module_iter, BOOL f_user_reset) {
  PsmFactorT  l_reset_factor;
  if (f_module_iter->IsAGLUnit() == TRUE) {
    if (f_module_iter->IsAGLResetHistoryDisable() == TRUE) {
      l_reset_factor = PSM_FACTOR_AGL;
    } else {
      l_reset_factor = PSM_FACTOR_AGL_WITH_HISTORY;
    }
  } else {
    if (f_module_iter->IsNonAGLResetHistoryDisable() == TRUE) {
      l_reset_factor = PSM_FACTOR_TIER1;
    } else {
      l_reset_factor = PSM_FACTOR_TIER1_WITH_HISTORY;
    }
  }

  if (f_user_reset == TRUE) {
    if ((l_reset_factor == PSM_FACTOR_AGL) || (l_reset_factor == PSM_FACTOR_TIER1)) {
      l_reset_factor = PSM_FACTOR_USER;
    } else {
      l_reset_factor = PSM_FACTOR_USER_WITH_HISTORY;
    }
  }
  return l_reset_factor;
}   // End of PsmFactorT GetResetFactor(ModuleLaunchListIter & f_module_iter)
///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnClientStopMonitorTimerExpiry
///
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnClientStopMonitorTimerExpiry(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from group %d", m_SystemStarter.get_id());

  SetCmdHist("SM_TIMER_CLIENT_STOP_MONITOR", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  if ((m_SMCurrentState == SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ)
      || (m_SMCurrentState == SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ)
      || m_SystemStarter.get_id() <= SS_SM_THIRD_GROUP) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: StopCompTimeout:gid:%d", m_SystemStarter.get_id());
    fprintf(stderr, "SS_SysManager/%s/Error: StopCompTimeout:gid:%d\n", __FUNCTION__, m_SystemStarter.get_id());

    for (GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
        l_GroupIterator != m_MapProclaunchGrps.end();
        l_GroupIterator++) {
      for (ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
          l_ModuleListIterator != l_GroupIterator->second.modules.end();
          l_ModuleListIterator++) {
        if (l_ModuleListIterator->group_id >= m_SystemStarter.get_id()
            && is_service_shutdown_ready(l_ModuleListIterator) == FALSE) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s", l_ModuleListIterator->name.c_str());
          fprintf(stderr, "SS_SysManager/%s/Error: %s\n", __FUNCTION__, l_ModuleListIterator->name.c_str());  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        }
      }
    }

    if (!m_SystemStarter.is_begin()) {
      // Continue termination processing to perform BackupManager termination processing.
      m_SystemStarter.decrement_id();
      check_all_groups_have_stopped(hApp);
    } else {
      // DEAD CODE
      fprintf(stderr, "SS_SysManager/%s:SVC stop timeout\n", __FUNCTION__);
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " SVC stop timeout");
      l_eStatus = CallStopCompleteHandler(hApp);
      LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "CallStopCompleteHandler( hApp )");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
    }
  } else {
    // The current m_ActiveGroupId group just timed out. If possible,
    // decrement it, and then see if there are more groups to send
    // stop requests to.
    if (!m_SystemStarter.is_begin()) {
      m_SystemStarter.decrement_id();
    }
    check_all_groups_have_stopped(hApp);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnClientStopMonitorTimerExpiry( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup check_all_groups_have_stopped
/// check that all the groups has stopped
///
/// \param [in]
///
///
/// \return VOID
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::check_all_groups_have_stopped(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  UI_32 l_ActiveGroupId = m_SystemStarter.get_id();
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      " m_SystemStarter.get_id() is %d, 'm_NPPStopSent' is '%s'"
      , m_SystemStarter.get_id(), GetStr(m_NPPStopSent).c_str());

  // send stop to next group in reverse order
//  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_NPPStopSent is %s", GetStr(m_NPPStopSent).c_str());  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  if (!m_NPPStopSent) {
    l_eStatus = stop_all_modules_of_group(hApp);
    if (eFrameworkunifiedStatusOK != l_eStatus) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: stop_all_modules_of_group(%d) errored: %d/'%s'",
          l_ActiveGroupId, l_eStatus, GetStr(l_eStatus).c_str());
    }
  } else {  // (m_ActiveGroupId < SS_SM_INITIAL_GROUP)
    BOOL l_bIsDetectTimeout;

    if ((l_bIsDetectTimeout = !have_critical_services_stopped())) {
      // If the Critical service is not terminated even when the final GROUP is completed, DUMP the applicable service and issue NAVI_DET.
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " FinalCriticalCheck");
      fprintf(stderr, "SS_SysManager/%s:FinalCriticalCheck\n", __FUNCTION__);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)

      for (GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
          l_GroupIterator != m_MapProclaunchGrps.end();
          l_GroupIterator++) {
        for (ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();
            l_ModuleListIterator != l_GroupIterator->second.modules.end();
            l_ModuleListIterator++) {
          if (is_service_shutdown_ready(l_ModuleListIterator) == FALSE) {
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s",
                l_ModuleListIterator->name.c_str());
            fprintf(stderr, "SS_SysManager/%s/Error: %s\n",  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
                __FUNCTION__,
                l_ModuleListIterator->name.c_str());  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
          }
        }
      }
      fprintf(stderr, "SS_SysManager/%s:critical service no stop\n", __FUNCTION__);
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "critical service no stop");
    }

    CALL_AND_LOG_STATUS(CallStopCompleteHandler(hApp, l_bIsDetectTimeout));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

    // In PastModel002, there was a transition to WAITING_FOR_CRITICAL_APPS in the following processing, but in _CWORD71_,
    // the transition to WAITING_FOR_CRITICAL_APPS was eliminated by revising the termination processing.
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return;
}  // End of VOID CSystemManager::check_all_groups_have_stopped( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup MarkModuleStateStopped
/// Sets Module State to STOP COMPLETE
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnNppStopComplete
/// Npp Stop Complete complete Response\Ack Handlers
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnNppStopComplete(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("NPS_NPP_STOP_ACK", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  char l_cBuf[100];
  snprintf(l_cBuf, sizeof(l_cBuf), "ProcessModuleStopCompleteResponse(%s)", FRAMEWORKUNIFIED_NS_NPSERVICE);
  l_eStatus = ProcessModuleStopCompleteResponse(hApp, FRAMEWORKUNIFIED_NS_NPSERVICE);
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eFrameworkunifiedStatusOK;
}

EFrameworkunifiedStatus CSystemManager::GetModuleIterator(PCSTR f_moduleName, ModuleLaunchListIter &f_moduleIter) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  ModuleLaunchListIter l_moduleIter;
//  static int l_numTimesEntered = 0 ;
//  l_numTimesEntered++ ;
//  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
//       , " NTE %d: Looking for %s"
//       , l_numTimesEntered
//       , f_moduleName);

  BOOL l_bIsFound = FALSE;
  for (GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.begin();
      !l_bIsFound && l_GroupIter != m_MapProclaunchGrps.end();
      l_GroupIter++) {
//    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
//       , " NTE %d: Checking group %d/%s"
//       , l_numTimesEntered
//       , l_GroupIter->second.id
//       , l_GroupIter->second.name.c_str());

    for (l_moduleIter = l_GroupIter->second.modules.begin();
        !l_bIsFound && (l_moduleIter != l_GroupIter->second.modules.end());
        l_moduleIter++) {
//    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
//       , " NTE %d: Checking PCSTR '%s' against std::string '%s': %d, %s"
//       , l_numTimesEntered
//       , f_moduleName
//       , l_moduleIter->name.c_str()
//       , strcmp(l_moduleIter->name.c_str(), f_moduleName)
//       , (0 == strcmp(l_moduleIter->name.c_str(), f_moduleName) ? "True" : "False"));

      l_bIsFound =
          (0 == strcmp(l_moduleIter->name.c_str(), f_moduleName));
      if (l_bIsFound) {
        f_moduleIter = l_moduleIter;
//        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
////            " NTE %d:"
//               " '%s' is in group %d/%s"
////           , l_numTimesEntered
//           , f_moduleIter->name.c_str()
//           , l_GroupIter->second.id
//           , l_GroupIter->second.name.c_str());
        l_eStatus = eFrameworkunifiedStatusOK;
      }
    }
  }

  if (!l_bIsFound) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
//      " NTE %d:"
        " Error: '%s' is not in group map 'm_MapProclaunchGrps'"
//       , l_numTimesEntered
        , f_moduleName);
    if (0 != strcmp(f_moduleName, SERVICE_SYSMANAGER)) {
      SysMgrConfiguration m_launchConfig;
      m_launchConfig.PrintAllInfo(m_MapProclaunchGrps);
    }
    l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::GetModuleIterator( PCSTR f_moduleName

BOOL CSystemManager::IsGroupStarted(UI_32 f_groupID) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL l_bIsStarted = TRUE;

  GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.find(f_groupID);
  if (l_GroupIter == m_MapProclaunchGrps.end()) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Group Map Empty; was looking for group %d", f_groupID);
  } else {
    ModuleLaunchListIter l_ModuleListIter = l_GroupIter->second.modules.begin();
    const SMModuleState l_dest_state = InProgressStateToState();  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
    if (l_dest_state != MODULE_STATE_INVALID) {
      for (; l_ModuleListIter != l_GroupIter->second.modules.end(); l_ModuleListIter++) {
        if (((l_ModuleListIter->IsModuleState(l_dest_state) == FALSE)  // LCOV_EXCL_BR_START 11:Gcov constraints (because exception-handling routes are automatically generated)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_FAILED) == FALSE)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_PRE_FAILED) == FALSE)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_PRE_FAILED) == FALSE)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_START_BACKGROUND_FAILED) == FALSE)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_FAILED) == FALSE)
            && (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_FAILED) == FALSE))
            // LCOV_EXCL_BR_STOP 11:Gcov constraints (because exception-handling routes are automatically generated)
            || ((l_ModuleListIter->is_start_required == TRUE)
                // LCOV_EXCL_START 6: Because the value cannot be stored to make the condition true
                && ((l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHING) == TRUE)
                    || (l_ModuleListIter->IsModuleState(MODULE_STATE_CONNECTED) == TRUE)
                    || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED) == TRUE)))) {
                // LCOV_EXCL_STOP 6: Because the value cannot be stored to make the condition true
          l_bIsStarted = FALSE;
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " No: '%s' in group %d/%s is '%s'", l_ModuleListIter->name.c_str(),
                 l_GroupIter->second.id, l_GroupIter->second.name.c_str(),
                 l_ModuleListIter->ModuleStateStr().c_str());
          break;
        }
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_bIsStarted;
}  // End of BOOL CSystemManager::IsGroupStarted(UI_32 f_groupId)

BOOL CSystemManager::IsGroupStopped(UI_32 f_groupID) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL l_bIsStopped = TRUE;
  ModuleLaunchListIter l_ModuleListIter;

  GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.find(f_groupID);
  if (l_GroupIter == m_MapProclaunchGrps.end()) {
    FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
        " Warning: Group Map Empty; was looking for group %d",
        f_groupID);
  } else {
    for (l_ModuleListIter = l_GroupIter->second.modules.begin();
        l_bIsStopped
            && l_ModuleListIter != l_GroupIter->second.modules.end();
        l_ModuleListIter++) {
      if (l_ModuleListIter->IsModuleState(MODULE_STATE_STOP_SENT)) {
        l_bIsStopped = FALSE;
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_bIsStopped;
}  // End of BOOL CSystemManager::IsGroupStopped(UI_32 f_groupId)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnStopComplete
/// Shutdown complete Response\Ack Handlers
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusErrOther;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)

  PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);

  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", l_moduleName);
  SetCmdHist("SS_SM_STOP_COMPL_RSPN", m_SMCmdHist, m_SMHistIter, l_moduleName);

  char l_cBuf[100];
  snprintf(l_cBuf, sizeof(l_cBuf), "ProcessModuleStopCompleteResponse(%s)", l_moduleName);
  l_eStatus = ProcessModuleStopCompleteResponse(hApp, l_moduleName);
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteResponse( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnGetStartExtInfo
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnGetStartExtInfo(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  T_SS_SM_START_ExtDataStructType l_extInfo = { 0 };

  SS_STATIC_ASERT(sizeof(T_SS_SM_START_ExtDataStructType) == SS_SM_START_EXT_INFO_SIZE);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ ");

  SetCmdHist("SS_SM_GET_START_EXT_INFO", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  l_extInfo.isProgUpdated =
      (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) ? TRUE : FALSE;
  l_extInfo.isMapUpdated =
      (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_MAP_UPDATED) ? TRUE : FALSE;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  l_extInfo.isMapDiffUpdated =
      (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_MAPDIFF_UPDATED) ? TRUE : FALSE;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  ModuleLaunchListIter l_ModuleListIter;

  l_eStatus = GetModuleIterator(FrameworkunifiedGetMsgSrc(hApp), l_ModuleListIter);
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s not found", FrameworkunifiedGetMsgSrc(hApp));
  } else {
    switch (l_ModuleListIter->relaunch_status) {
    case NotRelaunched:
      l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_NONE;
      break;
    case RelaunchSafe:
      // LCOV_EXCL_START 6: Because the applicable variable cannot be changed from the external API (only evaluated by the initial value)
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_SAFE;
      break;
    case RelaunchErr:
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_ERR;
      break;
    default:
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      l_extInfo.relaunchStatus = e_SS_SM_RELAUNCH_STATUS_NONE;
      break;
      // LCOV_EXCL_STOP
    }
  }

  // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData()
  // because this request is sent by FrameworkunifiedInvokeSync()
  l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_extInfo, sizeof(l_extInfo));
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnGetStartExtInfo( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnGetStopExtInfo
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnGetStopExtInfo(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  T_SS_SM_STOP_ExtDataStructType l_extInfo = { 0 };

  SS_STATIC_ASERT(sizeof(T_SS_SM_STOP_ExtDataStructType) == SS_SM_STOP_EXT_INFO_SIZE);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ ");

  SetCmdHist("SS_SM_GET_STOP_EXT_INFO", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  l_extInfo.isProgUpdated =
      (m_ProgUpdateState & SS_SM_PROG_UPDATE_STATE_UPDATED) ? TRUE : FALSE;

  // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData()
  // because this request is sent by FrameworkunifiedInvokeSync()
  l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_extInfo, sizeof(l_extInfo));
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnGetStopExtInfo( HANDLE hApp )

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnModuleStopCompleteNotification
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnModuleStopCompleteNotification(HANDLE hApp) {  // LCOV_EXCL_START 6: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  EFrameworkunifiedStatus l_eStatus;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+ ");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  ShutdownComplete l_shutdownNotif;   /// \file   frameworkunified_framework_types.h
  // ReadMsg():                                                      *
  //   Check hApp ptr, msg size, msg reception, read msg if all ok.  *
  //   Report any errors found.                                      *
  //                                                                 *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ShutdownComplete > (hApp, l_shutdownNotif))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    PCSTR l_moduleName = l_shutdownNotif.cServiceName;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
        " '%s' 'Shutdown Complete Status' is 0x%X", l_moduleName,
        l_shutdownNotif.eShutdownCompleteStatus);

    char l_cBuf[100];
    snprintf(l_cBuf, sizeof(l_cBuf),
        "ProcessModuleStopCompleteResponse(%s)", l_moduleName);
    l_eStatus = ProcessModuleStopCompleteResponse(hApp, l_moduleName);
    LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::onmodulestopcompletenotification( HANDLE hApp )
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CSystemManager::ProcessModuleStopCompleteResponse(HANDLE hApp, PCSTR f_moduleName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  ModuleLaunchListIter l_ModuleListIter;
  l_eStatus = GetModuleIterator(f_moduleName, l_ModuleListIter);
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Module %s not found in Group Launch Map", f_moduleName);
  } else {
    switch (m_SMCurrentState) {
    case SS_SM_READY_TO_LAUNCH_APP:
    case SS_SM_APPS_LAUNCH_IN_PROGRESS:
    case SS_SM_APPS_LAUNCHED_READY_TO_START:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: Received from client while in "
          "the '%s' state !!!",
          GetStr(m_SMCurrentState).c_str());
      l_eStatus = eFrameworkunifiedStatusErrOther;
      break;

    case SS_SM_APPS_STOPPING_AT__CWORD56__REQ:
    case SS_SM_APPS_STOPPING_AT_INTERNAL_REQ:
    case SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ:
    case SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ:
      if (m_SystemStarter.get_id() == SS_SM_THIRD_GROUP) {
        // Execute shutdown_critical services termination synchronization prior to CoreModule(backupManager termination processing
        l_ModuleListIter->SetModuleState(MODULE_STATE_STOPPED);
        if (have_critical_services_stopped()) {  // Transition after all critical services have ended
          ProcessGroupOnModuleStopResponse(hApp, m_SystemStarter.get_id());
        }
      } else {
        l_eStatus = ModuleCompleteResponse(hApp, l_ModuleListIter,
                MODULE_STATE_STOPPED,
                (SysMgrCbType3<CSystemManager,
                    &CSystemManager::IsGroupStopped>),
                (SysMgrCbType2<CSystemManager,
                    &CSystemManager::ProcessGroupOnModuleStopResponse>),
                "stop");
      }
      break;

    case SS_SM_APPS_START_COMPLETE:
    case SS_SM_APPS_START_IN_PROGRESS:
    case SS_SM_APPS_PRE_RUN_COMPLETE:
    case SS_SM_APPS_PRE_START_IN_PROGRESS:
    case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
    case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:
    case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
    case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: Received from client while in "
          "the '%s' state !!!",
          GetStr(m_SMCurrentState).c_str());
      l_eStatus = eFrameworkunifiedStatusErrOther;
      break;
    }  // End switch ( m_SMCurrentState )
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ProcessModuleStopCompleteResponse(

EFrameworkunifiedStatus CSystemManager::ProcessGroupOnModuleStopResponse(HANDLE hApp, UI_32 f_groupID) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  UI_32 l_ActiveGroupId = m_SystemStarter.get_id();

  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR]);

  if (f_groupID != l_ActiveGroupId) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
        " Group %d stop complete, but m_SystemStarter.get_id() is %d",
        f_groupID
        // , m_ActiveGroupId);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
        , l_ActiveGroupId);
  } else {
    if (!m_SystemStarter.is_begin()) {
      m_SystemStarter.decrement_id();
    }
    check_all_groups_have_stopped(hApp);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ProcessGroupOnModuleStopResponse( HANDLE hApp

///////////////////////////////////////////////////////////////////////////////
/// \ingroup stop_all_modules_of_group
/// Send SS_SM_STOP to all modules of the given group
///
/// \param [in]
///
///
/// \return VOID
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::stop_all_modules_of_group(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  ModuleLaunchList::reverse_iterator l_revIter;

  UI_32 l_uiMaxGroupWaitTime_sec = 0;
  UI_32 l_uiMaxGroupWaitTime_msec = 0;
  UI_32 l_uiModuleWaitTime = 0;

  // GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(m_ActiveGroupId);
  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(m_SystemStarter.get_id());
  if (l_GroupIterator == m_MapProclaunchGrps.end()) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Group %d not found; 'm_MapProclaunchGrps' is empty"
        //, m_ActiveGroupId);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
        , m_SystemStarter.get_id());
    l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
  } else {
    int l_numModulesMessaged = 0;
    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopReq grp:%d", m_SystemStarter.get_id());

    T_SS_SM_STOP_DataStructType l_SM_STOP_Struct;
    l_SM_STOP_Struct.shutdownTrigger = m_shutdownTrigger;
    l_SM_STOP_Struct.lastUserMode = m_lastUserMode;

    for (l_revIter = l_GroupIterator->second.modules.rbegin();
        l_revIter != l_GroupIterator->second.modules.rend();
        l_revIter++) {
      // LCOV_EXCL_BR_START 11: Excluded due to gcov constraints (others)
      if ((l_revIter->IsModuleState(MODULE_STATE_START_SENT) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STARTED) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_START_PRE_SENT) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STARTED_PRE) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STOP_PRE_SENT) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STOPPED_PRE) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_START_BACKGROUND_SENT) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STARTED_BACKGROUND) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STOP_BACKGROUND_SENT) == TRUE)
          || (l_revIter->IsModuleState(MODULE_STATE_STOPPED_BACKGROUND) == TRUE)) {
        // LCOV_EXCL_BR_STOP 11: Excluded due to gcov constraints (others)
        if (FRAMEWORKUNIFIED_NS_NPSERVICE == l_revIter->name) {
          if (epssdmsdtFACTORY_DATA_RESET == m_shutdownTrigger) {
            CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedDataResetShutdown, eFrameworkunifiedUserData | eFrameworkunifiedFactoryData));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          } else if (epssdmsdtUSER_DATA_RESET == m_shutdownTrigger) {
            CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedDataResetShutdown, eFrameworkunifiedUserData));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          } else if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) {
            CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedQuickShutdown));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          } else {
            CALL_AND_LOG_STATUS(FrameworkunifiedSendStopToNSNPP(hApp, eFrameworkunifiedNormalShutdown));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          }

          if (eFrameworkunifiedStatusOK != l_eStatus) {
            l_revIter->SetModuleState(MODULE_STATE_STOP_FAILED);
          } else {
            l_revIter->SetModuleState(MODULE_STATE_STOP_SENT);
            l_numModulesMessaged++;
          }

          m_NPPStopSent = TRUE;
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " m_NPPStopSent is %s", GetStr(m_NPPStopSent).c_str());  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
        // End else if ( FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIter->name )
        } else {
          l_eStatus = l_revIter->SendMsgAndUpdateState(&l_SM_STOP_Struct);
          LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "l_revIter->SendMsgAndUpdateState(&l_SM_STOP_Struct)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
          if (eFrameworkunifiedStatusOK == l_eStatus) {
            if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) {
              l_uiModuleWaitTime = l_revIter->fast_shutdown_wait_time;

            } else {
              l_uiModuleWaitTime = l_revIter->shutdown_wait_time;
            }
            if (l_uiModuleWaitTime > l_uiMaxGroupWaitTime_sec) {
              l_uiMaxGroupWaitTime_sec = l_uiModuleWaitTime;
            }
            l_numModulesMessaged++;
          }
        }  // End if MODULE_STATE_STARTED || MODULE_STATE_START_SENT
      } else if (l_revIter->IsModuleState(MODULE_STATE_INVALID)
          && FRAMEWORKUNIFIED_NS_NPSERVICE == l_revIter->name) {
        m_NPPStopSent = TRUE;
        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopNotSent:%s is INVALID", FRAMEWORKUNIFIED_NS_NPSERVICE);
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopNotSent:%s is %s",
            l_revIter->name.c_str(),
            l_revIter->ModuleStateStr().c_str());
      }
    }

    if (0 == l_numModulesMessaged) {
      LogGroupModulesState(m_SystemStarter.get_id()  // m_ActiveGroupId  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
          , " Warning: NO modules were sent SS_SM_STOP");

      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopComp grp:%d", l_GroupIterator->second.id);

      if (m_SystemStarter.get_id() > SS_SM_INITIAL_GROUP) {
        m_SystemStarter.decrement_id();
        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " m_ActiveGroupId is now %d", m_SystemStarter.get_id());

        check_all_groups_have_stopped(hApp);
      }
    } else {
      if (epssdmsdtFAST_SLEEP_MODE == m_shutdownTrigger) {
        // fast shutdown wait time always comes in milli seconds
        UI_32 l_uiTotalWaitTime = l_uiMaxGroupWaitTime_sec;
        l_uiMaxGroupWaitTime_sec = l_uiTotalWaitTime / 1000;
        l_uiMaxGroupWaitTime_msec = l_uiTotalWaitTime % 1000;
      } else {
        // Other types of shutdown except fast shutdown always comes in seconds.
        l_uiMaxGroupWaitTime_msec = 0;
      }

      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "StopTimer grp:%d time:%d.%d",
          m_SystemStarter.get_id(), l_uiMaxGroupWaitTime_sec,
          l_uiMaxGroupWaitTime_msec);
      m_GroupLaunchTimer->StartTimerMulti(
          m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR],
          l_uiMaxGroupWaitTime_sec, l_uiMaxGroupWaitTime_msec, 0, 0,
          m_SystemStarter.get_id());
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of VOID CSystemManager::stop_all_modules_of_group(HANDLE hApp)

EFrameworkunifiedStatus CSystemManager::ValidateUserModeMessage(HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState) {  // LCOV_EXCL_START 6: Because the condition cannot be set // NOLINT(whitespace/line_length)
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  Pwr_ServiceSetInterface tServiceSetIf;
  EPWR_USER_MODE_TYPE l_my_eUserModeState;

  // ReadMsg():                                                          *
  //   Check hApp ptr, msg size, msg reception, read msg if all ok.      *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < Pwr_ServiceSetInterface > (hApp, tServiceSetIf))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    l_my_eUserModeState = tServiceSetIf.data.user_mode.mode;
    switch (l_my_eUserModeState) {
    case epsumINVALID:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: l_eUserModeState == epsumINVALID");
      l_eStatus = eFrameworkunifiedStatusInvldParam;
      break;

    case epsumOFF:
    case epsumON:
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Validated '%s'",
          l_my_eUserModeState == epsumON ? "epsumON" : "epsumOFF");
      l_eUserModeState = l_my_eUserModeState;
      l_eStatus = eFrameworkunifiedStatusOK;
      break;

      // default:  Don't code a 'default' here - let the compiler
      // issue a warning ( set via -Wall or -Wswitch ) when the set of
      // enumerations changes - then the maintainer will
      // automagically know to update this switch statement.
    }  // End switch
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ValidateUserModeMessage( HANDLE hApp, EPWR_USER_MODE_TYPE &l_eUserModeState )
// LCOV_EXCL_STOP

//*****************************************************************************
// Next Wakeup Type Set Protocol functions                                    *
//                                                                            *
EFrameworkunifiedStatus CSystemManager::OnSetNextWakeupTypeRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  ESMNextWakeupType l_wakeupType;

  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
  SetCmdHist("SS_SM_NEXT_WAKEUP_TYPE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ESMNextWakeupType > (hApp, l_wakeupType))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    switch (l_wakeupType) {
    case e_SS_SM_NEXT_WAKEUP_TYPE_NONE:
    case e_SS_SM_NEXT_WAKEUP_TYPE_COLD:
    case e_SS_SM_NEXT_WAKEUP_TYPE_HOT:
      break;
    default:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unknown type(%d)", l_wakeupType);
      l_eStatus = eFrameworkunifiedStatusInvldParam;
    }
  }
  l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus));
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnSetNextWakeupTypeRequest( HANDLE hApp )

//                                                                            *
// End of Boot Mode Protocol functions                                        *
//*****************************************************************************


//*****************************************************************************
// Data Reset Mode Protocol functions                                         *
//                                                                            *
EFrameworkunifiedStatus CSystemManager::OnSetDataResetModeRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  ESMDataResetModeInfo l_dataResetMode;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("SS_SM_DATA_RESET_MODE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < ESMDataResetModeInfo > (hApp, l_dataResetMode))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    uint32_t tmp;
    m_DataResetMode = l_dataResetMode;
    tmp = static_cast<uint32_t>(m_DataResetMode);
    if (PowerHalSetResetInfo(AGL_DATARESET_STATE, tmp)) {  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not set AGL_DATARESET_STATE.");
      // Return error to client of system_manager.
      l_eStatus = eFrameworkunifiedStatusFail;
    }
  }
  //
  // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData()
  // because this request is sent by FrameworkunifiedInvokeSync()
  //
  l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus));
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnSetDataResetModeRequest( HANDLE hApp )

EFrameworkunifiedStatus CSystemManager::OnSetProgUpdateStateRequest(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  SMProgUpdateState l_progUpdateState;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  SetCmdHist("SS_SM_PROG_UPDATE_STATE_SET_REQ", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < SMProgUpdateState > (hApp, l_progUpdateState))) {  // LCOV_EXCL_BR_LINE 4: nsfw error
    // LCOV_EXCL_START 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else {
    m_ProgUpdateState |= l_progUpdateState;
    if (PowerHalSetResetInfo(AGL_PROGUPDATE_STATE, m_ProgUpdateState)) {  // LCOV_EXCL_BR_LINE 11:Gcov constraints (because exception-handling routes are automatically generated)
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not set AGL_PROGUPDATE_STATE.");
      // return Error to client of system_manager.
      l_eStatus = eFrameworkunifiedStatusFail;
    }
  }
  // Instead of sending Return Message, this function must call FrameworkunifiedSetSyncResponseData()
  // because this request is sent by FrameworkunifiedInvokeSync()
  l_eStatus = FrameworkunifiedSetSyncResponseData(hApp, &l_eStatus, sizeof(l_eStatus));
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedSetSyncResponseData()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnSetProgUpdateStateRequest( HANDLE hApp )

EFrameworkunifiedStatus CSystemManager::CallStopCompleteHandler(HANDLE hApp, BOOL bIsDetectTimeout /* = FALSE */) {
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;


  if (bIsDetectTimeout) {
    fprintf(stderr, "SS_SysManager/%s/State StopComplete(timeout)\n", __FUNCTION__);
  } else {
    fprintf(stderr, "SS_SysManager/%s/State StopComplete\n", __FUNCTION__);
  }

  l_eStatus = SecureChipOff();
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: SecureChipOff Failed");
  }

  l_eStatus = (*m_pfStopCompleteHandler)(hApp);

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::CallStopCompleteHandler( HANDLE hApp )


//*****************************************************************************
// Soft Reset Protocol functions                                              *
//                                                                            *
static char *get_line(const char *filepath) {
  char line[LINE_MAX];
  FILE *fp;

  if ((fp = fopen(filepath, "rb")) == NULL)
    return NULL;
  if (fgets(line, LINE_MAX, fp) == NULL) {  // LCOV_EXCL_BR_LINE 5:fgets error
    // LCOV_EXCL_START 5: fgets error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    fclose(fp);
    return NULL;
    // LCOV_EXCL_STOP
  }
  fclose(fp);

  return strdup(line);
}

EFrameworkunifiedStatus CSystemManager::PerformCpuReset(HANDLE hApp,
        ESMCpuResetReason f_eSmCpuResetReason, std::string f_messageStr) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  if (FALSE == m_isRcvModeInfo) {
    // If the condition for implementing the CpuReset request is not satisfied, keep the request.
    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Cpu Reset Pending");
    m_isRstPending = TRUE;
    m_rstPendingInfo.resetReason = f_eSmCpuResetReason;
    snprintf(m_rstPendingInfo.messageStr,
        sizeof(m_rstPendingInfo.messageStr), "%s", f_messageStr.c_str());
  } else {
    switch (f_eSmCpuResetReason) {
    case e_SS_SM_CPU_RESET_REASON_CRITICAL_ERR:
    case e_SS_SM_CPU_RESET_REASON_GENERIC_ERR:
    case e_SS_SM_CPU_RESET_REASON_DSP_ERR:
      m_isImmResetReq = TRUE;
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " will reset immediately");
      // The break is omitted because the same process as for a normal reboot is performed.
    case e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET:
      m_pfStopCompleteHandler = (SysMgrCallback<CSystemManager, &CSystemManager::perform_force_reset>);
    case e_SS_SM_CPU_RESET_REASON_NORMAL: {
        TSystemManagerCpuResetInfo l_resetInfo;

        l_resetInfo.resetReason = f_eSmCpuResetReason;
        snprintf(l_resetInfo.messageStr, SS_SM_RESET_MSG_STR_SIZE, "%s", f_messageStr.c_str());
        l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_CPU_RESET_REQ,
            sizeof(l_resetInfo), (PVOID) & l_resetInfo);
        LOG_STATUS(l_eStatus,  // LCOV_EXCL_BR_LINE 6: Because the condition cannot be set
            "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_CPU_RESET_REQ)");
      }
      break;
    case e_SS_SM_CPU_RESET_REASON_DATA_RESET: {
        ESMDataResetType l_eSmDataResetType;

        switch (m_DataResetMode) {
        case e_SS_SM_DATA_RESET_MODE_FACTORY:
          l_eSmDataResetType = e_SS_SM_DATA_RESET_TYPE_FACTORY;
          break;
        case e_SS_SM_DATA_RESET_MODE_USER:
          l_eSmDataResetType = e_SS_SM_DATA_RESET_TYPE_USER;
          l_eStatus = FrameworkunifiedBroadcastEvent(hApp, SS_SM_EVENT_USER_DATA_RESET, NULL, 0);
          LOG_STATUS(l_eStatus, "FrameworkunifiedBroadcastEvent(SS_SM_EVENT_USER_DATA_RESET)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          break;
        default:
          SS_ASERT_LOG(0, "unexpected data reset mode : %d", m_DataResetMode);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          l_eStatus = eFrameworkunifiedStatusInvldParam;
        break;
        }
        if (l_eStatus == eFrameworkunifiedStatusOK) {
          l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession,
              SS_SM_REMOTE_DATA_RESET_REQ, sizeof(l_eSmDataResetType),
              (PVOID) & l_eSmDataResetType);
          LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM_REMOTE_DATA_RESET_REQ)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        }
      }
      break;
    case e_SS_SM_CPU_RESET_REASON_INVALID:
    default:
      SS_ASERT_LOG(0, " Error: Unknown CPU reset request type: 0x%X/%d",  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          f_eSmCpuResetReason, f_eSmCpuResetReason);
      l_eStatus = eFrameworkunifiedStatusInvldParam;
      break;
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::PerformCpuReset( ESMCpuResetReason f_eSmCpuResetReason )

//*****************************************************************************
// CPU Reset Protocol functions                                               *
//                                                                            *
EFrameworkunifiedStatus CSystemManager::OnCpuResetRequest(HANDLE hApp) {  // SS_SM_CPU_RESET_REQ
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  std::string l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", l_moduleName.c_str());

  // If you implement FastSleep,
  // ShutdownTrigger of FrameworkunifiedOnStop needs to be changed to FAST_SLEEP_MODE,
  // and also MaxShutdownTime needs to be changed to CriticalAppsMaxShutdownTimeFastSleep

  try {
    TSystemManagerCpuResetInfo l_resetInfo;
    SetCmdHist("SS_SM_CPU_RESET_REQ", m_SMCmdHist, m_SMHistIter,  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        FrameworkunifiedGetMsgSrc(hApp));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < TSystemManagerCpuResetInfo > (hApp, l_resetInfo))) {
      LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    } else {
      char l_cBuf[100];
      EErrorEventType l_errorEventType;
      SMLoggingInfo l_loggingInfo;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

      l_loggingInfo.messageStr = l_resetInfo.messageStr;
      l_loggingInfo.suffixStr = l_resetInfo.suffixStr;

      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__,
          " CPU Reset Reason: '%d'/'%s' from %s",
          l_resetInfo.resetReason,
          GetStr(l_resetInfo.resetReason).c_str(),
          FrameworkunifiedGetMsgSrc(hApp));

      if (e_SS_SM_CPU_RESET_REASON_IMMRESET_NORMAL == l_resetInfo.resetReason) {
        m_isImmResetReq = TRUE;
        l_resetInfo.resetReason = e_SS_SM_CPU_RESET_REASON_NORMAL;
      }
      switch (l_resetInfo.resetReason) {
      case e_SS_SM_CPU_RESET_REASON_DATA_RESET:
        switch (m_DataResetMode) {
        case e_SS_SM_DATA_RESET_MODE_FACTORY:
        case e_SS_SM_DATA_RESET_MODE_USER:
          break;
        case e_SS_SM_DATA_RESET_MODE_NONE:
        default:
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "unexpected data reset mode : %d", m_DataResetMode);
          throw eFrameworkunifiedStatusInvldParam;
        }
      case e_SS_SM_CPU_RESET_REASON_CRITICAL_ERR:
      case e_SS_SM_CPU_RESET_REASON_GENERIC_ERR:
      case e_SS_SM_CPU_RESET_REASON_DSP_ERR:
      case e_SS_SM_CPU_RESET_REASON_NORMAL:
        l_errorEventType = eErrorEventTypeModuleInvokedResetRequest;
        l_loggingInfo.resetReason = l_resetInfo.resetReason;
        break;
      case e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET:
        // Separate ErrorEventType only for USER_FORCE_RESET, because the logs to be saved differ.
        l_errorEventType = eErrorEventTypeUserInvokedUserForceReset;
        l_loggingInfo.resetReason = e_SS_SM_CPU_RESET_REASON_USER_FORCE_RESET;
        break;
      case e_SS_SM_CPU_RESET_REASON_INVALID:
      default:
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: Unknown CPU reset request type: 0x%X/%d",
            l_resetInfo.resetReason, l_resetInfo.resetReason);
        throw eFrameworkunifiedStatusInvldParam;
      }

      l_eStatus = ErrorEventEnqueue(hApp, l_errorEventType, l_moduleName,
          eErrorEventResetTypeHard, l_loggingInfo);

      snprintf(l_cBuf, sizeof(l_cBuf), "ErrorEventEnqueue(%s)",
               GetStr(l_errorEventType).c_str());  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
    }
  } catch (EFrameworkunifiedStatus e) {
    l_eStatus = e;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
//                                                                            *
// End of CPU Reset Protocol functions                                        *
//*****************************************************************************

VOID CSystemManager::InitiateAllGroupsShutdown(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  // Prioritize safe termination sequence and do not save logs during termination
  m_errorEventQueueLocked = TRUE;

  m_MaxShutdownTime = calculate_max_shutdown_time();

  l_eStatus = FrameworkunifiedNPPublishNotification(hApp, NTFY_SSSystemMgrShutdownStarted, NULL, 0);

  SetCmdHist(NTFY_SSSystemMgrShutdownStarted, m_PubCmdHist, m_PubHistIter, "");  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
      "FrameworkunifiedNPPublishNotification(" NTFY_SSSystemMgrShutdownStarted ")");

  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER]);
  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR]);

  // Stop Heartbeat thread activity
  l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_STOP, NULL, 0);
  LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat(SS_HEARTBEAT_STOP)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  SMSetState(hApp, SS_SM_APPS_STOPPING_AT__CWORD56__REQ);

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "shutdownTrigger:%s, lastUserMode:%s",
      GetStr(m_shutdownTrigger).c_str(), GetStr(m_lastUserMode).c_str());

  fprintf(stderr,  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      "SS_SysManager/%s/State shutdownTrigger:%s, lastUserMode:%s\n",  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      __FUNCTION__, GetStr(m_shutdownTrigger).c_str(),  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      GetStr(m_lastUserMode).c_str());  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  /// Send SS_SM_STOP to all modules, starting with the m_ActiveGroupId group
  m_NPPStopSent = FALSE;
  check_all_groups_have_stopped(hApp);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return;
}  // End of EFrameworkunifiedStatus CSystemManager::InitiateAllGroupsShutdown(HANDLE hApp)

VOID CSystemManager::SendDeferMsg(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (!m_dqDeferMsg.empty()) {
    EFrameworkunifiedStatus l_eStatus;
    SM_POWER_EVENT_INFO deferMsg;

    deferMsg = m_dqDeferMsg.front();
    m_dqDeferMsg.pop();

    HANDLE hSender = McOpenSender(SERVICE_SYSMANAGER);
    if (hSender == NULL) {  // LCOV_EXCL_BR_LINE 4: nsfw error
      // LCOV_EXCL_START 4: nsfw error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: McOpenSender(SERVICE_SYSMANAGER)");
      // LCOV_EXCL_STOP
    } else {
      CALL_AND_LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
          McSend(hSender, SERVICE_POWER, deferMsg.first,
              sizeof(Pwr_ServiceSetInterface),
              (PVOID) & deferMsg.second));
      CALL_AND_LOG_STATUS_IF_ERRORED(McClose(hSender));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  return;
}  // End of VOID CSystemManager::SendDeferMsg(HANDLE hApp)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup PublishPowerOnOffNotification
/// Power Off notification handler
///
/// \param [in]
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::PublishPowerOnOffNotification(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  l_eStatus = PerformPowerOnOffUserModePublication(hApp, NTFY_SSSystemMgrPowerOnOff);

  SetCmdHist(NTFY_SSSystemMgrPowerOnOff, m_PubCmdHist, m_PubHistIter, "");
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformPowerOnOffUserModePublication()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus CSystemManager::PublishUserModeNotification(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  l_eStatus = PerformPowerOnOffUserModePublication(hApp, NTFY_SSSystemMgrUserMode);

  SetCmdHist(NTFY_SSSystemMgrUserMode, m_PubCmdHist, m_PubHistIter, "");
  LOG_STATUS_REC_HIST_IF_ERRORED(l_eStatus, "PerformPowerOnOffUserModePublication()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::PublishUserModeNotification(

EFrameworkunifiedStatus CSystemManager::PerformPowerOnOffUserModePublication(HANDLE hApp, const char * p_NotificationStr) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  char l_cBuf[500] = { 0 };

  if (m_SMConfig.UMConfig.IsUserModeNotificationABOOL) {
    BOOL l_bUuserMode(m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType]);

    snprintf(l_cBuf, sizeof(l_cBuf), "FrameworkunifiedNPPublishNotification(%s, %s)",
        p_NotificationStr, GetStr(l_bUuserMode).c_str());
    l_eStatus = FrameworkunifiedNPPublishNotification(hApp, p_NotificationStr,
        &l_bUuserMode, sizeof(l_bUuserMode));
  } else {
    T_SS_SM_UserModeOnOffNotification_Struct l_UserModeOnOffStruct(
        m_PowerType_to_SSBoolEnumMap[m_Wake.powerupType],
        m_StartUpReason, m_userModeChangeReason);

    snprintf(l_cBuf, sizeof(l_cBuf),
        "FrameworkunifiedNPPublishNotification(%s, %s, %s, %s)", p_NotificationStr,
        GetStr(l_UserModeOnOffStruct.isUserModeOn).c_str(),
        GetStr(m_StartUpReason).c_str(),
        GetStr(m_userModeChangeReason).c_str());
    l_eStatus = FrameworkunifiedNPPublishNotification(hApp, p_NotificationStr,
        &l_UserModeOnOffStruct, sizeof(l_UserModeOnOffStruct));
  }

  SetCmdHist(p_NotificationStr, m_PubCmdHist, m_PubHistIter, "");
  LOG_STATUS(l_eStatus, l_cBuf);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::PerformPowerOnOffUserModePublication(

EFrameworkunifiedStatus CSystemManager::ResetModulesStateToConnected(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  ModuleLaunchListIter l_moduleIter;
  for (GroupLaunchMapIter l_GroupIter = m_MapProclaunchGrps.begin();
      l_GroupIter != m_MapProclaunchGrps.end(); l_GroupIter++) {
    for (l_moduleIter = l_GroupIter->second.modules.begin();
        l_moduleIter != l_GroupIter->second.modules.end();
        l_moduleIter++) {
      if (l_moduleIter->name == FRAMEWORKUNIFIED_NS_NPSERVICE) {
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s ( Group %d/%s ) is %s",
            l_moduleIter->name.c_str(), l_GroupIter->second.id,
            l_GroupIter->second.name.c_str(),
            l_moduleIter->ModuleStateStr().c_str());
        l_moduleIter->SetModuleState(MODULE_STATE_STARTED);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
      // End else if ( FRAMEWORKUNIFIED_NS_NPSERVICE == l_ModuleListIter->name )
      } else {
        switch (l_moduleIter->GetModuleState()) {
        case MODULE_STATE_INVALID:
        case MODULE_STATE_SKIPPED:
        case MODULE_STATE_LAUNCHING:
        case MODULE_STATE_LAUNCHED:
        case MODULE_STATE_LAUNCH_FAILED:
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
              " %s ( Group %d/%s ) is %s, NOT setting to "
              "MODULE_STATE_CONNECTED",
              l_moduleIter->name.c_str(), l_GroupIter->second.id,
              l_GroupIter->second.name.c_str(),
              l_moduleIter->ModuleStateStr().c_str());  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
          break;

        case MODULE_STATE_STARTED:
        case MODULE_STATE_START_SENT:
        case MODULE_STATE_CONNECTED:
        case MODULE_STATE_START_FAILED:
        case MODULE_STATE_STOP_FAILED:
        case MODULE_STATE_STOP_SENT:
        case MODULE_STATE_STOPPED:
        case MODULE_STATE_START_PRE_SENT:
        case MODULE_STATE_START_PRE_FAILED:
        case MODULE_STATE_STARTED_PRE:
        case MODULE_STATE_STOP_PRE_SENT:
        case MODULE_STATE_STOP_PRE_FAILED:
        case MODULE_STATE_STOPPED_PRE:
        case MODULE_STATE_START_BACKGROUND_SENT:
        case MODULE_STATE_START_BACKGROUND_FAILED:
        case MODULE_STATE_STARTED_BACKGROUND:
        case MODULE_STATE_STOP_BACKGROUND_SENT:
        case MODULE_STATE_STOP_BACKGROUND_FAILED:
        case MODULE_STATE_STOPPED_BACKGROUND:
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s ( Group %d/%s ) is %s",
              l_moduleIter->name.c_str(), l_GroupIter->second.id,
              l_GroupIter->second.name.c_str(),
              l_moduleIter->ModuleStateStr().c_str());
          l_moduleIter->SetModuleState(MODULE_STATE_CONNECTED);
          break;
          // default:  Don't code a 'default' here - let the compiler
          // issue a warning ( set via -Wall or -Wswitch ) when the set of
          // enumerations changes - then the maintainer will
          // automagically know to update this switch statement.
        }
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::ResetModulesStateToConnected(HANDLE hApp)

EFrameworkunifiedStatus CSystemManager::On_CWORD56_HeartBeatRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  PCSTR l_senderName = FrameworkunifiedGetMsgSrc(hApp);

  SetCmdHist("SS_SM__CWORD56__HEARTBEAT_REQ", m_SMCmdHist, m_SMHistIter, l_senderName);

  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, " Received from %s", l_senderName);
  EPWR_HB_REQ_MSG_STRUCT l_hbReq;

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < EPWR_HB_REQ_MSG_STRUCT > (hApp, l_hbReq))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {

    m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE]);

    if (l_hbReq.IntervalSec > 0) {
      m_GroupLaunchTimer->StartTimer(
          m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE], 0, 0,
          l_hbReq.IntervalSec, 0);
    } else if (l_hbReq.IntervalSec == 0) {  // LCOV_EXCL_BR_LINE 8: As the condition is never false
      l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN, 0, NULL);

      LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CSystemManager::On_CWORD56_HeartBeatResponseIntervalTimerExpiry(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  SetCmdHist("SM_TIMER__CWORD56__HEARTBEAT_RESPONSE", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN, 0, NULL);

  LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(m_hPowerServiceSession, SS_SM__CWORD56__HEARTBEAT_RSPN)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

// EOF of /SS_SystemManager/src/ss_system_manager_callbacks.cpp