path: root/systemservice/system_manager/server/src/ss_system_manager.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 <native_service/cl_lock.h>
#include <native_service/cl_process.h>
#include <native_service/cl_monitor.h>

#include <native_service/frameworkunified_application.h>
#include <native_service/frameworkunified_framework_if.h>
#include <native_service/frameworkunified_multithreading.h>
#include <native_service/frameworkunified_thread_priority.h>

#include <native_service/ns_np_service_nor_persistence.h>
#include <native_service/ns_np_service_protocol.h>
#include <native_service/ns_plogger_if.h>
#include <native_service/ns_np_service_if.h>
#include <native_service/ns_backup.h>

#include <heartbeat/ss_hb_if.h>

#include <processlauncher/ProcessLauncher_if.h>
#include <processlauncher/ss_sm_process_launcher.h>
#include <processlauncher/ss_sm_process_launcher_protocol.h>

#include <system_service/ss_system_manager_conf.h>
#include <stub/ss_diag.h>

#include <system_service/ss_client_names.h>
#include <system_service/ss_heartbeat_service_protocol.h>
#include <system_service/ss_power_service_if.h>
#include <system_service/ss_power_service_notifications.h>
#include <system_service/ss_power_service_protocol.h>
#include <system_service/ss_services.h>
#include <system_service/ss_sm_thread_names.h>
#include <system_service/ss_sm_thread_names_local.h>
#include <system_service/ss_sm_client_if.h>
#include <system_service/ss_string_maps.h>
#include <system_service/ss_system_manager_notifications.h>
#include <system_service/ss_system_manager_notifications_local.h>
#include <system_service/ss_templates.h>
#include <system_service/ss_sm_client_if_local.h>
#include <system_service/ss_test_clients.h>
#include <stub/Clock_API.h>
#include <power_hal.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/resource.h>
#include <sys/procfs.h>
#include <sys/timeb.h>
#include <sys/wait.h>
#include <inttypes.h>
#include <libgen.h>
#include <spawn.h>
#include <pthread.h>
#include <linux/oom.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sched.h>
#include <other_service/itoa.h>
#include <iomanip>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include "ss_sm_signals.h"
#include "ss_sm_default_paths.h"
#include "ss_sm_systemmanagerlog.h"
#include "ss_sm_version.h"
#include "ss_system_manager.h"
using namespace std;  // NOLINT

static CSystemManager g_oSystemManger;

#define SS_SM_TEMP_FILE_FOR_STORE_LOGS "/nv/BS/ss/system_manager/rwdata/sm_tempStoreLogs"
#define TR_USB_PATH "/usr/agl/bin/realtimeUsbLog"

// \brief: public structure that is used for logging by NSLogger.
FRAMEWORKUNIFIEDLOGPARAM g_FrameworkunifiedLogParams = {
  FRAMEWORKUNIFIEDLOGOPTIONS,
  {
    ZONE_TEXT_10, ZONE_TEXT_11, ZONE_TEXT_12,
    ZONE_TEXT_13, ZONE_TEXT_14, ZONE_TEXT_15,
    ZONE_TEXT_16, ZONE_TEXT_17, ZONE_TEXT_18,
    ZONE_TEXT_19, ZONE_TEXT_20, ZONE_TEXT_21,
    ZONE_TEXT_22, ZONE_TEXT_23, ZONE_TEXT_24,
    ZONE_TEXT_25, ZONE_TEXT_26, ZONE_TEXT_27,
    ZONE_TEXT_28, ZONE_TEXT_29, ZONE_TEXT_30,
    ZONE_TEXT_31
  },
  FRAMEWORKUNIFIEDLOGZONES
};

std::string NumberToString(int Number) {  // LCOV_EXCL_START 8: dead code
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  std::ostringstream ss;
  ss << Number;
  return ss.str();
}
// LCOV_EXCL_STOP

/* Check if "Mount Point" exsists as Directory */
/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: No Argument Constructor.
 @note: .
 @param void
 @return void
 */
/*****************************************************************************/
template<typename C, eFrameworkunifiedStatus (C::*M)(HANDLE)> EFrameworkunifiedStatus SysMgrCallback(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  C * pObj = static_cast<C *>(&g_oSystemManger);
  if (pObj) {
    l_eStatus = (pObj->*M)(hApp);
  }
  return l_eStatus;
}

//**************************************************************************
//  System Manager State String Map                                        *
//                                                                         *
void Init_SS_SMModuleState_StrMap(std::map<SS_SMModuleState, SS_String> & m_strMap) {  // NOLINT
  MAP_ENTRY(m_strMap, SS_SM_READY_TO_LAUNCH_APP);
  MAP_ENTRY(m_strMap, SS_SM_APPS_LAUNCH_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_LAUNCHED_READY_TO_START);
  MAP_ENTRY(m_strMap, SS_SM_APPS_START_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_START_COMPLETE);
  MAP_ENTRY(m_strMap, SS_SM_APPS_STOPPING_AT__CWORD56__REQ);
  MAP_ENTRY(m_strMap, SS_SM_APPS_STOPPING_AT_INTERNAL_REQ);
  MAP_ENTRY(m_strMap, SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ);
  MAP_ENTRY(m_strMap, SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ);
  MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_START_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_STOP_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_PRE_RUN_COMPLETE);
  MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_START_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS);
  MAP_ENTRY(m_strMap, SS_SM_APPS_BACKGROUND_RUN_COMPLETE);
}  // End of void Init_SS_SMModuleState_StrMap(std::map<SS_SMModuleState,

class EnumStringMap<SS_SMModuleState, Init_SS_SMModuleState_StrMap>
                    m_oSS_SMModuleStateStrMap;
SS_String GetStr(SS_SMModuleState f_enum) {
  return m_oSS_SMModuleStateStrMap.GetStr(f_enum);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
}  // End of SS_String :GetStr(SS_SMModuleState f_enum)
//                                                                         *
//  End of System Manager State String Map                                 *
//**************************************************************************

std::string CSystemManager::m_bootOpt;  // NOLINT

/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: No Argument Constructor.
 @note: .
 @param void
 @return void
 */
/*****************************************************************************/
CSystemManager & CSystemManager::GetInstance() {
  return g_oSystemManger;
}

/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: No Argument Constructor.
 @note: .
 @param void
 @return void
 */
/*****************************************************************************/
CSystemManager::CSystemManager() :
  m_hHeartbeatThread(INVALID_HANDLE, eSM_ThreadNotExist),
  m_hProcLauncherThread(INVALID_HANDLE, eSM_ThreadNotExist),
  m_SystemLaunchProgress(SS_SM_INITIAL_GROUP),
  m_GroupLaunchTimer(NULL),
  m_GroupRelaunchCount(0),
  m_GroupRelaunchLimit(0),
  m_hPowerServiceSession(NULL),
  m_ActiveGroupId(SS_SM_INITIAL_GROUP),
  m_StartUpReason(epswfINVALID),
  m_DataResetMode(e_SS_SM_DATA_RESET_MODE_NONE),
  m_ProgUpdateState(SS_SM_PROG_UPDATE_STATE_NONE),
  m_NextWakeupType(e_SS_SM_NEXT_WAKEUP_TYPE_NONE),
  m_DramBackupStatus(e_SS_SM_DRAM_BACKUP_NG),
  m_isIlgReset(FALSE),
  m_ResetStatus(e_SS_SM_RESET_STATUS_NONE),
  m_ResetCount(0),
  m_SMCurrentState(SS_SM_READY_TO_LAUNCH_APP),

  m_MaxShutdownTime(0),
  m_NbrDebugDumpRspnRecv(0),
  m_isRcvModeInfo(FALSE),
  m_BinaryFilesPath(""),
  m_ConfigFilesPath(""),
  m_pfStopCompleteHandler(
      SysMgrCallback<CSystemManager, &CSystemManager::send_shutdown_complete_response>),
  m_VersionNumberStruct(0, eFrameworkunifiedStatusErrOther),
  m_BuildInfoStr(""),
  m_isRstPending(FALSE),
  m_rstPendingInfo(),
  m_UsingVMPlayer(FALSE),
  NVM_VALID_SIGNATURE(0xBA5EBA11),
  m_lastUserMode(epsumON),
  m_shutdownTrigger(epssdmsdtINVALID),
  m_isImmediateReset(FALSE),
  m_isImmResetReq(FALSE),
  m_needReNotifyStartPrm(FALSE),
  m_pVarCodeStr(NULL),
  m_SSLGroupLaunchMapIterator(NULL),
  m_ModuleLaunchListIter(NULL),
  m_bIsNPP_ServicesStarted(FALSE),
  m_bIsBackupAvail(FALSE),
  m_oSystemLauncher(),
  m_SystemStarter(),
  m_NPPStopSent(FALSE),
  m_userModeChangeReason(epsumcrNOT_AVAILABLE),
  m__CWORD56_CmdHist(SS_SM__CWORD56__CMD_HIST_SIZE),
  m_SMCmdHist(SS_SM_CMD_HIST_SIZE),
  m_TimerCmdHist(SS_SM_TIMER_CMD_HIST_SIZE),
  m_PubCmdHist(SS_SM_PUB_CMD_HIST_SIZE),
  m_ErrHist(SS_SM_ERR_HIST_SIZE),
  m_ClProcessSigFd(-1),
  m_SysMemMonitor(),
  m_FreeMemAvailable(0),
  m_coreFileSizeBytes(0),
  m_BootMicroResetReason(SS_SM_BOOT_MICRO_RESET_REASON_SELF_RESET),
  m_errorEventQueueLocked(FALSE),
  m_isPrevErrEventCompleted(TRUE),
  m_errorEventResult(eFrameworkunifiedStatusOK),
  m_requestedArtifactId(eArtifactIdInterfaceunifiedDebugLog) {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  m_InitialBoot = true;

  m_ResetFactor = PSM_FACTOR_NONE;

  m_Wake.powerupType = epswsPWRON;
  m_Wake.up.level = epswlFULLRUN;

  m_SystemModeInfo.lastUserMode = m_lastUserMode;
  m_SystemModeInfo.limpHomeCutoff = epslhcINVALID;
  m_SystemModeInfo.productionMode = epspmINVALID;
  m_SystemModeInfo.transportMode = epstmINVALID;
  m_SystemModeInfo.systemMode = epssinfINVALID;
  m_SystemModeInfo.startupStage = epssusfINVALID;

  bzero(&m_SMConfig, sizeof(m_SMConfig));
  bzero(&m_startUpConfirmationMsg, sizeof(m_startUpConfirmationMsg));
  bzero(&m_HBReport, sizeof(m_HBReport));

  m__CWORD56_HistIter = m__CWORD56_CmdHist.begin();
  m_TimerHistIter = m_TimerCmdHist.begin();
  m_SMHistIter = m_SMCmdHist.begin();
  m_PubHistIter = m_PubCmdHist.begin();
  m_ErrHistIter = m_ErrHist.begin();

  ////******************************************************************////
  ////       Initialization of enum<=>enum and enum=>string maps        ////
  ////                                                                  ////

  //
  // **** Initialization of powerupType enum maps ****
  // Map of System Services powerupType to BOOL enum values
  m_PowerType_to_SSBoolEnumMap[epswsPWRON] = TRUE;
  m_PowerType_to_SSBoolEnumMap[epswsPWROFF] = FALSE;
  //
  // Map of System Services powerupType to System Services User Mode enum values
  m_PowerType_to_SSUserModeEnumMap[epswsPWRON] = epsumON;
  m_PowerType_to_SSUserModeEnumMap[epswsPWROFF] = epsumOFF;
  //
  // Map of BOOL to System Services powerupType enum values
  m_SSBool_to_PowerTypeEnumMap[TRUE] = epswsPWRON;
  m_SSBool_to_PowerTypeEnumMap[FALSE] = epswsPWROFF;
  //
  // **** Initialization of User Mode ( aka Last User Mode ) maps ****
  // Map of BOOL to System Services User Mode enum values
  m_SSBool_to_SSUserModeEnumMap[FALSE] = epsumOFF;
  m_SSBool_to_SSUserModeEnumMap[TRUE] = epsumON;
  //
  // Map of BOOL to System Services User Mode enum values
  m_SSUserMode_to_SSBoolEnumMap[epsumOFF] = FALSE;
  m_SSUserMode_to_SSBoolEnumMap[epsumON] = TRUE;

  // LCOV_EXCL_BR_STOP
  ////                                                                  ////
  ////    End of Initialization of enum<=>enum and enum=>string maps    ////
  ////******************************************************************////

  m_startUpConfirmationMsg.wakeupType = epsstINVALID;
  m_startUpConfirmationMsg.coldStartRequest = epsscrtINVALID;
  m_startUpConfirmationMsg.HWVersion = UINT32_MAX;
  m_startUpConfirmationMsg.matchedHardwareType = UINT32_MAX;
  m_startUpConfirmationMsg.softwareType = UINT32_MAX;
  m_startUpConfirmationMsg.imageType = UINT32_MAX;
  m_startUpConfirmationMsg.majorVersion = UINT32_MAX;
  m_startUpConfirmationMsg.minorVersion = UINT32_MAX;

  m_SystemManagerPriority = PR_SS_SYSMANAGER;
}

/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: Destructor
 @note: .
 @param void
 @return void
 */
/*****************************************************************************/
CSystemManager::~CSystemManager() {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  if (NULL != m_pVarCodeStr) {
    delete[] m_pVarCodeStr;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }
}

/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: Initialize_memory Memory initialization processing
 @note: .
 @param
 @return void
 */
/*****************************************************************************/
void CSystemManager::Initialize_memory(HANDLE hApp, bool* l_isInitFail, EFrameworkunifiedStatus* l_eStatus_work, BOOL isIllReset) {
  int ret;
  EFrameworkunifiedStatus l_eStatus;

  /// Start Process for Realtime USB Logging
  {
    PreLaunchModuleParams l_rtuparam;
    l_rtuparam.LaunchFunc     = CreateRtUsb;
    l_rtuparam.relaunchLimit  = 1;
    l_rtuparam.name           = "realtimeUsbLog";
    l_rtuparam.binaryFileName = TR_USB_PATH;
/*    l_rtuparam.pid = CreateRtUsb();
    if (l_rtuparam.pid == 1) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: CreateRtUsb()");
    }  */
    m_PreLaunchModuleList.push_back(l_rtuparam);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  int fd = open("/dev/urandom", O_RDONLY);  // LCOV_EXCL_BR_LINE 5: standard lib error
  if (fd == -1) {  // LCOV_EXCL_BR_LINE 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    SS_ASERT_ERRNO(0);  // LCOV_EXCL_LINE 5: standard lib error
  } else {
    char buf[4];
    ret = static_cast<int>(read(fd, buf, 4));  // LCOV_EXCL_BR_LINE 5: standard lib error
    if (-1 == ret) {  // LCOV_EXCL_BR_LINE 5: standard lib error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      SS_ASERT_ERRNO(0);  // LCOV_EXCL_LINE 5: standard lib error
    } else if (4 != ret) {  // LCOV_EXCL_BR_LINE 5: standard lib error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      SS_ASERT(0);  // LCOV_EXCL_LINE 5: standard lib error
    } else {
      fprintf(stderr, "WakeupID:%X%X%X%X\n", buf[0], buf[1], buf[2], buf[3]);
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "WakeupID:%X%X%X%X", buf[0], buf[1], buf[2], buf[3]);
    }
    close(fd);
  }

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "bootOpt:%s", m_bootOpt.c_str());

  *l_eStatus_work = FrameworkunifiedAttachCallbackToDispatcherWithFd(hApp, m_ClProcessSigFd,  // LCOV_EXCL_BR_LINE 4: nsfw error
        SysMgrCallback<CSystemManager, &CSystemManager::OnProcessTermDetected>);

  if (eFrameworkunifiedStatusOK != *l_eStatus_work) {  // 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("FrameworkunifiedAttachCallbackToDispatcherWithFd()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  pthread_mutex_init(&sm_hist_mutex, NULL);

  ReadPathFromEnvironmentVariables();
  ReadUsingVMPlayerEnvironmentVariable();

  // FIXME : Dump information from power_hal by using

  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = SetSystemModeInfoStruct())) {
    LOG_ERROR("SetSystemModeInfoStruct()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    *l_isInitFail = true;
  }

  // Select configuration file for wakeup services
  BOOL bIsVupMode = (m_SystemModeInfo.systemMode == epssinfPROGRAMMING) ? TRUE : FALSE;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  T_SS_SM_INIT_HOOK_IN_PARAM inPrm;

  std::memset(&inPrm, 0, sizeof(inPrm));
  inPrm.bIsVupMode = bIsVupMode;

  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = ss_sm_initHook(hApp, &inPrm, &m_productCustomPrm))) {
    SS_ASERT_LOG(0, "ERROR: ss_sm_initHook()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    *l_isInitFail = true;
  }

  SetEnvVariableForVupMode(bIsVupMode);

  // Get the Version Number
  // GetVersionNumber() will report any errors
  m_VersionNumberStruct.m_eSystemmanagerStatus = GetVersionNumber(m_VersionNumberStruct.m_VersionNumber);

  *l_eStatus_work = GetBuildInfo(m_BuildInfoStr);
  l_eStatus = *l_eStatus_work;

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

  INTERFACEUNIFIEDLOG_WHEN_COMPILED;  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s priority is %d", SERVICE_SYSMANAGER, m_SystemManagerPriority);
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " %s was compiled at %s @ %s", __FILE__, __DATE__, __TIME__);

  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Host Processor Software Version is '0x%016llX'",
         m_VersionNumberStruct.m_VersionNumber);

  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Host Processor Build Version is '%s'", m_BuildInfoStr.c_str());

  LogESystemmanagerStatusEnums();
  LogProtocolIDs();
}

/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: Initialize_callbacks Callback enrollment process
 @note: .
 @param
 @return void
 */
/*****************************************************************************/
void CSystemManager::Initialize_callbacks(HANDLE hApp, bool *l_isInitFail, EFrameworkunifiedStatus *l_eStatus_work) {
  EFrameworkunifiedStatus l_eStatus;

  m_GroupLaunchTimer = new (std::nothrow) TimerCtrl(eSM_TIMERS_END);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    if (NULL == m_GroupLaunchTimer) {  // LCOV_EXCL_BR_LINE 5: Because new doesn't pass the failure case
    // LCOV_EXCL_START 5: Because new doesn't pass the failure case
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    *l_eStatus_work = eFrameworkunifiedStatusNullPointer;
    LOG_ERROR("new(std::nothrow)TimerCtrl(eSM_TIMERS_END)");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
  m_GroupLaunchTimer->Initialize(hApp);
  m_aTimerIDs[eSM_TIMER_GROUP_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnGroupLaunchTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_PROCESS_LAUNCH_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnProcessLaunchTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_HEARTBEAT_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnHeartBeatMonitorTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_PROCESSLAUNCHER_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::OnProcessLaunchMonitorTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_CLIENT_START_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::OnClientStartMonitorTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::OnNPPStatusCheckMonitorTimerExpiry>);
  m_aTimerIDs[eSM_TIMER__CWORD56__HEARTBEAT_RESPONSE] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::On_CWORD56_HeartBeatResponseIntervalTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::OnLaunchGroupTriggerProcessResponseTimerExpiry>);
  m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnGroupLaunchWaitTimeout>);
  m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnModuleConnectWaitTimeout>);
  m_aTimerIDs[eSM_TIMER_START_RESP_MONITOR_WAIT_TIMER] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnStartRespMonitorTimeout>);
  m_aTimerIDs[eSM_TIMER_SHUTDOWN_COMPLETE_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager,
                                      &CSystemManager::OnShutdownCompleteMonitorTimeout>);
  m_aTimerIDs[eSM_TIMER_CLIENT_STOP_MONITOR] =
      m_GroupLaunchTimer->CreateTimer(SysMgrCallback<CSystemManager, &CSystemManager::OnClientStopMonitorTimerExpiry>);

  FrameworkunifiedProtocolCallbackHandler l_cbArrayAnySource[] = {
      // Command ID,                   Call back functions
    { SS_SM_PROTOCOL_OPEN_SESSION_REQ, SysMgrCallback<CSystemManager, &CSystemManager::OnOpenSession> },
    { SS_SM_CPU_RESET_REQ,             SysMgrCallback<CSystemManager, &CSystemManager::OnCpuResetRequest> }
  };

  FrameworkunifiedProtocolCallbackHandler l_cbArrayGroupLaunchService[] = {
      // Command ID,              Call back functions
    { SS_SM_GROUP_LAUNCH_TRIGGER, SysMgrCallback<CSystemManager, &CSystemManager::OnLaunchGroupTriggerProcessResponse> }
  };

  FrameworkunifiedProtocolCallbackHandler l_cbArrayNPPService[] = {
      // Command ID,           Call back functions
    { NPS_NPP_READY_EVENT,     SysMgrCallback<CSystemManager, &CSystemManager::OnNPPReadyEventCallback> },
    { NPS_GET_READYSTATUS_ACK, SysMgrCallback<CSystemManager, &CSystemManager::OnNPPReadyStatusCallback> },
    { NPS_NPP_STOP_ACK,        SysMgrCallback<CSystemManager, &CSystemManager::OnNppStopComplete> }
  };

  FrameworkunifiedProtocolCallbackHandler l_cbArrayPowerService[] = {
      // Command ID,              Call back functions
    { SS_SM_POWER_REQUEST_MSG,    SysMgrCallback<CSystemManager, &CSystemManager::OnPowerRequestCallback> },
    { SS_SM_WAKEUP_MODULES,       SysMgrCallback<CSystemManager, &CSystemManager::OnWakeupCallback> },
    { SS_SM_SYSTEM_MODE_INFO_REQ, SysMgrCallback<CSystemManager, &CSystemManager::OnSystemModeInfoRequest> },
    { SS_SM_INITCOMP_REP,         SysMgrCallback<CSystemManager, &CSystemManager::OnInitCompReportCallback> },
    { SS_SM_SHUTDOWN_MODULES,     SysMgrCallback<CSystemManager, &CSystemManager::OnShutdownModulesRequest> },
    { SS_SM_FWD_STARTUP_CONFIRMATION_MSG_REQ,
                            SysMgrCallback<CSystemManager, &CSystemManager::OnSetStartupConfirmationDataRequest> }
  };

  FrameworkunifiedProtocolCallbackHandler l_cbArraySystemManager[] = {
      // Command ID,        Call back functions
    { SS_SM_SendTriggerToSelf, SysMgrCallback<CSystemManager, &CSystemManager::OnLaunchGroupSelfTrigger> },
    { SS_SM_DEBUG_DUMP_RSPN, SysMgrCallback<CSystemManager,   &CSystemManager::OnDebugDumpResponseReceived> }
  };
  // LCOV_EXCL_BR_STOP

#define ATTACH_CBS_TO_DISPATCHER(L_ARRAY, CALLING_SERVICE_NAME)       \
    *l_eStatus_work = l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp,           \
                          CALLING_SERVICE_NAME,   \
                          L_ARRAY,          \
                          static_cast<UI_32>_countof(L_ARRAY));     \
    if (eFrameworkunifiedStatusOK != l_eStatus) {                  \
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,                    \
       " Error: FrameworkunifiedAttachCallbacksToDispatcher(%s) errored: %d/'%s'",   \
       #L_ARRAY,                            \
       l_eStatus,                             \
       GetStr(l_eStatus).c_str());                    \
       *l_isInitFail = true;                       \
    }
// End of #define ATTACH_CBS_TO_DISPATCHER( CALLING_SERVICE_NAME, L_ARRAY )

  // LCOV_EXCL_BR_START 15: marco defined above
  // Note: This macro will exit this function if the embedded fnc errors.
  ATTACH_CBS_TO_DISPATCHER(l_cbArrayAnySource, FRAMEWORKUNIFIED_ANY_SOURCE);

  // Note: This macro will exit this function if the embedded fnc errors.
  ATTACH_CBS_TO_DISPATCHER(l_cbArrayGroupLaunchService, SS_GROUP_LAUNCH_TRIGGER);

  // Note: This macro will exit this function if the embedded fnc errors.
  ATTACH_CBS_TO_DISPATCHER(l_cbArrayNPPService, FRAMEWORKUNIFIED_NS_NPSERVICE);

  // Note: This macro will exit this function if the embedded fnc errors.
  ATTACH_CBS_TO_DISPATCHER(l_cbArrayPowerService, SERVICE_POWER);

  // Note: This macro will exit this function if the embedded fnc errors.
  ATTACH_CBS_TO_DISPATCHER(l_cbArraySystemManager, SERVICE_SYSMANAGER);
  // LCOV_EXCL_BR_STOP

  {
    char pathBuf[128];
    // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
    snprintf(pathBuf, sizeof(pathBuf), "/proc/%d/oom_score_adj", getpid());
    std::ofstream fo(pathBuf);
    fo << OOM_SCORE_ADJ_MIN << endl;
    fo.close();
    // LCOV_EXCL_BR_STOP
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "set OOM_SCORE_ADJ_MIN(SS_SysManager/%d)", getpid());
  }

#undef ATTACH_CBS_TO_DISPATCHER

  // LCOV_EXCL_BR_START 4: nsfw error
  *l_eStatus_work = FrameworkunifiedSubscribeNotificationWithCallback(hApp, NTFY_BackupMgr_Availability,
          SysMgrCallback<CSystemManager, &CSystemManager::OnBackupMgrAvailCallback>);
  // LCOV_EXCL_BR_STOP
  if (eFrameworkunifiedStatusOK != *l_eStatus_work) {  // 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("FrameworkunifiedSubscribeNotificationWithCallback()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = ErrorEventInit(hApp))) {  // LCOV_EXCL_BR_LINE 6: function do not return error
    // LCOV_EXCL_START 6: function do not return error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ErrorEventInit()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

#ifndef SS_SM_SKIP_HEARTBEAT_INIT
  // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_Heartbeat(hApp))) {
  // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 6: function do not return error, expect nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("init_HeartBeat()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }
#else
#warning Test code - NOT calling init_Heartbeat(hApp)
  FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: NOT calling init_Heartbeat(hApp)");
#endif
#undef SS_SM_SKIP_HEARTBEAT_INIT

  // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_process_launcher(hApp))) {
  // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 6: function do not return error, expect nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("init_process_launcher()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  // LCOV_EXCL_BR_START 6: function do not return error, expect init error
  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = start_process_launching(hApp))) {
  // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 6: function do not return error, expect init error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("start_process_launching()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  // LCOV_EXCL_BR_START 6: function do not return error, expect nsfw error
  if (eFrameworkunifiedStatusOK != (*l_eStatus_work = init_sysmem_monitor(hApp))) {
  // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 6: function do not return error, expect nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("init_sysmem_monitor()");
    *l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  /// Internal thread monitoring start
  // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
  m_GroupLaunchTimer->StartTimer(m_aTimerIDs[eSM_TIMER_HEARTBEAT_MONITOR],
      SS_HEARTBEAT_MONITOR_TIMER_CONFIG, 0,
      SS_HEARTBEAT_MONITOR_TIMER_CONFIG, 0);

  m_GroupLaunchTimer->StartTimer(
      m_aTimerIDs[eSM_TIMER_PROCESSLAUNCHER_MONITOR],
      SS_PROCESSLAUNCHER_MONITOR_TIMER_CONFIG, 0,
      SS_PROCESSLAUNCHER_MONITOR_TIMER_CONFIG, 0);

  m_GroupLaunchTimer->StartTimer(
      m_aTimerIDs[eSM_TIMER_NPP_STATUS_CHECK_MONITOR],
      SS_NPP_STATUS_CHECK_MONITOR_TIME_SEC, 0,
      SS_NPP_STATUS_CHECK_MONITOR_TIME_SEC, 0);
  // LCOV_EXCL_BR_STOP
}


/*****************************************************************************/
/**
 @ingroup: CSystemManager
 @brief: Initialization
 @note: .
 @param HANDLE hApp
 @return void
 */
/*****************************************************************************/
EFrameworkunifiedStatus CSystemManager::Initialize(HANDLE hApp) {
  bool l_isInitFail = false;
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  int ret;
  PsmFactorT      l_startup_factor;

  // Need to call Lock System Initialize API once in the system
  ret = CL_LockSystemInit();
  if (ret != 0) {
    fprintf(stderr, "SS_SysManager/%s/Error: CL_LockSystemInit() errored: %d\n", __FUNCTION__, ret);
  }

  ret = CL_LockProcessInit();
  if (ret != 0) {
    fprintf(stderr, "SS_SysManager/%s/Error: CL_LockProcessInit() errored: %d\n", __FUNCTION__, ret);
    l_isInitFail = true;
  }

  ret = PsmGetStartupFactor(hApp, &l_startup_factor);
  if (ret == 0) {
    if ((static_cast<UI_32>(l_startup_factor) & PSM_RESET_HISTORY) == PSM_RESET_HISTORY) {
      DGCODE_RET_API  l_ret = DGCODE_RET_ERROR;
      uint64_t l_SystemResetRobCode = 0;
      DGCODE_ROB_SSR_INFO  l_info;
      if (l_startup_factor == PSM_FACTOR_AGL_WITH_HISTORY) {
        l_SystemResetRobCode = 0x2219;                // AGL cause
      } else if (l_startup_factor == PSM_FACTOR_TIER1_WITH_HISTORY) {
        l_SystemResetRobCode = 0x221A;                // Tier1 cause
      } else if (l_startup_factor == PSM_FACTOR_USER_WITH_HISTORY) {
        l_SystemResetRobCode = 0x8027;                // USER cause
      } else {
        // No processing
      }

      if (l_SystemResetRobCode != 0) {
        memset(&l_info, 0x00, sizeof(DGCODE_ROB_SSR_INFO));

        l_ret = Diag_PutRoBInfo(hApp, l_SystemResetRobCode, &l_info);
        if (l_ret == DGCODE_RET_ERROR) {
          LOG_ERROR("Diag_PutRoBInfo()");
        }
      }
    }
  } else {
    (void)fprintf(stderr, "SS_SysManager/%s/ERROR:start-up factor not get\n", __FUNCTION__);
  }

  m_isIlgReset = (false == GetSyscomPowerStatusInfo(hApp)) ? TRUE : FALSE;
  if (m_isIlgReset || ("elog" == m_bootOpt)) {
    fprintf(stderr, "SS_SysManager/%s/Error: ILGRST LOG SAVE\n", __func__);
    StoreDebugLogs(hApp, SS_STORELOGS_ILLEGAL);
  } else {
    StoreDebugLogs(hApp, SS_STORELOGS_ACCOFFON);
  }

  if (m_isIlgReset == TRUE) {
    // overwrite AGL_ILLRESET_FLAG.
    uint32_t tmp = static_cast<uint32_t>(m_isIlgReset);
    if (PowerHalSetResetInfo(AGL_ILLRESET_FLAG, tmp)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "Could not set AGL_ILLRESET_FLAG to power_hal");
    }
  } else {
    // keep last value of AGL_ILLRESET_FLAG.
  }

  FRAMEWORKUNIFIED_SET_ZONES();
  NsLogSetLogMethod(LPRINT | LMSGQ);
  // FRAMEWORKUNIFIEDLOG can not be used until this line

  m_ClProcessSigFd = CL_ProcessInit();  // LCOV_EXCL_BR_LINE 4: nsfw error
  if (m_ClProcessSigFd == -1) {  // 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: CL_ProcessInit()");
    l_isInitFail = true;
    // LCOV_EXCL_STOP
  }

  ret = CL_MonitorInit(CL_MONITOR_INIT_SYSTEM);
  if(ret != 0) {
    fprintf(stderr, "SS_SysManager/%s/Error: CL_MonitorInit() errored: %d\n", __FUNCTION__, ret);
    l_isInitFail = true;
  }

  // Threads MUST NOT be started until this line
// ===== Initialization No.1
  Initialize_memory(hApp, &l_isInitFail, &l_eStatus, m_isIlgReset);

// ===== Initialization No.2
  Initialize_callbacks(hApp, &l_isInitFail, &l_eStatus);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");

  return l_eStatus;
}

EFrameworkunifiedStatus CSystemManager::SetEnvVariableForVupMode(BOOL bIsVupMode) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  const CHAR SmVupModeEnvVariable[] = "SM_VUP_MODE";
  const CHAR *l_pValue = bIsVupMode ? "y" : "n";  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  if (0 != setenv(SmVupModeEnvVariable, l_pValue, 1)) {  // LCOV_EXCL_BR_LINE 5: standard lib error
    // LCOV_EXCL_START 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    SS_ASERT_ERRNO(0);
    l_eStatus = eFrameworkunifiedStatusFail;
    // LCOV_EXCL_STOP
  }

  return l_eStatus;
}

int CSystemManager::CreateRtUsb(void) {// LCOV_EXCL_START 8: dead code
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  int pid = -1;
  int ret;

  ret = mkdir("/var/run", 0775);
  if ((ret < 0) && (errno != EEXIST)) {
    return -1;
  }
  pid = fork();
  switch (pid) {
    case 0: /* child process */
    {
      struct sched_param param;
      int policy;
      const char *exec;
      exec = const_cast<char *>(TR_USB_PATH);
      param.sched_priority = 0;
      policy = SCHED_OTHER;
      if (sched_setscheduler(getpid(), policy, &param) < 0) {
        SS_ASERT(0);
        _exit(-1);
      }
      if (setpriority(PRIO_PROCESS, getpid(), 0) < 0) {
        SS_ASERT(0);
        _exit(-1);
      }
      // exec
      if (execlp(exec, exec, NULL) < 0) {
        SS_ASERT(0);
        _exit(-1);
      }
      _exit(0);
    }
    break;

    case -1: /* error */
      SS_ASERT(0);
      goto ERROR;

    default: /* parent process */
      break;
  }

ERROR:
  return pid;
}// LCOV_EXCL_STOP

bool CSystemManager::StoreDebugLogs(const HANDLE h_app,
                                                   SS_STORELOGS_OPE_TYPE type) {
  bool isMountRamd = false;
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  int pid;

  if (!GetDramPowerStatusInfo(h_app)) {
    goto ERROR;
  } else if (access(SS_SM_TEMP_FILE_FOR_STORE_LOGS, F_OK) == 0) {
    fprintf(stderr, "SS_SysManager/%s/Error: Skip StoreDebugLogs\n", __FUNCTION__);
    goto ERROR;
  }

  isMountRamd = true;

  if (type == SS_STORELOGS_ILLEGAL) {
    UI_32 l_ErrLogCount = 0;
    if (PowerHalGetResetInfo(AGL_ERRLOG_COUNTER, &l_ErrLogCount)) {
      fprintf(stderr, "SS_SysManager/%s/Error: "
        "Could not read AGL_ERRLOG_COUNTER from power_hal\n", __FUNCTION__);
      goto ERROR;
    }

    if (l_ErrLogCount >= SS_SM_ERR_LOGGING_LIMIT) {
      fprintf(stderr, "SS_SysManager/%s/Error: "
        "Skip StoreDebugLogs by continuous error l_ErrLogCount=%lu\n",
        __FUNCTION__, l_ErrLogCount);
      goto ERROR;
    }

    l_ErrLogCount++;
    if (PowerHalSetResetInfo(AGL_ERRLOG_COUNTER, l_ErrLogCount)) {
      // Just logging, don't go to  ERROR.
      fprintf(stderr, "SS_SysManager/%s/Error: "
        "Could not write AGL_ERRLOG_COUNTER to power_hal\n", __FUNCTION__);
    }
  } else if (type == SS_STORELOGS_ACCOFFON) {
    if (0 != unlink(SS_LOGGER_SAVE_INTERFACEUNIFIEDLOG_FLAG)) {
      fprintf(stderr, "SS_SysManager/%s/Error: ACCOFFON LOG SAVE\n", __FUNCTION__);
    } else {
      goto ERROR;
    }
  }

  pid = fork();
  if (pid == 0) {
    int fd = open(SS_SM_TEMP_FILE_FOR_STORE_LOGS,
        O_CREAT | O_TRUNC | O_RDWR, 00664);
    if (-1 == fd) {  // LCOV_EXCL_BR_LINE 5:fd must not be -1
      fprintf(stderr, "SS_SysManager/%s/Error: Failed open %s errno: %d\n",
              __FUNCTION__, SS_SM_TEMP_FILE_FOR_STORE_LOGS, errno);
    } else {
      fsync(fd);
      close(fd);
    }
    FRAMEWORKUNIFIED_SET_ZONES();  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
    NsLogSetLogMethod(LPRINT | LMSGQ);

    if (eFrameworkunifiedStatusOK != (l_eStatus = SS_LoggerStoreLogs(type))) {  // LCOV_EXCL_BR_LINE 200: always return OK
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      fprintf(stderr, "SS_SysManager/%s/Error: SS_LoggerStoreDebugLogs() errored: %d\n", __FUNCTION__, l_eStatus);  // LCOV_EXCL_LINE 200: always return OK  // NOLINT(whitespace/line_length)
    }
    // Close accessing the RAMD by FRAMEWORKUNIFIEDLOG for RAMD initialization
    NsForceClose();

    if (0 != unlink(SS_SM_TEMP_FILE_FOR_STORE_LOGS)) {
      SS_ASERT_ERRNO(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }

    exit(0);
  } else if (pid == -1) {  // LCOV_EXCL_BR_LINE 5:fork error case
    // LCOV_EXCL_START 5:fork error case
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    fprintf(stderr, "SS_SysManager/%s/Error: ASSERT %d\n", __FUNCTION__, __LINE__);
    // LCOV_EXCL_STOP
  } else {
    if (-1 == waitpid(pid, NULL, 0)) {    // LCOV_EXCL_BR_LINE 5:waitpid error case
      // LCOV_EXCL_START 5:waitpid error case
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      fprintf(stderr, "SS_SysManager/%s/Error: ASSERT %d\n", __FUNCTION__, __LINE__);
      // LCOV_EXCL_STOP
    }
  }
 ERROR:
  return isMountRamd;
}

#define SS_SM_SCAC_DEVICE_NODE      "/dev/scac_driver"
#define SS_SM_SCAC_CMD_SHUTDOWN     0x3000

EFrameworkunifiedStatus CSystemManager::SecureChipOff() {
  static bool isOffDone = false;
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  int32_t fd;
  int32_t res;

  if (!isOffDone) {
    fd = open(SS_SM_SCAC_DEVICE_NODE, O_RDWR);
    if (fd < 0) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open(%s) ERR", SS_SM_SCAC_DEVICE_NODE);
      l_eStatus = eFrameworkunifiedStatusFail;
    } else {
      res = ioctl(fd, SS_SM_SCAC_CMD_SHUTDOWN);
      if (res < 0) {  // LCOV_EXCL_BR_LINE 5: standard lib error
        // LCOV_EXCL_START 5: standard lib error
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ioctl(SS_SM_SCAC_CMD_SHUTDOWN) ERR");
        l_eStatus = eFrameworkunifiedStatusFail;
        // LCOV_EXCL_STOP
      }

      close(fd);
    }

    isOffDone = true;
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Skip Chip Off");
  }

  return l_eStatus;
}

UI_32 CSystemManager::InProgressStateToSendMsg() const {
  UI_32 l_iCmd = SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX;
  switch (m_SMCurrentState) {
  case SS_SM_APPS_PRE_START_IN_PROGRESS:
    l_iCmd = SS_SM_PRE_START;
    break;
  case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
    l_iCmd = SS_SM_PRE_STOP;
    break;
  case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
    l_iCmd = SS_SM_BACKGROUND_START;
    break;
  case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
    l_iCmd = SS_SM_BACKGROUND_STOP;
    break;
  case SS_SM_APPS_START_IN_PROGRESS:
    l_iCmd = SS_SM_START;
    break;
  default:
    break;
  }
  return l_iCmd;
}

SMModuleState CSystemManager::InProgressStateToState() const {
  SMModuleState l_state = MODULE_STATE_INVALID;
  switch (m_SMCurrentState) {
  case SS_SM_APPS_PRE_START_IN_PROGRESS:
    l_state = MODULE_STATE_STARTED_PRE;
    break;
  case SS_SM_APPS_PRE_STOP_IN_PROGRESS:
    l_state = MODULE_STATE_STOPPED_PRE;
    break;
  case SS_SM_APPS_BACKGROUND_START_IN_PROGRESS:
    l_state = MODULE_STATE_STARTED_BACKGROUND;
    break;
  case SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS:
    l_state = MODULE_STATE_STOPPED_BACKGROUND;
    break;
  case SS_SM_APPS_START_IN_PROGRESS:
    l_state = MODULE_STATE_STARTED;
    break;
  default:
    break;
  }
  return l_state;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SetSystemModeInfoStruct
/// Read ( or initialize ) NVM and set the SystemModeInfo structure
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::SetSystemModeInfoStruct() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (m_UsingVMPlayer) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " 'm_UsingVMPlayer' is True,"
        " using default SystemModeInfo values");
    m_SystemModeInfo.limpHomeCutoff = epslhcDISABLED;
    m_SystemModeInfo.productionMode = epspmDISABLED;
    m_SystemModeInfo.transportMode = epstmDISABLED;
    m_SystemModeInfo.systemMode = epssinfNORMAL;
    m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
    m_ResetCount = 0;
    m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
    // Don't change the m_SystemModeInfo.startupStage.
    // It is set dynamically as System Manager initializes the _CWORD102_.
  } else {
    uint32_t tmp = 0;
    if (PowerHalGetResetInfo(AGL_RESET_COUNTER, &m_ResetCount)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            "Could not read AGLRESET_COUNTER from power_hal, assume to 0");
      m_ResetCount = 0;
    }

    if (PowerHalGetResetInfo(AGL_PROGUPDATE_STATE, &m_ProgUpdateState)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            "Could not read AGL_PROGUPDATE_STATE from power_hal, "
            "assume to SS_SM_PROG_UPDATE_STATE_NONE");
      m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
    }

    if (PowerHalGetResetInfo(AGL_DATARESET_STATE, &tmp)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            "Could not read AGL_DATARESET_STATE from power_hal, "
            "assume to e_SS_SM_DATA_REESET_MODE_NONE");
      m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
    } else {
      m_DataResetMode = static_cast<ESMDataResetModeInfo>(tmp);
    }
    m_SystemModeInfo.systemMode = epssinfNORMAL;
  }  // End else ! m_UsingVMPlayer

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

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

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "PsmClrRamJudgeFlgPower()");
  ret = PsmClrRamJudgeFlgPower(hApp);
  if (ret != 0) {  // LCOV_EXCL_BR_LINE 11: Excluded due to gcov constraints (others)
    SS_ASERT_ERRNO(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    l_eStatus = eFrameworkunifiedStatusFail;
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup CloseApplication
/// Process request to close Application
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::CloseApplication(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__, "+");

  if (eFrameworkunifiedStatusOK
      != (l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, FALSE))) {
    LOG_ERROR("FrameworkunifiedPublishServiceAvailability(hApp,FALSE)");
  } else if (eFrameworkunifiedStatusOK != (l_eStatus =
      FrameworkunifiedUnRegisterServiceAvailabilityNotification(hApp))) {
    LOG_ERROR("FrameworkunifiedUnRegisterServiceAvailabilityNotification(hApp)");
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Successful");
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SMStateStartCompleteEntry
///     entry for SM module state(SS_SM_APPS_START_COMPLETE)
///
/// \param
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::SMStateStartCompleteEntry(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      "All %d groups have been sent system_manager protocol message, sending Start Complete to _CWORD56_",
      m_SystemStarter.get_id());
  CALL_AND_LOG_STATUS_IF_ERRORED(  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      send_power_request_complete_response(hApp, "Startup"));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

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

  if (m_InitialBoot == true) {
    m_InitialBoot = false;

    const ESMServiceWakeupStatus l_svcWupStatus = e_SS_SM_SVC_WAKEUP_STATUS_COMPLETE;

    CALL_AND_LOG_STATUS(  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        FrameworkunifiedNPPublishNotification(hApp, NTFY_SSServiceWakeupStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
            &l_svcWupStatus, sizeof(ESMServiceWakeupStatus)));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

    // If all modules are restarted, a passive warning will be issued
    // indicating that Heartbeat is already running.

    UI_32 l_list_num = static_cast<UI_32>(m_HBList.size());
    if (SS_MAX_NUM_MODULES < l_list_num) {
      l_list_num = SS_MAX_NUM_MODULES;
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
          " Warn: SS_MAX_NUM_MODULES '%d' <  m_HBList.size '%d'",
          SS_MAX_NUM_MODULES, l_list_num);
    }

    CHAR send_data[sizeof(l_list_num)
        + (l_list_num * SS_SM_HB_MAX_PROC_NAME_SIZE)
        + sizeof(m_SMConfig.HBConfig)];
    CHAR* p_prm = &send_data[0];

    memcpy(p_prm, reinterpret_cast<char *>(&m_SMConfig.HBConfig), sizeof(m_SMConfig.HBConfig));
    p_prm = p_prm + sizeof(m_SMConfig.HBConfig);
    memcpy(p_prm, reinterpret_cast<char *>(&l_list_num), sizeof(l_list_num));
    p_prm = p_prm + sizeof(l_list_num);

    for (UI_32 i = 0; i < l_list_num; i++) {
      snprintf(p_prm, SS_SM_HB_MAX_PROC_NAME_SIZE, "%s", m_HBList[i].c_str());
      p_prm = p_prm + SS_SM_HB_MAX_PROC_NAME_SIZE;
    }
    l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_START, &send_data, static_cast<UI_32>(sizeof(send_data)));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

    m_DataResetMode = e_SS_SM_DATA_RESET_MODE_NONE;
    {
      uint32_t tmp = static_cast<uint32_t>(m_DataResetMode);
      if (PowerHalSetResetInfo(AGL_DATARESET_STATE, tmp)) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Could not set AGL_DATARESET_STATE to power_hal");
      }
    }

    m_ProgUpdateState = SS_SM_PROG_UPDATE_STATE_NONE;
    if (PowerHalSetResetInfo(AGL_PROGUPDATE_STATE, m_ProgUpdateState)) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Could not set AGL_PROGUPDATE_STATE to power_hal");
    }

    m_isIlgReset = FALSE;
    {
      uint32_t tmp = static_cast<uint32_t>(m_isIlgReset);
      if (PowerHalSetResetInfo(AGL_ILLRESET_FLAG, tmp)) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Could not set AGL_ILLRESET_FLAG to power_hal");
      }
    }

    if (access(SS_SM_TEMP_FILE_FOR_STORE_LOGS, F_OK) == 0) {
      SS_ASERT_ERRNO(0 == unlink(SS_SM_TEMP_FILE_FOR_STORE_LOGS));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }
  }

  for (vector<std::string>::iterator protectedSvc =
      m_productCustomPrm.protectedSvcs.begin();
      protectedSvc != m_productCustomPrm.protectedSvcs.end();
      protectedSvc++) {
    ModuleLaunchListIter l_ModuleListIter;
    l_eStatus = GetModuleIterator(protectedSvc->c_str(), l_ModuleListIter);
    if (eFrameworkunifiedStatusOK == l_eStatus) {
      if ((l_ModuleListIter->IsModuleState(MODULE_STATE_STARTED))
          || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED)
              && !l_ModuleListIter->is_start_required)) {
        char pathBuf[128];

        snprintf(pathBuf, 128, "/proc/%d/oom_score_adj", l_ModuleListIter->pid);  // NOLINT
        std::ofstream fo(pathBuf);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        fo << OOM_SCORE_ADJ_MIN << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        fo.close();  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "set OOM_SCORE_ADJ_MIN(%s/%d)",
            l_ModuleListIter->name.c_str(), l_ModuleListIter->pid);
      } else {
        SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      }
    }
  }

  for (vector<std::string>::iterator groupRelaunchSvc =
      m_productCustomPrm.groupRelaunchSvcs.begin();
      groupRelaunchSvc != m_productCustomPrm.groupRelaunchSvcs.end();
      groupRelaunchSvc++) {
    ModuleLaunchListIter l_ModuleListIter;
    l_eStatus = GetModuleIterator(groupRelaunchSvc->c_str(), l_ModuleListIter);
    if (eFrameworkunifiedStatusOK == l_eStatus) {
      if ((l_ModuleListIter->IsModuleState(MODULE_STATE_STARTED))
          || (l_ModuleListIter->IsModuleState(MODULE_STATE_LAUNCHED)
              && !l_ModuleListIter->is_start_required)) {
        GroupRelaunchModuleParams l_param;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        l_param.name = l_ModuleListIter->name.c_str();
        m_GroupRelaunchModuleList.push_back(l_param);

        if (l_ModuleListIter->retry_cnt > m_GroupRelaunchLimit) {
          m_GroupRelaunchLimit = l_ModuleListIter->retry_cnt;
        }

        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "GroupRelaunchSvcs:%s(%d)",
            l_ModuleListIter->name.c_str(), l_ModuleListIter->pid);
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s is not Launched", groupRelaunchSvc->c_str());
      }
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s is not exist", groupRelaunchSvc->c_str());
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "GroupRelaunchLimit:%d", m_GroupRelaunchLimit);

  SendDeferMsg(hApp);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
}  // End of VOID CSystemManager::SMStateStartCompleteEntry()

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SMStateEntry
///     entry for SM module state
///
/// \param
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::SMStateEntry(HANDLE hApp, SS_SMModuleState l_SMState) {
  switch (l_SMState) {
  case SS_SM_APPS_START_COMPLETE:
  case SS_SM_APPS_PRE_RUN_COMPLETE:
  case SS_SM_APPS_BACKGROUND_RUN_COMPLETE:
    SMStateStartCompleteEntry(hApp);
    break;
  default:
    break;
  }
}  // End of VOID CSystemManager::SMStateEntry(SS_SMModuleState l_SMState)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SMStateExit
///     exit for SM module state
///
/// \param
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::SMStateExit(HANDLE hApp, SS_SMModuleState l_SMState) {
  switch (l_SMState) {
  case SS_SM_APPS_START_COMPLETE:
    break;
  default:
    break;
  }
}  // End of VOID CSystemManager::SMStateExit(SS_SMModuleState l_SMState)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SMSetState
///     set module state
///
/// \param
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::SMSetState(HANDLE hApp, SS_SMModuleState l_SMNewState) {
  // FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s -> %s",
      GetStr(m_SMCurrentState).c_str(), GetStr(l_SMNewState).c_str());

  if (l_SMNewState != m_SMCurrentState) {
    SMStateExit(hApp, m_SMCurrentState);

    m_SMCurrentState = l_SMNewState;

    SMStateEntry(hApp, m_SMCurrentState);
  }
  // FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup register_all_notification_callbacks
///     register all notifications and callbacks with NP_NPS
///   this function gets called when NP_NPS reply launch complete
///
/// \param
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::register_all_notification_callbacks(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  FrameworkunifiedNotificationsList userModeNotificationsBOOL[] = { {
      NTFY_SSSystemMgrPowerOnOff, sizeof(BOOL), eFrameworkunifiedStateVar }, {
      NTFY_SSSystemMgrUserMode, sizeof(BOOL), eFrameworkunifiedStateVar } };

  FrameworkunifiedNotificationsList userModeNotificationsStruct[] = { {
      NTFY_SSSystemMgrPowerOnOff,
      sizeof(T_SS_SM_UserModeOnOffNotification_Struct), eFrameworkunifiedStateVar }, {
      NTFY_SSSystemMgrUserMode,
      sizeof(T_SS_SM_UserModeOnOffNotification_Struct), eFrameworkunifiedStateVar } };

  FrameworkunifiedNotificationsList sm_notifications[] = {
      { NTFY_SSSystemMgrStartUpType, sizeof(EPWR_SC_WAKEUP_TYPE), eFrameworkunifiedStateVar },
      { NTFY_SSSystemMgrDataReset, sizeof(ESMDataResetType), eFrameworkunifiedStateVar },
      { NTFY_SSSystemMgrShutdownStarted, 0, eFrameworkunifiedStateVar },
      { NTFY_SSServiceWakeupStatus, sizeof(ESMServiceWakeupStatus), eFrameworkunifiedStateVar },
      { NTFY_SSNeedAplRestart, 0, eFrameworkunifiedStateVar } };

  if (m_SMConfig.UMConfig.IsUserModeNotificationABOOL) {
    l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp, userModeNotificationsBOOL,
        static_cast<UI_32>(_countof(userModeNotificationsBOOL)));
  } else {
    l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp,
        userModeNotificationsStruct,
        static_cast<UI_32>(_countof(userModeNotificationsStruct)));
  }

  if (eFrameworkunifiedStatusOK != l_eStatus) {
    LOG_ERROR("FrameworkunifiedNPRegisterNotifications(userModeNotifications)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedNPRegisterNotifications(hApp, sm_notifications, static_cast<UI_32>(_countof(sm_notifications))))) {  // 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("FrameworkunifiedNPRegisterNotifications(sm_notifications)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedRegisterServiceAvailabilityNotification(hApp, NTFY_SSSystemMgrAvailability))) {  // 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("FrameworkunifiedRegisterServiceAvailabilityNotification("  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        NTFY_SSSystemMgrAvailability ")");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedPublishServiceAvailability(hApp, TRUE))) {  // 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("FrameworkunifiedPublishServiceAvailability('NTFY_SSSystemMgrAvailability ', TRUE)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    // LCOV_EXCL_STOP
  } else {
    LOG_SUCCESS("FrameworkunifiedPublishServiceAvailability('NTFY_SSSystemMgrAvailability ', TRUE)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)

    REC_HIST_IF_SUCCESSFUL(NTFY_SSSystemMgrAvailability, m_PubCmdHist,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    m_PubHistIter, "", l_eStatus);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::init_Heartbeat(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  FrameworkunifiedProtocolCallbackHandler hb_protocol_callbacks[] = { {
    SS_HEARTBEAT_PERIODIC_RESP, SysMgrCallback<CSystemManager,
            &CSystemManager::OnHeartBeatThreadHeartbeatResponse> }, {
    SS_HEARTBEAT_ERROR_DETECTED, SysMgrCallback<CSystemManager,
            &CSystemManager::OnHeartBeatErrorDetected> }, {
    SS_HEARTBEAT_AVAIL_CHECK_RESP, SysMgrCallback<CSystemManager,
            &CSystemManager::OnCheckAvailResponse> } };  // LCOV_EXCL_BR_LINE 11:unexpected branch

  //  Subscribe to Notifications (All required notifications)
  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, SS_SMHeartbeat, hb_protocol_callbacks, static_cast<UI_32>(_countof(hb_protocol_callbacks))))) {  // 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("FrameworkunifiedAttachCallbacksToDispatcher(hb_notification_handlers)");
    // LCOV_EXCL_STOP
  } else if (NULL == (m_hHeartbeatThread.m_ThreadHdl = FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMHeartbeat, HBThreadStart, HBThreadStop, PR_SMHEARTBEAT))) {  // 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
    l_eStatus = eFrameworkunifiedStatusThreadNotExist;
    m_hHeartbeatThread.m_ThreadState = eSM_ThreadNotExist;
    LOG_ERROR("FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMHeartbeat)");
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedStartChildThread(hApp, m_hHeartbeatThread.m_ThreadHdl, 0, NULL))) {  // 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
    m_hHeartbeatThread.m_ThreadState = eSM_ThreadNotExist;
    LOG_ERROR("FrameworkunifiedStartChildThread(SS_SMHeartbeat)");
    // LCOV_EXCL_STOP
  } else {
    m_hHeartbeatThread.m_ThreadState = eSMThreadIsFine;
  }

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

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

  FrameworkunifiedProtocolCallbackHandler sysmem_protocol_callbacks[] = { {
      eSysMemThrdCmd_SYS_LOW_MEMORY, SysMgrCallback<CSystemManager,
            &CSystemManager::OnLowSystemMemory> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  // LCOV_EXCL_BR_START 4: For setting the initialization conditions at SystemManager startup
  if (eFrameworkunifiedStatusOK
      != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(
            hApp,
            m_SysMemMonitor.GetThreadName().c_str(), sysmem_protocol_callbacks,
  static_cast<UI_32>(_countof(sysmem_protocol_callbacks))))) {
  // LCOV_EXCL_BR_STOP
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()");  // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
  } else {
    m_SysMemMonitor.SetSLMConfigData(m_SMConfig.SLMConfig);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    l_eStatus = m_SysMemMonitor.Initialize(hApp);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    LOG_ERROR_REC_HIST_IF_ERRORED  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
    (l_eStatus, "m_SysMemMonitor.Initialize(hApp);");  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnGroupLaunchTimerExpiry(HANDLE hThread) {  // 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__, "+");
  UI_32 l_launchID = m_oSystemLauncher.get_id();

  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, " Received from group %d", l_launchID);
  REC_HIST_IF_SUCCESSFUL("SM_TIMER_GROUP_MONITOR", m_TimerCmdHist,
          m_TimerHistIter, "TIMER", l_eStatus);

  LogGroupModulesState(l_launchID,
          " Group launch timer expired, processing next group.");

  if (NULL == hThread) {
    l_eStatus = eFrameworkunifiedStatusInvldParam;
    LOG_ERROR("NULL == hThread");
  } else {
    //    FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "Timer expired for group id,%d",m_oSystemLauncher.get_id());
    if (!m_oSystemLauncher.is_end()) {
      l_launchID = m_oSystemLauncher.advance_id();
      if (eFrameworkunifiedStatusOK != (l_eStatus = OnLaunchGroup(hThread))) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: OnLaunchGroup(%d) errored: %d/'%s'", l_launchID,
            l_eStatus, GetStr(l_eStatus).c_str());
      }
    }
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::FindNameOfTerminatedProcess(SI_32 f_pid, SS_String &f_ModuleName) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusDbRecNotFound;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.begin();
  if (l_GroupIterator == m_MapProclaunchGrps.end()) {  // LCOV_EXCL_BR_LINE 200: Group Map cannot be empty
    // LCOV_EXCL_START 200: Group Map cannot be empty
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error : Group Map empty");  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
    l_eStatus = eFrameworkunifiedStatusInvldParam;
    // LCOV_EXCL_STOP
  } else {
    BOOL l_bModuleFound = FALSE;
    for (; (FALSE == l_bModuleFound)
                && (l_GroupIterator != m_MapProclaunchGrps.end());
        l_GroupIterator++) {
      ModuleLaunchListIter l_ModuleListIterator =
            l_GroupIterator->second.modules.begin();
      for (; (FALSE == l_bModuleFound)
                    && (l_ModuleListIterator
                            != l_GroupIterator->second.modules.end());
            l_ModuleListIterator++) {
        if (l_ModuleListIterator->pid == f_pid) {
            l_bModuleFound = TRUE;
            f_ModuleName = l_ModuleListIterator->name;
            l_eStatus = eFrameworkunifiedStatusOK;
        }
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::GetBinaryNameOfProcess(SS_String f_ModuleQueueName,
    SS_String &f_ModuleBinaryName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  ModuleLaunchListIter l_moduleIter;

  f_ModuleBinaryName = "";
  l_eStatus = GetModuleIterator(f_ModuleQueueName.c_str(), l_moduleIter);
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    LOG_ERROR("GetModuleIterator()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    size_t l_pos = l_moduleIter->path.find_last_of("\\/");
    if (std::string::npos == l_pos) {  // LCOV_EXCL_BR_LINE 5: stdlib error case.
      // LCOV_EXCL_START 5: stdlib error case.
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error. Unable to parse binary name from path %s.",
          l_moduleIter->path.c_str());
      // LCOV_EXCL_STOP
    } else {
      f_ModuleBinaryName = l_moduleIter->path.substr(l_pos + 1);
      l_eStatus = eFrameworkunifiedStatusOK;
    }
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::init_process_launcher(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  UI_32 TODO = 0;

  FrameworkunifiedProtocolCallbackHandler process_launcher_protocol_callbacks[] = {
      // Command ID,                      Call back functions
      { ePLThrdCmd_LAUNCH_MODULE_RESP,    SysMgrCallback<CSystemManager,
                                          &CSystemManager::OnModuleLaunchResponse> },
      { ePLThrdCmd_TERMINATE_MODULE_RESP, SysMgrCallback<CSystemManager,
                                          &CSystemManager::OnTerminateModuleResponse> },
      { ePLThrdCmd_RELAUNCH_MODULE_RESP,  SysMgrCallback<CSystemManager,
                                          &CSystemManager::OnReLaunchModuleResponse> },
      { ePLThrdCmd_THREAD_STATUS_RESP,    SysMgrCallback<CSystemManager,
                                          &CSystemManager::OnProcessLauncherThreadHeartbeatResponse> } }; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  // setup call backs for my children
  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, SS_SMLauncher, process_launcher_protocol_callbacks, static_cast<UI_32>(_countof(process_launcher_protocol_callbacks))))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("FrameworkunifiedAttachCallbacksToDispatcher()");  // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
  ////////  Create Writer Child Threads handles the writing of data
  } else if (NULL == (m_hProcLauncherThread.m_ThreadHdl = FrameworkunifiedCreateChildThreadWithPriority(hApp, SS_SMLauncher, ProcessLauncherOnStart, ProcessLauncherOnStop, PR_SMPROCLAUNCH))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
    // LCOV_EXCL_START 4: For setting the initialization conditions at SystemManager startup
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusNullPointer;
    m_hProcLauncherThread.m_ThreadState = eSM_ThreadNotExist;
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: FrameworkunifiedCreateChildThreadWithPriority(%s) errored: %d/'%s'",
        SS_SMLauncher, l_eStatus, GetStr(l_eStatus).c_str());
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedStartChildThread(hApp, m_hProcLauncherThread.m_ThreadHdl, sizeof(UI_32), &TODO))) {  // LCOV_EXCL_BR_LINE 4:NSFW error case  //NOLINT (whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    m_hProcLauncherThread.m_ThreadState =  // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
        eSM_ThreadNotExist;  // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
    LOG_ERROR("FrameworkunifiedStartChildThread()");  // LCOV_EXCL_LINE 4: For setting the initialization conditions at SystemManager startup
  } else {
    m_hProcLauncherThread.m_ThreadState = eSMThreadIsFine;
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus CSystemManager::OnGroupLaunchWaitTimeout(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  SetCmdHist("SM_TIMER_GROUP_LAUNCH_WAIT_TIMER", m_TimerCmdHist, m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp)); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnModuleLaunchResponse(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_INFO, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  GroupLaunchMapIter l_GroupIter;
  ModuleLaunchListIter l_ModuleIter;
  UI_32 l_launchID = m_oSystemLauncher.get_id();

  l_eStatus = PerformModuleLaunchRespProcessing(hApp, l_GroupIter, l_ModuleIter, "ML");
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    LOG_ERROR("PerformModuleLaunchRespProcessing()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else if (l_GroupIter->second.id == l_launchID) {
    BOOL IsGroupLaunchComplete = TRUE;
    // Search the group for any module that has not completed launching.
    for (l_ModuleIter = l_GroupIter->second.modules.begin();
         IsGroupLaunchComplete && (l_ModuleIter != l_GroupIter->second.modules.end());
         l_ModuleIter++) {
      IsGroupLaunchComplete = !l_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING);
    }

    if (IsGroupLaunchComplete) {
      m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_GROUP_MONITOR]);
      l_GroupIter->second.launch_complete = TRUE;
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Group%d LaunchComp", l_GroupIter->second.id);

      if (!m_oSystemLauncher.is_end()) {
        l_launchID = m_oSystemLauncher.advance_id();
        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Next group:%d", l_launchID);
        if (FALSE == l_GroupIter->second.grp_wait_for_trigger) {
          UI_32 l_Sec = (l_GroupIter->second.grp_launch_wait) / (1000 * 1000);
          UI_32 l_mSec = 0;
          if (l_Sec > 0) {
              l_mSec = ((l_GroupIter->second.grp_launch_wait) % (1000 * 1000)) / 1000;
          } else {
              l_mSec = (l_GroupIter->second.grp_launch_wait) / 1000;
          }
          m_GroupLaunchTimer->StartTimer(
                  m_aTimerIDs[eSM_TIMER_GROUP_LAUNCH_WAIT_TIMER], l_Sec, l_mSec, 0, 0);
        } else {
          // Start the timer for group trigger... added for optimization
          m_GroupLaunchTimer->StartTimer(
                  m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER],
                  SS_LAUNCH_GROUP_TRIGGER_TIMER_CONFIG, 0, 0, 0);
        }
      }
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Group %d/%s LaunchIncomp", l_launchID,
          l_GroupIter->second.name.c_str());
    }
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
        " '%s' ( Group %d/%s ) Launch Response received late - "
                "group id is now %d", l_ModuleIter->name.c_str(),
        l_GroupIter->second.id, l_GroupIter->second.name.c_str()
        , l_launchID);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus CSystemManager::OnReLaunchModuleResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));

  GroupLaunchMapIter l_GroupIter;
  ModuleLaunchListIter l_ModuleIter;

  l_eStatus = PerformModuleLaunchRespProcessing(hApp, l_GroupIter, l_ModuleIter, "RL");
  LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "PerformModuleLaunchRespProcessing()");  // 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::OnReLaunchModuleResponse( HANDLE hApp )


EFrameworkunifiedStatus CSystemManager::PerformModuleLaunchRespProcessing(HANDLE hApp,
        GroupLaunchMapIter & f_GroupIter, ModuleLaunchListIter & f_ModuleIter,
        PCSTR p_sPPD_tag) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  T_ProcessLaunchResp l_LaunchRespData;

  // ReadMsg():                                                        *
  //     Check hApp ptr, msg size, msg reception, read msg if all ok.  *
  //     Report any errors found.                                      *
  //                                                                   *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < T_ProcessLaunchResp > (hApp, l_LaunchRespData))) {  // LCOV_EXCL_BR_LINE 4: nsfw error  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_LINE 4: nsfw error
  } else {
    BOOL b_DidModuleLaunch = FALSE;
    f_GroupIter = l_LaunchRespData.groupIterator;
    f_ModuleIter = l_LaunchRespData.moduleIterator;
    SS_String l_ModulePath = l_LaunchRespData.path;

    FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s(%d)", l_LaunchRespData.name, l_LaunchRespData.pid);

    if (l_LaunchRespData.pid == -1) {
      f_ModuleIter->pid = -1;

      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: Process launch failed: %s, %s",
          f_ModuleIter->name.c_str(), l_ModulePath.c_str());

      /// TODO
      /// If PID is -1, launch had failed. Add logic to do necessary action.

      f_ModuleIter->SetModuleState(MODULE_STATE_LAUNCH_FAILED);
    } else if (l_LaunchRespData.pid == 0x7FFFFFFF) {
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: '%s', '%s' already launched",
          f_ModuleIter->name.c_str(), l_ModulePath.c_str());

      b_DidModuleLaunch = TRUE;
    } else {
      f_ModuleIter->pid = l_LaunchRespData.pid;
      b_DidModuleLaunch = TRUE;
    }

    if (b_DidModuleLaunch) {
      //
      // Module state could already be MODULE_STATE_CONNECTED if
      // module process ran before process launcher thread completed;
      // don't overwrite/reset the MODULE_STATE_CONNECTED state.
      if (f_ModuleIter->IsModuleState(MODULE_STATE_LAUNCHING)) {
        f_ModuleIter->SetModuleState(MODULE_STATE_LAUNCHED);
      }

      l_eStatus = f_ModuleIter->GetPriority(f_ModuleIter->current_priority);
      if (eFrameworkunifiedStatusOK != l_eStatus) {
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning: f_ModuleIter->GetPriority( "
               "f_ModuleIter->current_priority ) returned %d/'%s'. "
               "Setting 'current_priority' = 'configuration_priority' %d.",
               l_eStatus, GetStr(l_eStatus).c_str(),
               f_ModuleIter->configuration_priority);
        f_ModuleIter->current_priority = f_ModuleIter->configuration_priority;
        l_eStatus = eFrameworkunifiedStatusOK;
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::PerformModuleLaunchRespProcessing(

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnTerminateModuleResponse
///
/// \param HANDLE hApp
///
/// \return EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnTerminateModuleResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;
  T_ProcessLauncherTerminationResp l_TerminateRespData;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, " from %s", FrameworkunifiedGetMsgSrc(hApp));

  // ReadMsg():                                                        *
  //     Check hApp ptr, msg size, msg reception, read msg if all ok.  *
  //     Report any errors found.                                      *
  //                                                                   *
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < T_ProcessLauncherTerminationResp
                       > (hApp, l_TerminateRespData))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    ModuleLaunchListIter l_ModuleIter = l_TerminateRespData.moduleIterator;

    SS_String l_ModulePath = m_BinaryFilesPath + l_ModuleIter->path;

    if ((0 == strcmp(l_ModulePath.c_str(), l_TerminateRespData.path))
        && (0 == strcmp(l_ModuleIter->arguments.c_str(),
                        l_TerminateRespData.args))) {
      l_ModuleIter->pid = 0;
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s Termination successful",
             l_ModuleIter->name.c_str());
    } else {
      if (0 != strcmp(l_ModulePath.c_str(), l_TerminateRespData.path)) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: ModuleIter->path != l_TerminateRespData.path"
            " \" '%s' != '%s' \"", l_ModuleIter->path.c_str(),
            l_TerminateRespData.path);
      }
      if (0 != strcmp(l_ModuleIter->arguments.c_str(),
                      l_TerminateRespData.args)) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: ModuleIter->arguments != "
            "l_TerminateRespData.args, \" '%s' != '%s' \"",
            l_ModuleIter->arguments.c_str(), l_TerminateRespData.args);
      }
    }
  }

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

///////////////////////////////////////////////////////////////////////
/// \ingroup ReadPathAndFileNameEnvironmentVariables
///
/// \param
///
/// \return VOID
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::ReadPathFromEnvironmentVariables() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  CHAR *l_pEnvVariable = NULL;

  // read Path from environment variable
  if (NULL == (l_pEnvVariable = std::getenv(BaseDirPathEnvVariable))) {
    // Environment variable not set, set it to default path
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default path for Binary Files : %s", DefaultBasePath);
    m_BinaryFilesPath = DefaultBasePath;

    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default path for Config Files : %s%s",
        DefaultBasePath, DefaultConfigFilesPath);
    m_ConfigFilesPath = DefaultBasePath;
  } else {
    // set path of binary files
    m_BinaryFilesPath = l_pEnvVariable;

    // set path of configuration files
    m_ConfigFilesPath = l_pEnvVariable;
  }
  // set path of configuration files
  m_ConfigFilesPath += DefaultConfigFilesPath;

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

///////////////////////////////////////////////////////////////////////
/// \ingroup GetConfigDataFileNameFromEnvironmentVariable
///
/// \param
///
/// \return SS_String
///////////////////////////////////////////////////////////////////////////////
SS_String CSystemManager::ReadLaunchConfigFileNameFromEnvironmentVariable() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  CHAR *l_pEnvVariable = NULL;
  SS_String l_FileName;

  // read Launch Config File Name from environment variable
  // LCOV_EXCL_BR_START 5: standard lib error
  if (NULL == (l_pEnvVariable = std::getenv(LaunchConfigFileNameEnvVariable))) {
  // LCOV_EXCL_BR_STOP
    // Environment variable not set, set it to default file name
    // LCOV_EXCL_START 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Using Default Launch Configuration file : %s",
        DefaultLaunchConfigFileName);
    l_FileName = DefaultLaunchConfigFileName;
    // LCOV_EXCL_STOP
  } else {
    l_FileName = l_pEnvVariable;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Using Launch Configuration file: %s", l_FileName.c_str());

  SS_String retStr = m_ConfigFilesPath + l_FileName; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  if (access(retStr.c_str(), F_OK) != 0) {  // LCOV_EXCL_BR_LINE 5: standard lib error
    // LCOV_EXCL_START 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "no found %s", retStr.c_str());
    SS_ASERT(0);
    // LCOV_EXCL_STOP
  }
  return retStr;
}

///////////////////////////////////////////////////////////////////////
/// \ingroup GetConfigDataFileNameFromEnvironmentVariable
///
/// \param
///
/// \return SS_String
///////////////////////////////////////////////////////////////////////////////
SS_String CSystemManager::ReadConfigDataFileNameFromEnvironmentVariable() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  CHAR *l_pEnvVariable = NULL;
  SS_String l_FileName = "";

  // read SM Config Data File Name from environment variable
  // LCOV_EXCL_BR_START 5: standard lib error
  if (NULL == (l_pEnvVariable = std::getenv(SMConfigDataFileNameEnvVariable))) {
  // LCOV_EXCL_BR_STOP 5: standard lib error
    // LCOV_EXCL_START 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    // Environment variable not set, set it to default file name
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Using Default Configuration Data file : %s", DefaultSMConfigFileName);
    l_FileName = DefaultSMConfigFileName;
    // LCOV_EXCL_STOP
  } else {
    l_FileName = l_pEnvVariable;
  }

  SS_String retStr = m_ConfigFilesPath + l_FileName; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  if (access(retStr.c_str(), F_OK) != 0) {  // LCOV_EXCL_BR_LINE 5: standard lib error
    // LCOV_EXCL_START 5: standard lib error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "no found %s", retStr.c_str());
    SS_ASERT(0);
    // LCOV_EXCL_STOP
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return retStr;
}

///////////////////////////////////////////////////////////////////////
/// \ingroup ReadUsingVMPlayerEnvironmentVariable
///
/// \param
///
/// \return VOID
///////////////////////////////////////////////////////////////////////////////
VOID CSystemManager::ReadUsingVMPlayerEnvironmentVariable() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  CHAR *l_pEnvVariable = std::getenv(UsingVMPlayerVariable);
  m_UsingVMPlayer = (NULL != l_pEnvVariable);
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %sunning on a VMPlayer",
      m_UsingVMPlayer ? "R" : "Not r");
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return;
}  // End of VOID CSystemManager::ReadUsingVMPlayerEnvironmentVariable()

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::start_process_launching(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  BOOL l_bIsGoodRc;
  SS_String l_SMConfigFile(ReadConfigDataFileNameFromEnvironmentVariable());
  SMConfigParams SMConfigData;
  SS_String l_LaunchConfigFile(ReadLaunchConfigFileNameFromEnvironmentVariable()); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  SysMgrConfiguration l_launchConfig;

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Reading %s Configuration Data from %s",
      SERVICE_SYSMANAGER, l_SMConfigFile.c_str());

  l_bIsGoodRc = SMConfigData.LoadSMConfigParameters(m_SMConfig, l_SMConfigFile);

  if (!l_bIsGoodRc) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
    // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: SMConfigData.LoadSMConfigParameters(m_SMConfig, "
                " %s) returned FALSE", l_SMConfigFile.c_str());
    l_eStatus = eFrameworkunifiedStatusFileLoadError;
    // LCOV_EXCL_STOP
  } else {
    SMSetState(hApp, SS_SM_APPS_LAUNCH_IN_PROGRESS);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Reading Launch Configuration Data from %s",
        l_LaunchConfigFile.c_str());

    SS_String l_launchOrderName = "DEFAULT";  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    LaunchOrderedVector l_OrderList;

    l_bIsGoodRc = l_launchConfig.LoadParametersCfg(m_MapProclaunchGrps,
        m_MapProcNames, l_OrderList, l_launchOrderName, l_LaunchConfigFile);

    if (l_OrderList.size() != 0) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "wakeup order:%s",
          l_launchOrderName.c_str());
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "wakeup order:DEFAULT");
    }

    if (!l_bIsGoodRc) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
      // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: l_launchConfig.LoadParametersCfg( "
          "m_MapProclaunchGrps, m_MapProcNames, %s ) returned FALSE",
          l_LaunchConfigFile.c_str());
      l_eStatus = eFrameworkunifiedStatusFileLoadError;
      // LCOV_EXCL_STOP
    } else {
      m_SystemLaunchProgress = SS_SM_INITIAL_GROUP;
      // l_launchConfig.PrintAllInfo( m_MapProclaunchGrps );

      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " System Launch Started");
      // Don't use DynamicLaunch because its dependency on the services table is complex
      SS_SOURCE source_type = SS_SOURCE_FM;

      m_oSystemLauncher.configure_dynamic_launch(source_type, m_MapProclaunchGrps, l_OrderList);
      m_oSystemLauncher.copyDynOrderedVector(m_SystemStarter);
      // m_SystemStarter.print_info();

      // start the timer upon successful launching of first process
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
          "Starting Module Connection Timeout timer with %d sec period",
          m_SMConfig.MCConfig.ModuleConnectionTimeOutSec);
      m_GroupLaunchTimer->StartTimer(
          m_aTimerIDs[eSM_TIMER_MODULE_CONNECT_WAIT_TIMER],
          m_SMConfig.MCConfig.ModuleConnectionTimeOutSec, 0,
          m_SMConfig.MCConfig.ModuleConnectionTimeOutSec, 0);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
      CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
    }
  }

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


EFrameworkunifiedStatus CSystemManager::GetLastSourceInfo(SS_SOURCE &source_type) {  // LCOV_EXCL_START 8: Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  CHAR LastSource[64 + 1] = { '\0' };
  l_eStatus = NPSynchronousReadPersistentData(SERVICE_AS_MODE,
              NTFY_SSLastSourceType, LastSource, static_cast<UI_32>(sizeof(LastSource) - 1));
  if (eFrameworkunifiedStatusOK != l_eStatus) {
    LOG_ERROR("NPSynchronousReadPersistentData("
              SERVICE_AS_MODE "," NTFY_SSLastSourceType);
  } else {
    std::string tempstr(LastSource);
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " String got from persistence %s", LastSource);
    UI_32 pos = static_cast<UI_32>(tempstr.find("_"));
    std::string tempstr2 = tempstr.substr(0, pos);
    UI_64 value = strtoull(tempstr2.c_str(), 0, 10);
    source_type = static_cast<SS_SOURCE>((UI_32)(value >> 32) & 0x0000FFFF);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus CSystemManager::OnLaunchGroupTriggerProcessResponse(HANDLE hApp) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
  UI_32 l_groupID;

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
  SetCmdHist("SS_SM_GROUP_LAUNCH_TRIGGER", m_SMCmdHist, m_SMHistIter, FrameworkunifiedGetMsgSrc(hApp));
  // stop group launch trigger process response timer
  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_LAUNCH_GROUP_TRIGGER_PROC_RESP_TIMER]);

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < UI_32 > (hApp, l_groupID))) {
    LOG_ERROR("ReadMsg()");
  } else {
    SS_SOURCE source_type = SS_SOURCE_NA;
    l_eStatus = GetLastSourceInfo(source_type);

    if ((SS_SOURCE_AM == source_type) || (SS_SOURCE_FM == source_type)
     || (SS_SOURCE_FM_DAB == source_type) || (SS_SOURCE_SDARS == source_type)) {
      if (l_groupID == m_oSystemLauncher.get_id()) {
        CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
      } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: Received Group ID %d != Sys Mgr Group ID %d", l_groupID,
            m_oSystemLauncher.get_id());
        l_eStatus = eFrameworkunifiedStatusInvldParam;
     }
    } else {  // media is last source
      CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));
    }
  }

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

EFrameworkunifiedStatus CSystemManager::OnLaunchGroupTriggerProcessResponseTimerExpiry(HANDLE hApp) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
  REC_HIST_IF_SUCCESSFUL("SM_TIMER_LAUNCH_GROUP_TRIGGER", m_TimerCmdHist,
                         m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
  CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnLaunchGroupSelfTrigger(HANDLE hApp) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

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

  REC_HIST_IF_SUCCESSFUL("SS_SM_SendTriggerToSelf", m_SMCmdHist, m_SMHistIter,
                         FrameworkunifiedGetMsgSrc(hApp), l_eStatus);

  CALL_AND_LOG_STATUS(OnLaunchGroup(hApp));

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup
///
/// \param
///
/// \return
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnLaunchGroup(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  GroupLaunchMapIter l_GroupIter;
  UI_32 l_launch_ID = m_oSystemLauncher.get_id();

  //  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Launching group %d", l_launch_ID );

  l_GroupIter = m_MapProclaunchGrps.find(l_launch_ID);

  if (l_GroupIter->second.launch_complete == FALSE) {  // LCOV_EXCL_BR_LINE 6: Because it is not called for a condition that results in "TRUE"
    // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__
    //     , " m_bIsNPP_ServicesStarted ? %s, group.id: %d, Launch_Group: %d"
    //     , m_bIsNPP_ServicesStarted ? "Yes" : "No"
    //     , l_GroupIter->second.id
    //     , m_SystemLaunchProgress );

    if ((m_bIsNPP_ServicesStarted && m_bIsBackupAvail) || (l_GroupIter->second.id <= 2)) {  // LCOV_EXCL_BR_LINE 6: Because it is not called for the condition that results in "FALSE" // NOLINT(whitespace/line_length)
      ModuleLaunchListIter l_ModuleListIterator = l_GroupIter->second.modules.begin();
      if (l_ModuleListIterator != l_GroupIter->second.modules.end()) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
        // FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "GRPLCH,(start),%d,%s",
        //        l_GroupIter->second.id,l_GroupIter->second.name.c_str());

        FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Launching Group%d/%s",
            l_GroupIter->second.id, l_GroupIter->second.name.c_str());
        SS_String l_ModulePath;
        for (; l_ModuleListIterator != l_GroupIter->second.modules.end(); l_ModuleListIterator++) {
          if (l_ModuleListIterator->IsModuleState(MODULE_STATE_INVALID)) {
            char l_cFormat[] = "SendRequestToLauncher(%s, "
                    "ePLThrdCmd_LAUNCH_MODULE_REQST)";
            char l_cBuf[sizeof(l_cFormat) + MAX_NAME_SIZE_APP];
            snprintf(l_cBuf, sizeof(l_cBuf), l_cFormat,
                    l_ModuleListIterator->name.c_str());

            l_eStatus = SendRequestToLauncher(hApp, l_ModuleListIterator,  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
                    ePLThrdCmd_LAUNCH_MODULE_REQST,  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
                    "ePLThrdCmd_LAUNCH_MODULE_REQST");  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

            if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
              // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
              AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
              l_ModuleListIterator->SetModuleState(
                      MODULE_STATE_LAUNCH_FAILED);
              SetCmdHist(l_cBuf, m_ErrHist, m_ErrHistIter,
                      GetStr(l_eStatus).c_str());
              // LCOV_EXCL_STOP
            } else {
              l_ModuleListIterator->SetModuleState(MODULE_STATE_LAUNCHING);
            }
          } else {
            l_ModulePath = (m_BinaryFilesPath + l_ModuleListIterator->path);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
            FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
                    " Not launching %s: module state is %s",
                    l_ModulePath.c_str(),
                    l_ModuleListIterator->ModuleStateStr().c_str());
          }
        }

        // LCOV_EXCL_BR_START 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
        if (FALSE ==
            l_GroupIter->second.grp_wait_for_trigger) {
        // LCOV_EXCL_BR_STOP
          m_GroupLaunchTimer->StartTimer(m_aTimerIDs[eSM_TIMER_GROUP_MONITOR],
                  SS_GROUP_LAUNCH_TIMER_CONFIG, 0, 0, 0);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        }
      }
    }

    if (m_oSystemLauncher.is_end()) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "System Launch Completed");

      if (epssusSYSTEM_SERVICES_STARTED == m_SystemModeInfo.startupStage) {
        // If startupStage == SYSTEM_SERVICES_STARTED, a notification is requested because there are SVCs required for notification to the _CWORD56_.
        l_eStatus = SendSystemModeInfoResponse(hApp, epssusALL_SERVICES_LAUNCHED);
        LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
            "UpdateStartupStageState_SendSystemModeInfoResponse"  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
            "( epssusALL_SERVICES_LAUNCHED )");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
      }

      m_SystemModeInfo.startupStage = epssusALL_SERVICES_LAUNCHED;

      if (is_current_state(SS_SM_APPS_LAUNCH_IN_PROGRESS)) {
         SMSetState(hApp, SS_SM_APPS_LAUNCHED_READY_TO_START);
      }
      // SysMgrConfiguration config;
      // config.PrintAllInfo( m_MapProclaunchGrps );
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnLaunchGroup(HANDLE hApp)

///////////////////////////////////////////////////////////////////////////////
/// \ingroup    OnProcessLaunchTimerExpiry
///
/// \param      HANDLE hApp
///
/// \return     EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnProcessLaunchTimerExpiry(HANDLE hApp) {  // LCOV_EXCL_START 8:  Because the condition cannot be set
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  // ToDo 2013_05_17 Jay When used ? Dead code ? Don't see a StartTimer call.
  REC_HIST_IF_SUCCESSFUL("SM_TIMER_PROCESS_LAUNCH_MONITOR", m_TimerCmdHist,
                         m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
  m_GroupLaunchTimer->StopTimer(m_aTimerIDs[eSM_TIMER_PROCESS_LAUNCH_MONITOR]);
  return eFrameworkunifiedStatusOK;
}
// LCOV_EXCL_STOP

///////////////////////////////////////////////////////////////////////////////
/// \ingroup    OnHeartBeatMonitorTimerExpiry
///
/// \param      HANDLE hApp
///
/// \return     EFrameworkunifiedStatus
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnHeartBeatMonitorTimerExpiry(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, " Received from %s", FrameworkunifiedGetMsgSrc(hApp));
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
  REC_HIST_IF_SUCCESSFUL("SM_TIMER_HEARTBEAT_MONITOR", m_TimerCmdHist,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
                         m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  // LCOV_EXCL_BR_START 4: nsfw error
  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hHeartbeatThread.m_ThreadHdl,
                      SS_HEARTBEAT_PERIODIC_STATUS_REQ, 0, NULL))) {
  // LCOV_EXCL_BR_STOP 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("FrameworkunifiedSendChild(m_hHeartbeatThread.m_ThreadHdl, "  // LCOV_EXCL_LINE 4: nsfw error
              "SS_HEARTBEAT_PERIODIC_STATUS_REQ)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    m_hHeartbeatThread.m_ThreadState = eSMWaitForHeartbeat;
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup SystemManagerDebugDump
///     implement post mortem function
///
/// \param
///
/// \return void
///////////////////////////////////////////////////////////////////////////////

VOID CSystemManager::SystemManagerDebugDump(HANDLE hApp) {
  std::stringstream l_debugDumpBuf;
  cmdHistIter i;

  // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
  l_debugDumpBuf << FrameworkunifiedGetAppName(hApp) << "/" << endl
      << " <SYSTEM MANAGER DUMP DATA> " << endl << endl << " ***internals*** " << endl
      << endl << " SM state: "
      << GetStr(m_SMCurrentState).c_str() << endl << " SM  startup reason: "
      << GetStr(m_StartUpReason).c_str() << endl << " SM shutdown reason: "
      << GetStr(m_shutdownTrigger).c_str() << endl << " LUM: "
      << GetStr(m_lastUserMode).c_str() << endl << " TPM: "
      << GetStr(m_SystemModeInfo.transportMode).c_str() << endl << " LPH: "
      << GetStr(m_SystemModeInfo.limpHomeCutoff).c_str() << endl << " PMode: "
      << GetStr(m_SystemModeInfo.productionMode).c_str() << endl << " ActiveGroup: "
      << m_ActiveGroupId << endl << " m_MaxShutdownTime: " << m_MaxShutdownTime
      << endl << " NPP: " << (m_bIsNPP_ServicesStarted ? "Started" : "notStarted")
      << endl
      << endl << " ***Error history***" << endl;
  // LCOV_EXCL_BR_STOP

  for (i = m_ErrHist.begin(); i != m_ErrHist.end(); ++i) {
    l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        << "ms EC:" << i->m_sender.c_str() << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  l_debugDumpBuf << endl << " ***_CWORD56_ command history***" << endl;

  for (i = m__CWORD56_CmdHist.begin(); i != m__CWORD56_CmdHist.end(); ++i) {
    l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms" << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  l_debugDumpBuf << endl << " ***Timer history***" << endl;

  for (i = m_TimerCmdHist.begin(); i != m_TimerCmdHist.end(); ++i) {
    l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms" << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  l_debugDumpBuf << endl << " ***SM message history***" << endl;

  for (i = m_SMCmdHist.begin(); i != m_SMCmdHist.end(); ++i) {
    l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms "  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        << i->m_sender.c_str() << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  l_debugDumpBuf << endl << " ***Publishshing history***" << endl;

  for (i = m_PubCmdHist.begin(); i != m_PubCmdHist.end(); ++i) {
    l_debugDumpBuf << endl << " " << i->m_cmd.c_str() << " @ " << i->m_time << "ms "  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        << i->m_sender.c_str() << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  l_debugDumpBuf << endl << " ***SM start table***" << endl;    // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
  l_debugDumpBuf << endl
    << " index | name | start required? | isOKFlag | Module state | start sent "
        "| start resposne received |start delta | stop sent | reply received | stop delta | PID"
    << endl;
  // LCOV_EXCL_BR_STOP

  for (UI_32 k = 1u; (k <= m_MapProclaunchGrps.size()); k++) {
    GroupLaunchMapIter l_GroupIterator = m_MapProclaunchGrps.find(k);

    if (l_GroupIterator != m_MapProclaunchGrps.end()) {
      ModuleLaunchListIter l_ModuleListIterator = l_GroupIterator->second.modules.begin();

      for (int i = 1u; l_ModuleListIterator != l_GroupIterator->second.modules.end();
            l_ModuleListIterator++, i++) {
      // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
        std::string sIsOKFlag = GetModuleCondition(l_ModuleListIterator) ? " " :  // 'blank' means OK
                "X";  // 'X' means state mismatch

        l_debugDumpBuf << " " << std::setw(2) << std::right << i << " | "
            << std::setw(24) << std::left << l_ModuleListIterator->name.c_str()
            << " | " << std::setw(5) << std::left
            << (l_ModuleListIterator->is_start_required ? "TRUE" : "FALSE")

            << " | " << sIsOKFlag.c_str() << " | " << std::setw(24) << std::left
            << l_ModuleListIterator->ModuleStateStr().c_str() << " | "
            << l_ModuleListIterator->m_startReason.GetInitial() << " | "
            << l_ModuleListIterator->m_startReason.GetFinal() << " | "
            << std::setw(3) << std::right
            << static_cast<SI_16>(l_ModuleListIterator->m_startReason.GetDelta())
            << "ms" << " | " << l_ModuleListIterator->m_stopReason.GetInitial()
            << " | " << l_ModuleListIterator->m_stopReason.GetFinal() << " | "
            << std::setw(3)
            << static_cast<SI_16>(l_ModuleListIterator->m_stopReason.GetDelta())
            << "ms" << " | " << l_ModuleListIterator->pid << endl;
      // LCOV_EXCL_BR_STOP
      }
    }
  }

  l_debugDumpBuf << endl << " ***Heartbeat information***" << endl;

  l_debugDumpBuf << endl << " Entire State:" << m_HBReport.eEntireState << endl;  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  l_debugDumpBuf << endl << " Number of Modules:" << m_HBReport.nNumOfModules << endl;

  for (UI_32 j = 0; j < m_HBReport.nNumOfModules; j++) {  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    // 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
    if (0 != m_HBReport.tModuleList[j].HeartBeatRetryCount) {
      l_debugDumpBuf << endl << " " << m_HBReport.tModuleList[j].ProcQueueName << ","
          << m_HBReport.tModuleList[j].ProcHBState << ", "
          << m_HBReport.tModuleList[j].HeartBeatRetryCount << endl;
    }
    // LCOV_EXCL_STOP
  }

  std::string l_debugDumpStr = l_debugDumpBuf.str();

  SendDebugDumpResponseToSystemManager(l_debugDumpStr);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup   OnProcessLaunchMonitorTimerExpiry
///           This sends request to launcher thread to confirm that it
///           is still responsive.
///
/// \param [in] hApp
///         HANDLE - Handle of the Client Application
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnProcessLaunchMonitorTimerExpiry(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Received from %s", FrameworkunifiedGetMsgSrc(hApp));
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  REC_HIST_IF_SUCCESSFUL("TIMER_PROCESSLAUNCHER_MONITOR", m_TimerCmdHist,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
        m_TimerHistIter, FrameworkunifiedGetMsgSrc(hApp), l_eStatus);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  // LCOV_EXCL_BR_START 4: nsfw error
  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hProcLauncherThread.m_ThreadHdl,
        ePLThrdCmd_THREAD_STATUS_REQST, 0, NULL))) {
  // LCOV_EXCL_BR_STOP 4: nsfw error
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("FrameworkunifiedSendChild(m_hProcLauncherThread.m_ThreadHdl,"  // LCOV_EXCL_LINE 4: nsfw error
        "ePLThrdCmd_THREAD_STATUS_REQST)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    m_hProcLauncherThread.m_ThreadState = eSMWaitForHeartbeat;
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup  SendRequestToLauncher
///           This function is used for sending request to launcher thread from
///           System Manager.
///
/// \param HANDLE hApp
///      ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
///        ESMPLThreadCommandIds f_CommandId         => command id to send
///        SS_String f_ModulePath                    => Path of the Module
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::PerformLaunchProcedure(HANDLE hApp,
  ModuleLaunchListIter f_ModuleIterator, SS_String & f_stopCompName) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  SS_String s_ModuleStatus2;

  // Register for Stop Complete notification
  if (!f_ModuleIterator->shutdown_critical) {
    s_ModuleStatus2 = "is not shutdown_critical";
  // LCOV_EXCL_BR_START 6: For setting the initialization conditions at SystemManager startup

  } else if (eFrameworkunifiedStatusOK != (l_eStatus =
      FrameworkunifiedSubscribeNotificationWithCallback(
                hApp,
                f_stopCompName.c_str(),
                SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStopCompleteNotification>))) {
  // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
         " Error: FrameworkunifiedSubscribeNotificationWithCallback(hApp, %s) errored: %d/'%s'",
    f_stopCompName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());

    s_ModuleStatus2 = "is shutdown_critical but errored";
    // LCOV_EXCL_STOP
  } else {
    s_ModuleStatus2 = f_stopCompName + " is now registered";  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  }

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", s_ModuleStatus2.c_str());

  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup   PerformTerminateProcedure
///           Perform Procedure for Service Terminate.
///
/// \param HANDLE hApp
///        ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
///        SS_String & f_availabilityName            => Availability Name
///        SS_String & f_stopCompName                => Stop Complete Notification Name
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::PerformTerminateProcedure(HANDLE hApp,
        ModuleLaunchListIter f_ModuleIterator, SS_String & f_availabilityName,
        SS_String & f_stopCompName) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  // close session
  f_ModuleIterator->SetModuleState(MODULE_STATE_INVALID);
  f_ModuleIterator->pid = 0;
  if (NULL != f_ModuleIterator->hsession) {  // LCOV_EXCL_BR_LINE 200:hsession must not be NULL.
    l_eStatus = FrameworkunifiedMcClose(f_ModuleIterator->hsession);  // LCOV_EXCL_BR_LINE 4: nsfw error
    if (eFrameworkunifiedStatusOK != l_eStatus) {  // 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: FrameworkunifiedMcClose(%s) errored: %d/'%s'",
          f_ModuleIterator->name.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
      // LCOV_EXCL_STOP
    }
    f_ModuleIterator->hsession = NULL;
  }

  // Availability
  if (f_ModuleIterator->is_start_required) {
    // Initialize Availability
    HANDLE pPublishMq = McOpenSender(FRAMEWORKUNIFIED_NS_NPSERVICE);  // LCOV_EXCL_BR_LINE 4: nsfw error
    if (NULL == pPublishMq) {  // LCOV_EXCL_BR_LINE 4: nsfw error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      SS_ASERT(0);  // LCOV_EXCL_LINE 4: nsfw error
    } else {
      ServiceAvailability tServiceAvailability;

      snprintf(tServiceAvailability.cServiceName, MAX_NAME_SIZE_APP, "%s",
          f_ModuleIterator->name.c_str());
      tServiceAvailability.eServiceAvailability = eFrameworkunifiedServiceNotAvailable;

      l_eStatus = NPPublishNotification(pPublishMq, f_ModuleIterator->name.c_str(),  // LCOV_EXCL_BR_LINE 4: nsfw error
                  f_availabilityName.c_str(), &tServiceAvailability,  // LCOV_EXCL_BR_LINE 4: nsfw error
        sizeof(tServiceAvailability));  // LCOV_EXCL_BR_LINE 4: nsfw error
      if (eFrameworkunifiedStatusOK != l_eStatus) {  // 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: NPPublishNotification(%s)",
            f_availabilityName.c_str());
        // LCOV_EXCL_STOP
      }

      l_eStatus = McClose(pPublishMq);  // LCOV_EXCL_BR_LINE 4: nsfw error
      if (eFrameworkunifiedStatusOK != l_eStatus) {
        // 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
      }
    }
  }

  if (f_ModuleIterator->shutdown_critical) {
    // Unregister Stop Complete notification
    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedUnsubscribeNotificationWithCallback(hApp, f_stopCompName.c_str()))) {  // LCOV_EXCL_BR_LINE 4: nsfw error  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_START 4: nsfw error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: FrameworkunifiedUnsubscribeNotificationWithCallback(hApp, %s) errored: %d/'%s'",
          f_stopCompName.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
      // LCOV_EXCL_STOP
    } else {
      SS_String s_ModuleStatus2 = f_stopCompName + " is now unregistered ";
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "%s", s_ModuleStatus2.c_str());
    }
  }

  return l_eStatus;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup  SendRequestToLauncher
///           This function is used for sending request to launcher thread from
///           System Manager.
///
/// \param HANDLE hApp
///      ModuleLaunchListIter f_ModuleListIterator => iterator node from map for the module
///        ESMPLThreadCommandIds f_CommandId         => command id to send
///        SS_String f_ModulePath                    => Path of the Module
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::SendRequestToLauncher(HANDLE hApp,
        ModuleLaunchListIter f_ModuleIterator, ESMPLThreadCommandIds f_CommandId,
        SS_String f_CommandIdStr) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  SS_String l_ModulePath = m_BinaryFilesPath + f_ModuleIterator->path;

  T_ProcessLauncherLaunchReq l_ModuleLaunchReq = { };
  strcpy(l_ModuleLaunchReq.name, f_ModuleIterator->name.c_str());  // NOLINT
  strcpy(l_ModuleLaunchReq.path, l_ModulePath.c_str());  // NOLINT
  strncpy(l_ModuleLaunchReq.args, f_ModuleIterator->arguments.c_str(),  // NOLINT
  sizeof(l_ModuleLaunchReq.args) - 1);
  strcpy(l_ModuleLaunchReq.logging_mask,  // NOLINT
  f_ModuleIterator->logging_msk_str.c_str());
  l_ModuleLaunchReq.priority = f_ModuleIterator->configuration_priority;
  l_ModuleLaunchReq.cpu_assign = f_ModuleIterator->cpu_assign;
  l_ModuleLaunchReq.groupIterator = m_MapProclaunchGrps.find(
  f_ModuleIterator->group_id);
  l_ModuleLaunchReq.moduleIterator = f_ModuleIterator;

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
      "Queue:%s, path:%s, args:%s, lmsk:%s, prio:%d, cmd:%s", l_ModuleLaunchReq.name,
  l_ModuleLaunchReq.path, l_ModuleLaunchReq.args, l_ModuleLaunchReq.logging_mask,
  l_ModuleLaunchReq.priority, f_CommandIdStr.c_str());

  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendChild(hApp, m_hProcLauncherThread.m_ThreadHdl, f_CommandId, sizeof(l_ModuleLaunchReq), reinterpret_cast<void *>(&l_ModuleLaunchReq)))) {  // LCOV_EXCL_BR_LINE 4: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied // NOLINT(whitespace/line_length)
    // LCOV_EXCL_START 4: Because an initialization condition is set at SystemManager startup and the branching condition cannot be satisfied
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: FrameworkunifiedSendChild( %s, %s ) errored: %d/'%s'", l_ModulePath.c_str(),
        f_CommandIdStr.c_str(), l_eStatus, GetStr(l_eStatus).c_str());
    // LCOV_EXCL_STOP
  } else {
    SS_String l_availabilityName = f_ModuleIterator->name + "/Availability";  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    SS_String l_stopCompName = f_ModuleIterator->name + "/StopComp";  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
    // Perform command-specific processing
    switch (f_CommandId) {  // LCOV_EXCL_BR_LINE 6: Because the case is fixed on the call from the SystemManager::Initialize
      // LCOV_EXCL_START 6: Because the case is fixed on the call from the SystemManager::Initialize
      case ePLThrdCmd_RELAUNCH_MODULE_REQST:
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        l_eStatus = PerformTerminateProcedure(hApp, f_ModuleIterator,
                    l_availabilityName, l_stopCompName);
        if (eFrameworkunifiedStatusOK != l_eStatus) {
          SS_ASERT(0);
        }

        l_eStatus = PerformLaunchProcedure(hApp, f_ModuleIterator, l_stopCompName);
        if (eFrameworkunifiedStatusOK != l_eStatus) {
          SS_ASERT(0);
        }
        break;
      // LCOV_EXCL_STOP

      case ePLThrdCmd_LAUNCH_MODULE_REQST:
        l_eStatus = PerformLaunchProcedure(hApp, f_ModuleIterator, l_stopCompName);
        if (eFrameworkunifiedStatusOK != l_eStatus) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          SS_ASERT(0);  // LCOV_EXCL_LINE 6: For setting the initialization conditions at SystemManager startup
        }
        break;

      case ePLThrdCmd_TERMINATE_MODULE_REQST:
        l_eStatus = PerformTerminateProcedure(hApp, f_ModuleIterator,
                    l_availabilityName, l_stopCompName);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        if (eFrameworkunifiedStatusOK != l_eStatus) {
          SS_ASERT(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
        }
        break;

      // LCOV_EXCL_START 6: Because the case is fixed on the call from the SystemManager::Initialize
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      case ePLThrdCmd_LAUNCH_MODULE_RESP:
      case ePLThrdCmd_MODULE_STATUS_REQST:
      case ePLThrdCmd_RELAUNCH_MODULE_RESP:
      case ePLThrdCmd_TERMINATE_MODULE_RESP:
      case ePLThrdCmd_THREAD_STATUS_REQST:
      case ePLThrdCmd_THREAD_STATUS_RESP:
      case ePLThrdCmd_NONE:
        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.
      // LCOV_EXCL_STOP
    }
  }

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup RemoveModuleEntryFromHB
///          This function is called to send module information to heart beat thread
///          which is to be removed from its list of services to be monitored.
///
/// \param   HANDLE hApp,
///      const CHAR *f_ModuleName  => Module Name
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::RemoveModuleEntryFromHB(HANDLE hApp, const CHAR *f_ModuleName) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  HBListIter l_HBIter = std::find(m_HBList.begin(), m_HBList.end(), f_ModuleName);
  if (l_HBIter != m_HBList.end()) {
    m_HBList.erase(l_HBIter);
  }

  TSMRequestMessage l_ModuleDetails;
  strncpy(l_ModuleDetails.pstModuleName, f_ModuleName,
          sizeof(l_ModuleDetails.pstModuleName) - 1);
  l_ModuleDetails.pstModuleName[sizeof(l_ModuleDetails.pstModuleName) - 1] = '\0';
  l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_DELETE_MODULE_ENTRY,
                &l_ModuleDetails, sizeof(TSMRequestMessage));

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}
///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnHeartBeatThreadHeartbeatResponse
///          This function gets called when heart beat thread replies the
///          heart beat query sent by the System Manager.
/// \param [in] hApp
///         HANDLE - Handle of the Client Application
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnHeartBeatThreadHeartbeatResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, "HeartBeat HeartBeat Received");
  m_hHeartbeatThread.m_ThreadState = eSMThreadIsFine;
  return eFrameworkunifiedStatusOK;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnCheckAvailResponse
///          This function gets service's availability status from HBThread
/// \param [in] hApp
///         HANDLE - Handle of the Client Application
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnCheckAvailResponse(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  THbAvailCheck result;

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < THbAvailCheck > (hApp, result))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_tempaltes.h // NOLINT(whitespace/line_length)
  } else if (result.isOk == FALSE) {
  }
  return eFrameworkunifiedStatusOK;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnProcessLauncherThreadHeartbeatResponse
///          This function gets called when launcher thread replies the
///          heart beat query sent by the System Manager.
/// \param [in] hApp
///         HANDLE - Handle of the Client Application
///
/// \return Status
///         EFrameworkunifiedStatus - success or error
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnProcessLauncherThreadHeartbeatResponse(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_PERIODIC_INFO, __FUNCTION__, "ProcessLaunch HeartBeat Received");
  m_hProcLauncherThread.m_ThreadState = eSMThreadIsFine;
  return eFrameworkunifiedStatusOK;
}

///////////////////////////////////////////////////////////////////////////////
/// \ingroup RegisterCallbacksForRequester
/// Register callbacks for External Protocol commands
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::RegisterCallbacksForRequester(HANDLE hApp, PCSTR f_pRequester) {
  EFrameworkunifiedStatus l_eStatus;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  // Attach Session Protocol messages.
  FrameworkunifiedProtocolCallbackHandler l_sm_protocol_handlers[] = {
    // Command ID,              Call back functions
     { SS_SM_START_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
     { SS_SM_STOP_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStopCompleteResponse> },
     { SS_SM_PRE_START_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
     { SS_SM_PRE_STOP_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
     { SS_SM_BACKGROUND_START_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
     { SS_SM_BACKGROUND_STOP_COMPL_RSPN,
         SysMgrCallback<CSystemManager, &CSystemManager::OnModuleStartCompleteResponse> },
    { SS_SM_GET_START_EXT_INFO, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnGetStartExtInfo> },
    { SS_SM_GET_STOP_EXT_INFO,  SysMgrCallback<CSystemManager,
                                &CSystemManager::OnGetStopExtInfo> },
    { SS_SM_CRNT_STATE_QUERY,   SysMgrCallback<CSystemManager,
                                &CSystemManager::OnCurrentSMStateQuery> },
    { SS_SM_DATA_RESET_MODE_SET_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnSetDataResetModeRequest> },
    { SS_SM_PROG_UPDATE_STATE_SET_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnSetProgUpdateStateRequest> },

    { SS_SM__CWORD56__HEARTBEAT_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::On_CWORD56_HeartBeatRequest> },
    { SS_SM_NEXT_WAKEUP_TYPE_SET_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnSetNextWakeupTypeRequest> },
      // Error Event Logging
    { SS_SM_ERROR_EVENT_LOGGING_START_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnLoggingStartRequest> },
    { SS_SM_ERROR_EVENT_ARTIFACT_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnErrorEventArtifactRequest> },
    { SS_SM_ERROR_EVENT_LOGGING_COMPLETE, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnErrorEventLoggingComplete> },
    { SS_SM_DEBUG_DUMP_RSPN,    SysMgrCallback<CSystemManager,
                                &CSystemManager::OnDebugDumpResponseReceived> },
    { SS_SM_PROPAGATE_SYSTEM_ERROR, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnPropagateSystemError> },
    { SS_SM_BOOT_MICRO_RESET_NTF,   SysMgrCallback<CSystemManager,
                                &CSystemManager::OnBootMicroResetNotification> },
    { SS_SM_BOOT_MICRO_LOG_RSP, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnBootMicroLogResponse> },
    { SS_SM_USER_INVOKED_LOG_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnUserInvokedLoggingRequest> },
    { SS_SM_ERROR_EVENT_EEL_EXPORT_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnEelExportRequest> },
    { SS_SM_ERROR_EVENT_INTERFACEUNIFIED_EMMC_LOGS_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnSystemmanagerEmmcLogsRequest> },
    { SS_SM_ERROR_EVENT_CLR_LOGS_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnSystemmanagerClearLogsRequest> },
    { SS_SM_ERROR_EVENT_DIAG_LOG_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnDiagLoggingRequest> },
    { SS_SM_ERROR_EVENT_CAN_LOG_REQ, SysMgrCallback<CSystemManager,
                                &CSystemManager::OnCANLoggingRequest> } };  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

    l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(hApp, f_pRequester,
                l_sm_protocol_handlers, static_cast<UI_32>(_countof(l_sm_protocol_handlers)));  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup open_session_with_sm_test_client
/// Process request to open session with sm test client
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::open_session_with_sm_test_client(HANDLE hApp, PCSTR pRequester) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  UI_32 const l_ui32DefaultSessionID = 0;
  OpenSessionAck tOpenAck = { };

/*
 * Here pRequester is SMTesteClient with whom session is opened and its handle is stored in m_hPowerServiceSession handle.
 * This case comes only while testing SystemManager through SMTestClient (PowerService should not be running).
 */
  // Validate session handle
  if (NULL == m_hPowerServiceSession) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Session Handle NULL, calling FrameworkunifiedMcOpenSender for %s", pRequester);

    m_hPowerServiceSession = FrameworkunifiedMcOpenSender(hApp, pRequester);
  //
  // Set the Session Handle for Framework so FrameworkunifiedSendResponse won't error due to a null
  // session handle.
  //
    // LCOV_EXCL_BR_START 4:NSFW's error
    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSetSessionHandle(hApp,
        pRequester,                  // [in] PCSTR - Name of the associated service name
        m_hPowerServiceSession))) {  // [in] HANDLE - Session handle
    // LCOV_EXCL_BR_STOP
      // LCOV_EXCL_START 4:NSFW's error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: FrameworkunifiedSetSessionHandle(%s) errored: %d/'%s'", pRequester,
          l_eStatus, GetStr(l_eStatus).c_str());
      FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
      return l_eStatus;
      // LCOV_EXCL_STOP
    }
  }

  if (m_hPowerServiceSession == NULL) {  // LCOV_EXCL_BR_LINE 200:m_hPowerServiceSession must not be NULL
    // LCOV_EXCL_START 200:m_hPowerServiceSession must not be NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Invalid Session Handle to service (%s) ", pRequester);
    // LCOV_EXCL_STOP
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Session opened with %s", pRequester);

    // Copy session name to data structure
    strncpy(tOpenAck.cSessionName, FrameworkunifiedGetAppName(hApp),
            sizeof(tOpenAck.cSessionName) - 1);
    tOpenAck.eStatus = eFrameworkunifiedStatusOK;
    tOpenAck.sessionId = l_ui32DefaultSessionID;

    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "About to send Open Session ACK");
    // send OpenSession ACK
    // LCOV_EXCL_BR_START 4:NSFW's error
    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(m_hPowerServiceSession,
            PROTOCOL_OPEN_SESSION_ACK, sizeof(OpenSessionAck),
            (PVOID) & tOpenAck))) {
    // LCOV_EXCL_BR_STOP
      // LCOV_EXCL_START 4:NSFW's error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      LOG_ERROR("FrameworkunifiedSendMsg(PROTOCOL_OPEN_SESSION_ACK)");

      // Close the message queue handle
      if (NULL != m_hPowerServiceSession) {
        CALL_AND_LOG_STATUS_IF_ERRORED(FrameworkunifiedMcClose(m_hPowerServiceSession));
        m_hPowerServiceSession = NULL;
      }
      // LCOV_EXCL_STOP
    } else {
      CALL_AND_LOG_STATUS_IF_ERRORED(RegisterCallbacksForRequester(hApp, pRequester));
    }
  }  // end of else block of if(l_ModuleListIterator->hsession == NULL)

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

///////////////////////////////////////////////////////////////////////////////
/// \ingroup OnOpenSession
/// Process request to open session
///
/// \param [in]
///
///
/// \return EFrameworkunifiedStatus
/// Success ==> eFrameworkunifiedStatusOK
/// Failure ==> Other values
///////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnOpenSession(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  UI_32 const l_ui32DefaultSessionID = 0;
  UI_32 const l_ui32DefaultSessionType = 0;
  OpenSessionAck tOpenAck = { };
  PCSTR pRequester = FrameworkunifiedGetMsgSrc(hApp);
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "%s", pRequester);

  ModuleLaunchListIter l_ModuleListIter;

  REC_HIST_IF_SUCCESSFUL("PROTOCOL_OPEN_SESSION_REQ", m_SMCmdHist, m_SMHistIter,  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)
    FrameworkunifiedGetMsgSrc(hApp), l_eStatus);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_system_manager.h  // NOLINT(whitespace/line_length)

  l_eStatus = GetModuleIterator(pRequester, l_ModuleListIter);

  if (eFrameworkunifiedStatusOK != l_eStatus) {
    // Special handling for open session request from SMTestClient.
    if ((0 == strcmp(TC_SysManager, pRequester))) {
      open_session_with_sm_test_client(hApp, pRequester);
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: %s not found in Group Launch Map",
          pRequester);
    }
  } else {
    /**********************************************************************/
    if (0 != l_ModuleListIter->pid) {
      UI_32 l_ClientPriority;
      l_eStatus = l_ModuleListIter->GetPriority(l_ClientPriority);

      if (eFrameworkunifiedStatusOK != l_eStatus) {
        LOG_ERROR("l_ModuleListIter->GetPriority( l_ClientPriority )");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      } else if (l_ClientPriority != l_ModuleListIter->configuration_priority) {
        FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Changing %s's priority from %d to %d",
            pRequester, l_ClientPriority,
            l_ModuleListIter->configuration_priority);
        CALL_AND_LOG_STATUS_IF_ERRORED( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
            l_ModuleListIter->SetPriority( // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
                    l_ModuleListIter->configuration_priority));  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      }
    }
    /**********************************************************************/

    // ToDo Jay 2013 Jan 09 REPLACE WITH CORRECT SERVICE / SESSION HANDLE
    //                      LOGIC
    // validate session handle
    if (NULL == l_ModuleListIter->hsession) {
      // LCOV_EXCL_BR_START 4: nsfw error
      if (NULL == (l_ModuleListIter->hsession = FrameworkunifiedMcOpenSender(hApp, pRequester))) {
      // LCOV_EXCL_BR_STOP 4: nsfw error
        // LCOV_EXCL_START 4: nsfw error
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
            " Error: FrameworkunifiedMcOpenSender(App %s, %s) returned NULL",
            FrameworkunifiedGetAppName(hApp), pRequester);
        return eFrameworkunifiedStatusInvldHandle;
        // LCOV_EXCL_STOP
      }
    } else {
    /*
     * Currently System Manager does not support multiple sessions from same client.
     * When a client gets restarted after Crash or after missing HeartBeat, System Manager
     * would receive OpenSession request from that client even when System Manager already
     * has a open session with that client.
     */
      FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
          " Warning: Repeated Session Opening Request from %s", pRequester);
    }
    if (eFrameworkunifiedStatusOK != (l_eStatus = RegisterCallbacksForRequester(hApp, pRequester))) {
      // Close the message queue handle
      if (NULL != l_ModuleListIter->hsession) {  // LCOV_EXCL_BR_LINE 6: Due to NULL checking
        if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedMcClose(l_ModuleListIter->hsession))) {
          LOG_ERROR("FrameworkunifiedMcClose()");  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
        }
        l_ModuleListIter->hsession = NULL;
      }
      FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
      return l_eStatus;
    }

    // Copy session name to data structure
    strncpy(tOpenAck.cSessionName, FrameworkunifiedGetAppName(hApp), sizeof(tOpenAck.cSessionName) - 1);
    tOpenAck.eStatus = eFrameworkunifiedStatusOK;
    tOpenAck.sessionId = l_ui32DefaultSessionID;
    tOpenAck.sessionType = l_ui32DefaultSessionType;

    // send OpenSession ACK
    // LCOV_EXCL_BR_START 4: nsfw error
    if (eFrameworkunifiedStatusOK
        != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession,
            SS_SM_PROTOCOL_OPEN_SESSION_ACK, sizeof(OpenSessionAck),
            (PVOID) & tOpenAck))) {  // LCOV_EXCL_BR_STOP
      // LCOV_EXCL_START 4: nsfw error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: FrameworkunifiedSendMsg( %s, SS_SM_PROTOCOL_OPEN_SESSION_ACK)"
          " errored: %d/'%s'", l_ModuleListIter->name.c_str(), l_eStatus,
          GetStr(l_eStatus).c_str());

      if (NULL != l_ModuleListIter->hsession) {
        // Close the message queue handle
        if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedMcClose(l_ModuleListIter->hsession))) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
              " Error: FrameworkunifiedMcClose(%s) errored: %d/'%s'",
              l_ModuleListIter->name.c_str(), l_eStatus,
              GetStr(l_eStatus).c_str());
          FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
        }
        l_ModuleListIter->hsession = NULL;
      }
      // LCOV_EXCL_STOP
    } else {
      // Store PowerService session handle in class so it can be accessed faster
      // to use opened session while replying to PowerService.
      if ((0 == strcmp(SERVICE_POWER, pRequester))) {
        m_hPowerServiceSession = l_ModuleListIter->hsession;
      }

      l_ModuleListIter->SetModuleState(MODULE_STATE_CONNECTED);

      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " SM State: %s, %s.is_start_required: %s",
          GetStr(m_SMCurrentState).c_str(), l_ModuleListIter->name.c_str(),
          GetStr(l_ModuleListIter->is_start_required).c_str());

      if (l_ModuleListIter->is_start_required
          && ((SS_SM_APPS_START_IN_PROGRESS == m_SMCurrentState)
          || (SS_SM_APPS_START_COMPLETE == m_SMCurrentState))) {
          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);
          const UI_32 l_iCmd = InProgressStateToSendMsg();
          if (l_iCmd != SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX) {
            CALL_AND_LOG_STATUS_IF_ERRORED(l_ModuleListIter->SendMsgAndUpdateState(l_iCmd, &f_startupData));  // LCOV_EXCL_BR_LINE 11: Gcov constraints (because exception-handling routes are automatically generated) // NOLINT(whitespace/line_length)
          }
      }
    }
  }

  if (eFrameworkunifiedStatusOK == l_eStatus) {
    std::string l_Subscriber;
    l_Subscriber = FrameworkunifiedGetMsgSrc(hApp);

    // check if the heart beat subscriber is already in list
    HBListIter l_HBIter = std::find(m_HBList.begin(), m_HBList.end(), l_Subscriber);
    if (l_HBIter == m_HBList.end()) {
      m_HBList.push_back(l_Subscriber);
    }
    if (m_SMCurrentState == SS_SM_APPS_START_COMPLETE) {
      TSMRequestMessage l_ModuleDetails;
      snprintf(l_ModuleDetails.pstModuleName, sizeof(l_ModuleDetails.pstModuleName),
          "%s", l_Subscriber.c_str());
      l_eStatus = SendRequestToHeartBeat(hApp, SS_HEARTBEAT_APPEND_MODULE_ENTRY,
          &l_ModuleDetails, sizeof(TSMRequestMessage));
      LOG_ERROR_REC_HIST_IF_ERRORED(l_eStatus, "SendRequestToHeartBeat()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }
  }

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

///////////////////////////////////////////////////////////////////////
/// ConstructGetResultResponse
///
///
//////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::add_state_information_to_response(CHAR *f_MessageResponse) const {
  const CHAR ReadyToLaunchAppDescription[] = "_READY_TO_LAUNCH:";
  const CHAR StartInProgressDescription[] = "_START_IN_PROGRESS:";
  const CHAR LaunchInProgressDescription[] = "_LAUNCH_IN_PROGRESS:";
  const CHAR LaunchedReadyToStartDescription[] = "_READY_TO_START:";
  const CHAR StopInProgressDescription[] = "_STOP_IN_PROGRESS:";
  const CHAR StartCompleteDescription[] = "_START_COMPLETED:";
  const CHAR WaitingForCriticalAppsToStopDescription[] = "_WAITING_FOR_CRITICAL_APPS_TO_STOP:";
  const CHAR PreStartInProgressDescription[] = "_PRE_START_IN_PROGRESS:";
  const CHAR PreStopInProgressDescription[] = "_PRE_STOP_IN_PROGRESS:";
  const CHAR PreRunCompleteDescription[] = "_PRE_RUN_COMPLETE:";
  const CHAR BackgroundStartInProgressDescription[] = "_BACKGROUND_START_IN_PROGRESS:";
  const CHAR BackgroundStopInProgressDescription[] = "_BACKGROUND_STOP_IN_PROGRESS:";
  const CHAR BackgroundRunCompleteDescription[] = "_BACKGROUND_RUN_COMPLETE:";
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  CHAR l_Buffer[5];
  UI_32 l_Index = 0;

  std::map<SS_SMModuleState, std::string> StateMap;   // State Map
  StateMap[SS_SM_READY_TO_LAUNCH_APP] = ReadyToLaunchAppDescription;
  StateMap[SS_SM_APPS_LAUNCH_IN_PROGRESS] = LaunchInProgressDescription;
  StateMap[SS_SM_APPS_LAUNCHED_READY_TO_START] = LaunchedReadyToStartDescription;
  StateMap[SS_SM_APPS_START_IN_PROGRESS] = StartInProgressDescription;
  StateMap[SS_SM_APPS_START_COMPLETE] = StartCompleteDescription;
  StateMap[SS_SM_APPS_STOPPING_AT__CWORD56__REQ] = StopInProgressDescription;
  StateMap[SS_SM_APPS_STOPPING_AT_INTERNAL_REQ] = StopInProgressDescription;
  StateMap[SS_SM_WAITING_FOR_CRITICAL_APPS_AT_INTERNAL_REQ] =
      WaitingForCriticalAppsToStopDescription;
  StateMap[SS_SM_WAITING_FOR_CRITICAL_APPS_AT__CWORD56__REQ] =
      WaitingForCriticalAppsToStopDescription;
  StateMap[SS_SM_APPS_PRE_START_IN_PROGRESS] = PreStartInProgressDescription;
  StateMap[SS_SM_APPS_PRE_STOP_IN_PROGRESS] = PreStopInProgressDescription;
  StateMap[SS_SM_APPS_PRE_RUN_COMPLETE] = PreRunCompleteDescription;
  StateMap[SS_SM_APPS_BACKGROUND_START_IN_PROGRESS] = BackgroundStartInProgressDescription;
  StateMap[SS_SM_APPS_BACKGROUND_STOP_IN_PROGRESS] = BackgroundStopInProgressDescription;
  StateMap[SS_SM_APPS_BACKGROUND_RUN_COMPLETE] = BackgroundRunCompleteDescription;

  itoa(m_SMCurrentState, l_Buffer, 16);
  while (l_Buffer[l_Index]) {
    l_Buffer[l_Index] = toupper(l_Buffer[l_Index]);
    l_Index++;
  }

  if (SS_SM_MAX_RESP_MSG_SIZE > (strlen(f_MessageResponse) + sizeof(l_Buffer)
      + StateMap[m_SMCurrentState].length() + 1)) {
    strncat(f_MessageResponse, l_Buffer, sizeof(l_Buffer));
    strncat(f_MessageResponse, StateMap[m_SMCurrentState].c_str(),
    StateMap[m_SMCurrentState].length());
  } else {
    eStatus = eFrameworkunifiedStatusFail;
  }

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

///////////////////////////////////////////////////////////////////////
/// ConstructGetResultResponse
///
///
//////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::construct_get_result_response(CHAR *f_MessageResponse) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  const EFrameworkunifiedStatus  eStatus = add_state_information_to_response(f_MessageResponse);
  if (eFrameworkunifiedStatusOK == eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Response Constructed");
  }

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

///////////////////////////////////////////////////////////////////////
/// REC_HIST_IF_SUCCESSFUL / SetCmdHist
///
///
//////////////////////////////////////////////////////////////////////
void CSystemManager::SetCmdHist(std::string cmd, cmdHist &hist, cmdHistIter &it, std::string sender) {
  UI_64 l_time = 0XDEAD;
  CTimeSpan* timerClass = new (std::nothrow) CTimeSpan();  // LCOV_EXCL_BR_LINE 5: Because new cannot fail
  if (NULL == timerClass) {  // LCOV_EXCL_BR_LINE 5: Because new cannot fail
    // LCOV_EXCL_START 5: Because new cannot fail
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " 'new (std::nothrow) CTimeSpan()' returned NULL, "
        "'it->m_time' being set to 0xDEAD");
    // LCOV_EXCL_STOP
  } else {
    l_time = timerClass->GetTimeMilliseconds();
  }

  pthread_mutex_lock(&sm_hist_mutex);

  it->m_time = l_time;
  it->m_cmd = cmd;
  it->m_sender = sender;
  it++;

  if (it != hist.end()) {  // LCOV_EXCL_BR_LINE 5: std: because it is a member of a vector and it is difficult to create a failing condition
    it = hist.begin();
  }

  pthread_mutex_unlock(&sm_hist_mutex);

  delete timerClass;  // LCOV_EXCL_BR_LINE 5: Because the delete cannot fail
}

///////////////////////////////////////////////////////////////////////
/// OnCurrentPowerStateQuery
///
///
//////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CSystemManager::OnCurrentSMStateQuery(HANDLE hApp) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);
  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "Received from %s", FrameworkunifiedGetMsgSrc(hApp));

  SS_SMCurrentState l_CurrentState;

  REC_HIST_IF_SUCCESSFUL("SS_SM_CRNT_STATE_QUERY", m_SMCmdHist, m_SMHistIter,
                         FrameworkunifiedGetMsgSrc(hApp), l_eStatus);
  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg < SS_SMCurrentState > (hApp, l_CurrentState))) {
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  } else {
    construct_get_result_response(l_CurrentState.respMsgString);

    ModuleLaunchListIter l_ModuleListIter;
    PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
    if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) {  // LCOV_EXCL_BR_LINE 200: can not be other value  // NOLINT (whitespace/line_length)
      // LCOV_EXCL_START 200: can not be other value
      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);
      // LCOV_EXCL_STOP
    } else if (l_ModuleListIter->hsession != NULL) {  // LCOV_EXCL_BR_LINE 200: can not be NULL // NOLINT (whitespace/line_length)
      if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession,  // LCOV_EXCL_BR_LINE 4: nsfw error
                SS_SM_CRNT_STATE_QUERY_RSPN, sizeof(SS_SMCurrentState),
                (PVOID) & l_CurrentState))) {
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_ERROR("FrameworkunifiedSendMsg(SS_SM_CRNT_STATE_QUERY_RSPN)");  // LCOV_EXCL_LINE 4: nsfw error
      }
    } else {
      // LCOV_EXCL_START 200: can not be NUL
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " NULL == hsession; %s not connected yet",
          l_ModuleListIter->name.c_str());
      // LCOV_EXCL_STOP
    }
  }

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

EFrameworkunifiedStatus CSystemManager::GetVersionNumber(SS_VersionNumberType & f_VersionNumber) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  CSMVersion cVersion;
  if (eFrameworkunifiedStatusOK != (l_eStatus = cVersion.get_version(f_VersionNumber))) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
    LOG_ERROR("cVersion.get_version()");  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::GetVersionNumber( SS_VersionNumberType

EFrameworkunifiedStatus CSystemManager::GetBuildInfo(std::string &f_BuildInfoStr) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus;

  CSMVersion cVersion;
  if (eFrameworkunifiedStatusOK != (l_eStatus = cVersion.get_build_info(f_BuildInfoStr))) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
    LOG_ERROR("cVersion.get_build_info()");  // LCOV_EXCL_BR_LINE 6:For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::GetBuildInfo(std::string)

bool CSystemManager::GetDramPowerStatusInfo(const HANDLE h_app) {
  PsmDramStsT l_dram_sts = PSM_DRAM_STS_NORMAL;
  bool ret = false;

  // Checking dram power status.
  if (PsmGetDramPowerSupplyAbnormalityCheckResultPower(h_app, &l_dram_sts))
    return ret;

  if (l_dram_sts == PSM_DRAM_STS_NORMAL)
    ret = true;

  return ret;
}

bool CSystemManager::GetDramStoreStatusInfo(const HANDLE h_app) {
  PsmSysupDramT l_dram1 = PSM_SYSUP_DRAM_NORMAL;
  PsmSysupDramT l_dram2 = PSM_SYSUP_DRAM_NORMAL;
  PsmSysupDramT l_dram3 = PSM_SYSUP_DRAM_NORMAL;
  PsmStartStatusT l_sts = PSM_START_STATUS_FACTRESET;

  bool ret = false;

  // Checking factory shipment status
  if (PsmGetStartStatusPower(h_app, &l_sts))
    return ret;

  if (l_sts == PSM_START_STATUS_FACTRESET) {
    ret = true;
    goto finish;
  }

  // Checking dram power
  if (!GetDramPowerStatusInfo(h_app))
    goto finish;

  // Checking dram status.
  if (PsmGetDramBackupStatusPower(h_app, &l_dram1, &l_dram2, &l_dram3))
    goto finish;

  // l_dram2 and l_dram3 would be ignored.
  if (l_dram1 == PSM_SYSUP_DRAM_NORMAL)
    ret = true;

  if (l_dram2 == PSM_SYSUP_DRAM_SFTERRSR)
    ret = true;

finish:
  return ret;
}

bool CSystemManager::GetSyscomPowerStatusInfo(const HANDLE h_app) {
  PsmComStsT l_syscom_sts = PSM_COM_STS_NORMAL;
  bool ret = false;

  if (PsmGetSyscomStatusPower(h_app, &l_syscom_sts))
    return ret;

  if (l_syscom_sts == PSM_COM_STS_NORMAL)
    ret = true;

  return ret;
}

EFrameworkunifiedStatus CSystemManager::OnSetStartupConfirmationDataRequest(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  INTERFACEUNIFIEDLOG_RECEIVED_FROM(hApp);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_PERFORMANCE, __FUNCTION__, "from %s", FrameworkunifiedGetMsgSrc(hApp));
  EFrameworkunifiedStatus l_eStatus;
  Pwr_ServiceSetInterface tServiceSetIf;
  // 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, tServiceSetIf))) {  // LCOV_EXCL_BR_LINE 4:NSFW's error
    // LCOV_EXCL_START 4:NSFW's 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_startUpConfirmationMsg = tServiceSetIf.data.startupConfirmationMsg;
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " %s Startup Confirmation data:", FrameworkunifiedGetMsgSrc(hApp));
    SYSTEMMANAGERLOG_StartupConfirmationMsg(m_startUpConfirmationMsg);  // LCOV_EXCL_BR_LINE 15: marco defined in ns_logger_if.h  // NOLINT(whitespace/line_length)
    DGCODE_RET_API  l_ret = DGCODE_RET_ERROR;

    l_ret = Diag_StartupAllStatusOfDTC();
    if (l_ret == DGCODE_RET_ERROR) {
      LOG_ERROR("Diag_StartupAllStatusOfDTC()");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
    }

    if ((e_SS_SM_NEXT_WAKEUP_TYPE_COLD == m_NextWakeupType) && (epsstCOLDSTART != m_startUpConfirmationMsg.wakeupType)) {  //  LCOV_EXCL_BR_LINE 6: Because the above formula cannot be set to true // NOLINT(whitespace/line_length)
      // LCOV_EXCL_START 6: Because the condition cannot be set
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "WakeupType Change to Cold by Svc Request");
      m_startUpConfirmationMsg.wakeupType = epsstCOLDSTART;
      // LCOV_EXCL_STOP
    }

    m_ResetStatus = ((m_isIlgReset == TRUE) ?
                     e_SS_SM_RESET_STATUS_NG :
                    ((m_isImmediateReset == TRUE) ?
                     e_SS_SM_RESET_STATUS_IMMEDIATE : e_SS_SM_RESET_STATUS_NONE));
    if (e_SS_SM_RESET_STATUS_NG == m_ResetStatus) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__,
          "ResetStatus NG   illRst:%s lastErr:Not Support",
          m_isIlgReset ? "TRUE" : "FALSE");
      m_ResetCount++;
      if (PowerHalSetResetInfo(AGL_RESET_COUNTER, m_ResetCount)) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          "Could not back up m_ResetCount(%lu) to power_hal", m_ResetCount);
      }
    }

    m_DramBackupStatus =
            ((epsstWARMSTART != m_startUpConfirmationMsg.wakeupType)
            || (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode)
            || (GetDramStoreStatusInfo(hApp) == false)) ?
            e_SS_SM_DRAM_BACKUP_NG : e_SS_SM_DRAM_BACKUP_OK;

    if (e_SS_SM_DRAM_BACKUP_NG == m_DramBackupStatus) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__,
          "DramBackup NG  wakeupType:%s dataResetMode:%s",
          (epsstWARMSTART == m_startUpConfirmationMsg.wakeupType) ?
          "WARM" : "COLD",
          (e_SS_SM_DATA_RESET_MODE_FACTORY == m_DataResetMode) ?
          "FACTORY" : "NotFactory");
    }

    if (m_needReNotifyStartPrm) {  //  LCOV_EXCL_BR_LINE 6: Because the condition cannot be satisfied from the external API
      // LCOV_EXCL_BR_START 6: Because both sides are not FALSE
      if (e_SS_SM_DRAM_BACKUP_NG == m_DramBackupStatus) {
      // LCOV_EXCL_BR_STOP
        m_DramBackupStatus = e_SS_SM_DRAM_BACKUP_NG;
      }
    }

    if (m_needReNotifyStartPrm) {  //  LCOV_EXCL_BR_LINE 6: Because the condition cannot be satisfied from the external API
      if (e_SS_SM_RESET_STATUS_NG == m_ResetStatus) {
        // do nothing, keep m_ResetStatus.
      } else if (e_SS_SM_RESET_STATUS_IMMEDIATE == m_ResetStatus) {
        // do nothing, keep m_ResetStatus.
      } else {
        m_ResetStatus = e_SS_SM_RESET_STATUS_NONE;
      }

      if (epsstWARMSTART != m_startUpConfirmationMsg.wakeupType) {  //  LCOV_EXCL_BR_LINE 6: Because the above condition cannot be satisfied // NOLINT(whitespace/line_length)
        m_startUpConfirmationMsg.wakeupType = epsstCOLDSTART;
      }
    }

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

    FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "\n"
      "start prm\n"
      "dramBackupStatus = %s\n"
      "wakeupType       = %s\n"
      "dataResetMode    = %s\n"
      "resetStatus      = %s\n"
      "resetCount       = %d\n"
      "progUpdateState  = %d",
      (m_DramBackupStatus == e_SS_SM_DRAM_BACKUP_OK) ? "OK" : "NG",
      (m_startUpConfirmationMsg.wakeupType == epsstWARMSTART) ? "WARM" : "COLD",
      (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_FACTORY) ? "FACT" :
      (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_USER) ? "USER" :
      (m_DataResetMode == e_SS_SM_DATA_RESET_MODE_PROGUPDATE) ? "PROG" : "NONE",
      (m_ResetStatus == e_SS_SM_RESET_STATUS_IMMEDIATE) ? "IMM" :
      (m_ResetStatus == e_SS_SM_RESET_STATUS_NONE) ? "NONE" : "NG", m_ResetCount,
      m_ProgUpdateState);

    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedNPPublishNotification(hApp, NTFY_SSSystemMgrStartUpType, &m_startUpConfirmationMsg.wakeupType, sizeof(EPWR_SC_WAKEUP_TYPE)))) {  // 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
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
          " Error: FrameworkunifiedNPPublishNotification(%s, %s) errored: %d/'%s'",
          NTFY_SSSystemMgrStartUpType,
          GetStr(m_startUpConfirmationMsg.wakeupType).c_str(), l_eStatus,
          GetStr(l_eStatus).c_str());
      // LCOV_EXCL_STOP
    } else {
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " FrameworkunifiedNPPublishNotification(%s, %s) successful",
          NTFY_SSSystemMgrStartUpType,
          GetStr(m_startUpConfirmationMsg.wakeupType).c_str());

      // LCOV_EXCL_BR_START 200: As there are no cases other than eFrameworkunifiedStatusOK
      REC_HIST_IF_SUCCESSFUL("SM/StartUpType",
                             m_PubCmdHist, m_PubHistIter, "", l_eStatus);
      // LCOV_EXCL_BR_STOP
    }
  }

  EFrameworkunifiedStatus l_responseStatus = l_eStatus;

  ModuleLaunchListIter l_ModuleListIter;
  PCSTR l_moduleName = FrameworkunifiedGetMsgSrc(hApp);
  if (eFrameworkunifiedStatusOK != (l_eStatus = GetModuleIterator(l_moduleName, l_ModuleListIter))) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
        " Error: Module %s not found in Group Launch Map", l_moduleName);
  } else if (l_ModuleListIter->hsession != NULL) {
    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(l_ModuleListIter->hsession,  // LCOV_EXCL_BR_LINE 4:NSFW's error
            SS_SM_FWD_START_CONFIRMATION_MSG_RESP, sizeof(EFrameworkunifiedStatus),
            (PVOID) & l_responseStatus))) {
      // LCOV_EXCL_START 4:NSFW's error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      LOG_ERROR("FrameworkunifiedSendMsg(SS_SM_FWD_START_CONFIRMATION_MSG_RESP)");  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
      // LCOV_EXCL_STOP
    }
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " NULL == hsession; %s not connected yet", l_ModuleListIter->name.c_str());
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}  // End of EFrameworkunifiedStatus CSystemManager::OnSetStartupConfirmationDataRequest( HANDLE hApp )

EFrameworkunifiedStatus CSystemManager::GetTimeStamp(std::string& TimeStamp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  CHAR format[256] = { '\0' };
  CHAR l_format[256] = { '\0' };
  struct timeb timebuf;
  uint32_t time;
  uint8_t status;
  struct tm theTime;
  ftime(&timebuf);
  Clock_getSystemTimeY2K38(&time, &status);
  CLOCK_RETURN clock_ret = Clock_CnvSecToDateY2K38(&time, &theTime);

  if (CLOCK_OK != clock_ret) {
    return eFrameworkunifiedStatusNullPointer;
  }

  sprintf(l_format, "GMT Time,%04d-%02d-%02d %02d:%02d:%02d.%hu\n",  // NOLINT
  theTime.tm_year + 1900, theTime.tm_mon + 1, theTime.tm_mday,
  theTime.tm_hour, theTime.tm_min, theTime.tm_sec, timebuf.millitm);

  struct timespec timeSpec;

  if (0 != clock_gettime(CLOCK_MONOTONIC, &timeSpec)) {
    SS_ASERT_ERRNO(0);  // LCOV_EXCL_BR_LINE 15: marco defined in ss_templates.h  // NOLINT(whitespace/line_length)
  } else {
    time_t timeInSecs = timeSpec.tv_sec;
    sprintf(format, "Elaps Time,%ld:%02ld:%02ld\n", (timeInSecs / 3600),  // NOLINT
            ((timeInSecs % 3600) / 60), (timeInSecs % 60));
  }

  TimeStamp.clear();
  TimeStamp.assign(format);
  TimeStamp.append(l_format);

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

VOID CSystemManager::SYSTEMMANAGERLOG_StartupConfirmationMsg(EPWR_SC_MSG_STRUCT & f_scMsg) {
  std::stringstream l_enumStr;
  l_enumStr << endl;
  l_enumStr << " HostProcSoftVer:" << hex << std::setw(16) << std::setfill('0')
      << m_VersionNumberStruct.m_VersionNumber << endl;
  l_enumStr << "  _CWORD56_ Boot Mode:" << GetStr(f_scMsg._CWORD56_BootMode) << endl; // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  l_enumStr << "  wakeupType    :" << GetStr(f_scMsg.wakeupType); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)

  FRAMEWORKUNIFIEDLOG(ZONE_STATE, __FUNCTION__, "%s", l_enumStr.str().c_str());
}  // End of VOID CSystemManager::SYSTEMMANAGERLOG_StartupConfirmationMsg( EPWR_SC_MSG_STRUCT & f_scMsg )

VOID CSystemManager::LogESystemmanagerStatusEnums() {
  #define INITIAL_INDEX eFrameworkunifiedStatusEmptyMediaList
  #define FINAL_INDEX   eFrameworkunifiedStatusErrNoEINTR

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::stringstream l_enumStr;
  for (int i = INITIAL_INDEX; i <= FINAL_INDEX; i++) {
    // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
    l_enumStr << "\n" << "0x" << std::setfill('0') << std::setw(8) << hex << i
      << "/" << std::setfill(' ') << std::setw(2) << dec << i << ": "
      << GetStr(static_cast<EFrameworkunifiedStatus>(i));
    // LCOV_EXCL_BR_STOP
  }

  std::string l_logMsg = l_enumStr.str();
  SystemmanagerLogString(ZONE_INFO, __FUNCTION__, l_logMsg); // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");

#undef INITIAL_INDEX
#undef FINAL_INDEX
}  // End of VOID CSystemManager::LogESystemmanagerStatusEnums()

VOID CSystemManager::LogProtocolIDs() {
#define INITIAL_INDEX SS_SYSTEM_MANAGER_PROTOCOL_BEGINNING_INDEX
#define FINAL_INDEX   SS_SYSTEM_MANAGER_PROTOCOL_ENDING_INDEX

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::stringstream l_enumStr;
  for (int i = INITIAL_INDEX; i <= FINAL_INDEX; i++) {
    // LCOV_EXCL_BR_START 11:unexpected branch  // NOLINT(whitespace/line_length)
    l_enumStr << "\n" << "0x" << std::setfill('0') << std::setw(8) << hex << i
      << "/" << std::setfill(' ') << std::setw(2) << dec << i << ": "
      << GetStr(static_cast<SS_SystemManagerProtocol>(i));
    // LCOV_EXCL_BR_STOP
  }

  std::string l_logMsg = l_enumStr.str();
  SystemmanagerLogString(ZONE_INFO, __FUNCTION__, l_logMsg);  // LCOV_EXCL_BR_LINE 11:unexpected branch  // NOLINT(whitespace/line_length)
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");

#undef INITIAL_INDEX
#undef FINAL_INDEX
}  // End of VOID CSystemManager::LogProtocolIDs()

VOID CSystemManager::SystemmanagerLogString(TFrameworkunifiedZone f_zone, PCSTR f_func, std::string &f_text) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  UI_32 l_offset = 0;
  UI_32 l_msgLenMax = MAX_QUEUE_MSG_SIZE - 512;  // Leave space for the appending of
                                                 // the NSLog date/time/service/line string.

  if (f_text.at(f_text.length() - 1) == '\n') {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    f_text.erase(f_text.length() - 1);  // LCOV_EXCL_LINE 6: For setting the initialization conditions at SystemManager startup
  }

  while (l_offset < f_text.size()) {
    UI_32 l_charsRem = static_cast<UI_32>(f_text.size() - l_offset);
    UI_32 l_msgLen = (l_charsRem > l_msgLenMax) ?  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
        l_msgLenMax : l_charsRem;  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup
    std::string l_msgStr = f_text.substr(l_offset, l_msgLen);
    size_t l_newLinePos = l_msgStr.find_last_of("\n", l_msgLen);
    if ((l_newLinePos != std::string::npos) && (l_charsRem > l_msgLenMax)) {  // LCOV_EXCL_BR_LINE 6: For setting the initialization conditions at SystemManager startup // NOLINT(whitespace/line_length)
      // LCOV_EXCL_START 6: For setting the initialization conditions at SystemManager startup
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      l_msgStr = f_text.substr(l_offset, l_newLinePos);
      l_offset += static_cast<UI_32>(l_newLinePos);
      // LCOV_EXCL_STOP
    } else {
      l_offset += l_msgLen;
    }

    FRAMEWORKUNIFIEDLOG(f_zone, f_func, l_msgStr.c_str());
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}  // LCOV_EXCL_BR_LINE 10: Final line

// End of /SS_SystemManager/src/ss_system_manager.cpp