path: root/logger_service/server/src/ss_logger_error_event.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_SS_LoggerService
/// \brief    This file supports error event logging.
///
///////////////////////////////////////////////////////////////////////////////
#include "ss_logger_error_event.h"
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <boost/bind.hpp>
#include <unistd.h>
#include <sys/wait.h>
#include <native_service/frameworkunified_framework_if.h>
#include <system_service/ss_sm_client_if.h>
#include <system_service/ss_client_names.h>
#include <system_service/ss_logger_service_protocol.h>
#include <system_service/ss_logger_service.h>
#include <system_service/ss_services.h>
#include <system_service/ss_templates.h>
#include <stub/el_mem.h>
#include <native_service/cl_process.h>
#include <stub/Clock_API.h>
#include <string>
#include "loggerservicedebug_loggerservicelog.h"
#include "loggerservicedebug_thread_if.h"
#include "ss_logger_service_callbacks.h"
#include "ss_logger_error_event_archive.h"
#include "ss_logger_common.h"
#include "ss_logger_types.h"
#include "ss_logger_fs_directory.h"

CErrorEvent::CErrorEvent()
    : m_hApp(NULL),
      m_bIsPrevEventCompleted(true),
      m_errorEventNtfData(),
      m_pLoggerCfg(NULL),
      m_pReaderWriterControl(NULL),
      m_ServiceName(""),
      m_time(0),
      m_currentEventTriggerNumber(0),
      m_diagsessionhandle(NULL),
      m_thrdEvntLogWriter(NULL),
      m_sfd(-1) {  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}  // LCOV_EXCL_BR_LINE 11:Unexpected branch

CErrorEvent::~CErrorEvent() {  // LCOV_EXCL_START 14:globle instance
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CErrorEvent::Initialize(HANDLE f_hApp, CLoggerCfg *f_pLoggerCfg,
                                   CReaderWriterControl *f_pReaderWriterControl,
                                   HANDLE f_thrdEvntLogWriter,
                                   std::string f_strEvntLogQueWorkerName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  Timer *l_pTimer;

  m_sfd = CL_ProcessInit();
  if (m_sfd == -1) {  // LCOV_EXCL_BR_LINE 8:Because the process initialization is guaranteed to be successful
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. m_sfd CL_ProcessInit() failed \n.");  // LCOV_EXCL_LINE 8:Because the process initialization is guaranteed to be successful
  }

  SS_LoggerServerEvents l_errorEventStateEvents[] = {
      SS_LOGGER_SCREENCAPTURE_EVT };

  FrameworkunifiedProtocolCallbackHandler l_smCallbacks[] = {
  // Logging Protocol Callbacks
      { SS_SM_EVENT_ERROR_TO_SSL, boost::bind(&CErrorEvent::OnStartLogging,
                                              this, _1) }, {
          SS_SM_ERROR_EVENT_LOGGING_START_RSPN, boost::bind(
              &CErrorEvent::OnLogStartResponse, this, _1) }, {
          SS_SM_ERROR_EVENT_ARTIFACT_RSPN, boost::bind(
              &CErrorEvent::OnArtifactResponse, this, _1) } };  // LCOV_EXCL_BR_LINE 11:Unexpected branch

  FrameworkunifiedProtocolCallbackHandler l_selfCallbacks[] = {
  // Logging Protocol Callbacks
      { SS_LOGGER_ERROR_EVENT_ARTIFACT_REQ, boost::bind(
          &CErrorEvent::OnArtifactRequest, this, _1) }, {
          SS_SM_ERROR_EVENT_ARTIFACT_RSPN, boost::bind(
              &CErrorEvent::OnArtifactResponse, this, _1) } };  // LCOV_EXCL_BR_LINE 11:Unexpected branch

  FrameworkunifiedProtocolCallbackHandler l_requesterCallbacks[] = { {
      SS_LOGGER_SCREENCAPTURE_EVT_ACK, boost::bind(
          &CErrorEvent::OnObtainScreenShotResponse, this, _1) } };  // LCOV_EXCL_BR_LINE 11:Unexpected branch

  FrameworkunifiedProtocolCallbackHandler l_storageThreadCallbacks[] = { {
      eLoggerStorageThreadCmdOK, boost::bind(&CErrorEvent::OnStorageResponseOk,
                                             this, _1) }, {
      eLoggerStorageThreadCmdWriteFailed, boost::bind(
          &CErrorEvent::OnStorageResponseWriteFailed, this, _1) }, {
      eLoggerStorageThreadCmdNotFound, boost::bind(
          &CErrorEvent::OnStorageResponseNotFound, this, _1) }, {
      eLoggerStorageThreadCmdNoWritten, boost::bind(
          &CErrorEvent::OnStorageResponseNoWritten, this, _1) } };  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  for (UI_32 i = 0; i < _countof(l_requesterCallbacks); i++) {
    m_requesterCallbacksVec.push_back(l_requesterCallbacks[i]);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
  }

  if (NULL == f_hApp) {  // LCOV_EXCL_BR_LINE 6:As it is not always NULL
    // LCOV_EXCL_START 6:As it is not always NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusInvldHandle;
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR, __FUNCTION__,
        " Error. Argument f_hApp passed NULL pointer. Initialization failed.");
    // LCOV_EXCL_STOP
  } else if (NULL == (m_thrdEvntLogWriter = f_thrdEvntLogWriter)) {  // LCOV_EXCL_BR_LINE 6:As it is not always NULL
    // LCOV_EXCL_START 6:As it is not always NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusInvldHandle;
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR, __FUNCTION__,
        " Error. Argument f_hApp passed NULL pointer. Initialization failed.");
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = m_errorEventCfg.Initialize(f_pLoggerCfg))) {  // LCOV_EXCL_BR_LINE 200:To ensure success
    // LCOV_EXCL_START 200:To ensure success
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. m_errorEventCfg.Initialize() returned: %d.", l_eStatus);
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(f_hApp, SERVICE_LOGGER, l_selfCallbacks, _countof(l_selfCallbacks)))) {  // LCOV_EXCL_BR_LINE 4:NSFW  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 4:NSFW
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. FrameworkunifiedAttachCallbacksToDispatcher(SERVICE_SYSMANAGER) returned: %d.",
        l_eStatus);
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(f_hApp, SERVICE_SYSMANAGER, l_smCallbacks, _countof(l_smCallbacks)))) {  // LCOV_EXCL_BR_LINE 4:NSFW  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 4:NSFW
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. FrameworkunifiedAttachCallbacksToDispatcher(SERVICE_SYSMANAGER) returned: %d.",
        l_eStatus);
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedDefineStateEvents(f_hApp, &l_errorEventStateEvents, static_cast<UI_32>(_countof(l_errorEventStateEvents))))) {  // LCOV_EXCL_BR_LINE 4:NSFW  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 4:NSFW
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. FrameworkunifiedDefineStateEvents(SS_LOGGER_SCREENCAPTURE_EVT) returned: %d",
        l_eStatus);
    // LCOV_EXCL_STOP
  } else if (NULL == f_pLoggerCfg) {  // LCOV_EXCL_BR_LINE 200:As it is not always NULL
    // LCOV_EXCL_START 200:As it is not always NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusNullPointer;
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. f_pLoggerCfg passed NULL pointer.");
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = m_loggerPopups.Initialize(f_pLoggerCfg))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 200:To ensure success
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. m_loggerPopups.Initialize(f_pLoggerCfg) returned: %d.",
           l_eStatus);
    // LCOV_EXCL_STOP
  } else if (NULL == f_pReaderWriterControl) {  // LCOV_EXCL_BR_LINE 200:As it is not always NULL
    // LCOV_EXCL_START 200:As it is not always NULL
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    l_eStatus = eFrameworkunifiedStatusNullPointer;
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. Argument f_pReaderWriterControl passed NULL pointer.");
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = m_loggerStorage.Initialize(f_hApp, AppName, f_pLoggerCfg))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 200:To ensure success
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. m_loggerPopups.Initialize(f_pLoggerCfg) returned: %d.",
           l_eStatus);
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher( f_hApp, ERROR_EVENT_STORAGE_QUEUE_NAME, l_storageThreadCallbacks, _countof(l_storageThreadCallbacks)))) {  // LCOV_EXCL_BR_LINE 4:NSFW  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 4:NSFW
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. FrameworkunifiedAttachCallbacksToDispatcher(ERROR_EVENT_STORAGE_QUEUE_NAME) returned: %d.",
        l_eStatus);
    // LCOV_EXCL_STOP
  } else if (eFrameworkunifiedStatusOK != (l_eStatus = m_loggerCanEvent.Initialize(f_pLoggerCfg))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 200:To ensure success
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. m_loggerCanEvent.Initialize() returned: %d.", l_eStatus);
    // LCOV_EXCL_STOP
  } else {
    m_hApp = f_hApp;
    m_pLoggerCfg = f_pLoggerCfg;
    m_pReaderWriterControl = f_pReaderWriterControl;
    l_eStatus = m_loggerUtil.Initialize(m_pLoggerCfg);  // LCOV_EXCL_BR_LINE 11:Unexpected branch
    LOG_STATUS_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 5:macro
                          "CLoggerUtil::m_loggerUtil.Initialize(m_pLoggerCfg)");

    l_pTimer = &m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_LOGGING_START_RSPN];
    l_pTimer->Initialize(
        f_hApp, SS_LOGGER_ERROR_EVENT_TIMER_ID_LOGGING_START_RSPN,
        boost::bind(&CErrorEvent::OnLogStartResponseTimeout, this, _1));  // LCOV_EXCL_BR_LINE 11:Unexpected branch

    l_pTimer = &m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_ARTIFACT_RSPN];
    l_pTimer->Initialize(
        f_hApp, SS_LOGGER_ERROR_EVENT_TIMER_ID_ARTIFACT_RESPONSE,
        boost::bind(&CErrorEvent::OnArtifactResponseTimeout, this, _1));  // LCOV_EXCL_BR_LINE 11:Unexpected branch
    m_ServiceName = "";
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : RegisterSessionErrorEvent
//  brief    : Register session event. This function is called within the
//             context of the System Manager session acknowledgment handler.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::RegisterSessionErrorEvent(HANDLE f_hSession) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  l_eStatus = FrameworkunifiedRegisterEvent(f_hSession, SS_SM_EVENT_ERROR_TO_SSL);
  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedRegisterEvent(SS_SM_EVENT_ERROR_TO_SSL)");  // LCOV_EXCL_BR_LINE 5:macro

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnOpenSession
//  brief    : Called when a requester opens a session with SS_Logger
//             service.  This function attaches error event callbacks
//             to the dispatcher with the source set to the requester.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnOpenSession(HANDLE f_hApp, PCSTR f_pRequesterName,
                                      HANDLE f_hSession) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  l_eStatus = FrameworkunifiedAttachCallbacksToDispatcher(f_hApp, f_pRequesterName,
                                             &m_requesterCallbacksVec[0],
                                             static_cast<UI_32>(m_requesterCallbacksVec.size()),
                                             f_hSession);

  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedAttachCallbacksToDispatcher(f_hSession)");  // LCOV_EXCL_BR_LINE 5:macro

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnOpenSession
//  brief    : Called when a requester opens a session with SS_Logger
//             service.  This function attaches error event callbacks
//             to the dispatcher with the source set to the requester.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnCloseSession(HANDLE f_hApp, PCSTR f_pRequesterName,
                                       HANDLE f_hSession) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  UI_32 l_cmdIdArr[m_requesterCallbacksVec.size()]; // NOLINT (runtime/arrays)

  for (UI_32 i = 0; i < m_requesterCallbacksVec.size(); i++) {
    l_cmdIdArr[i] = m_requesterCallbacksVec[i].iCmd;
  }

  l_eStatus = FrameworkunifiedDetachCallbacksFromDispatcher(f_hApp, f_pRequesterName,
                                               l_cmdIdArr,
                                               static_cast<UI_32>(m_requesterCallbacksVec.size()),
                                               f_hSession);

  LOG_STATUS_IF_ERRORED(l_eStatus, "FrameworkunifiedAttachCallbacksToDispatcher()");  // LCOV_EXCL_BR_LINE 5:macro

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnStartLogging
//  brief    : Called by SS_Logger and external services to begin logging
//             artifact collection. This function sends a logging request
//             to System Manager. See SS_SM_EVENT_ERROR_TO_SSL.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnStartLogging(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  SMErrorEventNtfData l_eventErrorNtfData;

  INTERFACEUNIFIEDLOG_RECEIVED_FROM(f_hApp);  // LCOV_EXCL_BR_LINE 5:macro

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg<SMErrorEventNtfData>(f_hApp, l_eventErrorNtfData))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
    // when failed to ReadMsg, we can't know event-type for action, so nothing is able to do.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_LINE 200:To ensure success
  } else {
    if (TRUE == this->m_pLoggerCfg->IsLoggingEnabled()) {  // LCOV_EXCL_BR_LINE 200:As it is always TRUE
      if (TRUE == m_bIsPrevEventCompleted) {
        TLoggerErrorEvent l_eventData = l_eventErrorNtfData;

        if (IsNeedVerify(l_eventData.EventType)) {
          // if need output log to external storage, check whether device is authenticated or not.
          VerifyExtStorage(l_eventData);
        }

        uint8_t status;
        Clock_getSystemTimeY2K38(&m_time, &status);
        m_currentEventTriggerNumber = m_pLoggerCfg->GetUserInvokedCounter();
        l_eStatus = m_loggerUtil.checkDestinationAvailable(l_eventData);
        if (eFrameworkunifiedStatusOK == l_eStatus) {
          m_bIsPrevEventCompleted = false; /* See timer start / timeout handler below.             */

          m_artifactResponseVec.clear();

          m_errorEventNtfData = l_eventErrorNtfData; /* Overwrite m_eventErrorNtfData when logging complete. */
          m_errorEventNtfData.EventBitMask = m_errorEventCfg
              .GetEventsForErrorEvent(l_eventErrorNtfData.EventType);
          l_eStatus = SendLogStartRequestToSystemManager(
              m_errorEventNtfData.EventType);
          LOG_STATUS_IF_ERRORED(l_eStatus,
                                "SendLogStartRequestToSystemManager()");
          l_eStatus = m_loggerCanEvent.PublishStartEvent(f_hApp,
                                                         m_errorEventNtfData);
          LOG_STATUS_IF_ERRORED(
              l_eStatus,
              "m_loggerCanEvent.PublishStartEvent(f_hApp,m_errorEventNtfData);");

          bool result =
              m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_LOGGING_START_RSPN]
                  .Start(m_loggingStartRspnToSec, 0, 0, 0);
          if (FALSE == result) {  // LCOV_EXCL_BR_LINE 200:As it is always TRUE
            // LCOV_EXCL_START 200:As it is always TRUE
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
            FRAMEWORKUNIFIEDLOG(
                ZONE_ERR,
                __FUNCTION__,
                " Error. Failed to start timer kSSL_ERROR_EVENT_TIMER_LOGGING_START_RSPN.");
            // LCOV_EXCL_STOP
          }
        } else {
          FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
                 " Warning. Destination not available. ");
          m_errorEventNtfData = l_eventErrorNtfData; /* Overwrite m_eventErrorNtfData when logging complete. */
          m_errorEventNtfData.EventBitMask = m_errorEventCfg
              .GetEventsForErrorEvent(l_eventErrorNtfData.EventType);
          l_eStatus = OnStorageResponseNotFound(f_hApp);
          LOG_STATUS_IF_ERRORED(l_eStatus, "OnStorageResponseNotFound(f_hApp)");
        }
      } else {
        // Not-Need Resp to SM, because of keep logging sequance.
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. Logging already in progress. Event dropped.");
      }
    } else {
      // LCOV_EXCL_START 200:As it is always TRUE
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      if (l_eventErrorNtfData.isNeedReboot == TRUE) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "System will reboot soon, so stop logging function.");
        StopLoggingFunction(f_hApp);
      }
      FRAMEWORKUNIFIEDLOG(
          ZONE_INFO,
          __FUNCTION__,
          "Logging is disabled! Dropping Event. Sending Complete to SS_SystemManager");
      l_eStatus = SendLogCompleteRequestToSystemManager(eFrameworkunifiedStatusFail);
      LOG_STATUS_IF_ERRORED(l_eStatus,
                            "SendLogCompleteRequestToSystemManager()");
      // LCOV_EXCL_STOP
    }
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnLogStartResponse
//  brief    : Called by System Manager after the acknowledgment of the
//             logging session start request.  This function starts the
//             artifact collection process. See
//             SS_SM_ERROR_EVENT_LOGGING_START_RSPN.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnLogStartResponse(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_LOGGING_START_RSPN].Stop();
  m_errorEventCfg.GetArtifactRequestVec(m_errorEventNtfData.EventType,
                                        m_artifactRequestVec);

  l_eStatus = RequestNextArtifact(f_hApp);
  LOG_STATUS_IF_ERRORED(l_eStatus, "RequestNextArtifact()");

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnLogStartResponseTimeout
//  brief    : Called when / if SM fails to respond to a logging start
//             request and the logging star response timer expires.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnLogStartResponseTimeout(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  FRAMEWORKUNIFIEDLOG(
      ZONE_ERR,
      __FUNCTION__,
      " Error. SM failed to respond to a logging start request in the required amount of time.");

  m_bIsPrevEventCompleted = TRUE;

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

///////////////////////////////////////////////////////////////////////////
//  Function : RequestNextArtifact
//  brief    : This function requests the next artifact from the service
//             that owns the artifact.  If no artifacts remain, this
//             function performs initiates artifact post processing.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::RequestNextArtifact(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  UI_32 l_timeoutSec;
  UI_32 l_timeoutMs;

  if (0 != m_artifactRequestVec.size()) {
    TLoggingArtifact &l_nextArtifact = m_artifactRequestVec.back();
    l_eStatus = m_loggerPopups.ShowStartPopup(
        f_hApp, m_errorEventNtfData, &m_artifactRequestVec,
        m_loggerUtil.getDestination(m_errorEventNtfData));

    LOG_STATUS_IF_ERRORED(
        l_eStatus,
        "m_loggerPopups.ShowStartPopup(f_hApp,m_errorEventNtfData,&m_artifactRequestVec )");

    TEXT(__FUNCTION__,
         "Requesting next artifact ID:%d from:%s, with timeout:%d ms.",
         l_nextArtifact.ArtifactId,
         l_nextArtifact.Information.OwnerServiceName.c_str(),
         l_nextArtifact.Information.RequestTimeoutMs);

    l_timeoutSec = l_nextArtifact.Information.RequestTimeoutMs / 1000;
    l_timeoutMs = l_nextArtifact.Information.RequestTimeoutMs % 1000;
    bool result =
        m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_ARTIFACT_RSPN].Start(
            l_timeoutSec, l_timeoutMs, 0, 0);
    if (FALSE == result) {  // LCOV_EXCL_BR_LINE 200:As it is always TRUE
      // LCOV_EXCL_START 200:As it is always TRUE
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Failed to start timer kSSL_ERROR_EVENT_TIMER_ARTIFACT_RSPN.");
      // LCOV_EXCL_STOP
    }
    switch (l_nextArtifact.Information.Cb.Type) {
      case eCbTypePath: {
        l_eStatus = CheckPathForArtifact(f_hApp, l_nextArtifact);
      }
        break;

      case eCbTypeFunction: {
        if (l_nextArtifact.Information.Cb.Function == NULL) {  // LCOV_EXCL_BR_LINE 200:As it is not always NULL
          AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
          l_eStatus = eFrameworkunifiedStatusNullPointer;  // LCOV_EXCL_LINE 200:As it is not always NULL
        } else {
          l_eStatus = l_nextArtifact.Information.Cb.Function(f_hApp,
                                                             l_nextArtifact);
          LOG_STATUS_IF_ERRORED(
              l_eStatus,
              "l_nextArtifact.Information.Cb.Function(f_hApp, l_nextArtifact)");
        }
      }
        break;

      case eCbTypeInvalid:
      default:
      {
        FRAMEWORKUNIFIEDLOG(
            ZONE_ERR,
            __FUNCTION__,
            " Error. Unknown artifact or artifact owner for artifact ID:"
            " %d. Invalid logging artifact configuration likely.",
            l_nextArtifact.ArtifactId);
      }
        break;
    }
  } else {
    if ((m_errorEventNtfData.EventType == eErrorEventTypeUserInvokedClearLogs)
        || (m_errorEventNtfData.EventType
            == eErrorEventTypeUserInvokedCollectNaviLog)) {
      l_eStatus = this->OnStorageResponseOk(f_hApp);
      return (l_eStatus);
    }
    uint8_t status;
    Clock_getSystemTimeY2K38(&m_time, &status);
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
           " Info. All logging error event artifacts have been collected.");
    l_eStatus = m_loggerUtil.checkDestinationAvailable(m_errorEventNtfData);
    LOG_STATUS_IF_ERRORED(
        l_eStatus,
        "m_loggerUtil.checkDestinationAvailable(m_errorEventNtfData)");
    if (eFrameworkunifiedStatusOK == l_eStatus) {
      /* Check one last time after all logs have been collected   */
      /* if we should show popup for archiving and writing to USB */
      l_eStatus = m_loggerPopups.ShowStartPopup(
          f_hApp, m_errorEventNtfData, &m_artifactRequestVec,
          m_loggerUtil.getDestination(m_errorEventNtfData));
      LOG_STATUS_IF_ERRORED(
          l_eStatus,
          "m_loggerPopups.ShowStartPopup(f_hApp,m_errorEventNtfData,&m_artifactRequestVec )");

      l_eStatus = m_loggerUtil.getFilePathAndName(f_hApp, m_errorEventNtfData,
                                                  m_time, m_archiveDestination);
      LOG_STATUS_IF_ERRORED(
          l_eStatus,
          "m_loggerUtil.getFilePathAndName()");

      std::string destination_path = m_loggerUtil.getDestination(
          m_errorEventNtfData);
      if (destination_path.compare(m_pLoggerCfg->m_emmcOutputPath) == 0) {
        if (eFrameworkunifiedStatusOK
            != m_loggerUtil.deleteOldEmmcLog(m_archiveDestination,
                                             m_errorEventNtfData.EventType)) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
                 " Error. m_loggerUtil.deleteOldEmmcLog()");
        }
      }

      l_eStatus = this->m_loggerStorage.Start(m_archiveDestination,
                                              this->m_artifactResponseVec,
                                              m_time);
      LOG_STATUS_IF_ERRORED(
          l_eStatus,
          "m_loggerStorage.Start()");
      if (l_eStatus != eFrameworkunifiedStatusOK) {
        l_eStatus = this->OnStorageResponseWriteFailed(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus,
                              "this->OnStorageResponseWriteFailed(f_hApp)");
      }
    } else {
      l_eStatus = this->OnStorageResponseNotFound(f_hApp);
      LOG_STATUS_IF_ERRORED(
          l_eStatus,
          "this->OnStorageResponseNotFound(f_hApp)");
    }
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnArtifactResponse
//  brief    : This function is called when an artifact has been made ready
//             by the owning service.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnArtifactResponse(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  ARTIFACT_RESPONSE l_artifactResponse;

  if (eFrameworkunifiedStatusOK != (l_eStatus = ReadMsg<ARTIFACT_RESPONSE>(f_hApp, l_artifactResponse))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOG_ERROR("ReadMsg()");  // LCOV_EXCL_LINE 200:To ensure success
  } else {
    m_errorEventTimers[kSSL_ERROR_EVENT_TIMER_ARTIFACT_RSPN].Stop();

    // Prevent processing of artifacts that arrive after the error event logging session has completed.
    if (m_artifactRequestVec.size() > 0) {
      TEXT(__FUNCTION__, "Artifact ID:%d received.",
           l_artifactResponse.ArtifactId);

      TLoggingArtifact &l_artifactCurr = m_artifactRequestVec.back();
      if (l_artifactCurr.ArtifactId != l_artifactResponse.ArtifactId) {
        TEXT(
            __FUNCTION__,
            "Failure collecting current artifact. Expected artifact ID:%d, received artifact ID:%d."
            " Ignoring received artifact.",
            l_artifactCurr.ArtifactId, l_artifactResponse.ArtifactId);
      } else {
        TLoggingArtifactResponse l_response;
        l_response.ArtifactId = l_artifactResponse.ArtifactId;
        l_response.Filepath = l_artifactResponse.FilePathAndName;
        l_response.Remove = l_artifactCurr.Information.Remove;
        m_artifactResponseVec.push_back(l_response);
        m_artifactRequestVec.pop_back();  // Remove received artifact from request vector.
        l_eStatus = RequestNextArtifact(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "RequestNextArtifact()");
      }
    } else {
      FRAMEWORKUNIFIEDLOG(
          ZONE_ERR,
          __FUNCTION__,
          " Error. Received spurious artifact ID: %d. No error event logging session active.",
          l_artifactResponse.ArtifactId);  // LCOV_EXCL_BR_LINE 5:macro
    }
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnArtifactResponseTimeout
//  brief    : This function is called when a requested artifact response
//             fails to arrive in the required amount of time.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnArtifactResponseTimeout(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (m_artifactRequestVec.size() > 0) {  // LCOV_EXCL_BR_LINE 200:As it cannot always be 0
    TLoggingArtifact &l_artifactCurr = m_artifactRequestVec.back();

    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. Artifact response timer expired for artifact ID: %d.",
           l_artifactCurr.ArtifactId);

    // Remove artifact from request vector.
    m_artifactRequestVec.pop_back();

    RequestNextArtifact(f_hApp);
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnArtifactRequest
//  brief    : This function services an artifact request generated by
//             the error event sub system.  The requested artifact will
//             be one of the artifacts owned by SSL.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnArtifactRequest(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  EArtifactId l_requestedArtifactId;

  if (eFrameworkunifiedStatusOK
      != (l_eStatus = ReadMsg<EArtifactId>(f_hApp, l_requestedArtifactId))) {
    LOG_ERROR("ReadMsg()");
  } else {
    switch (l_requestedArtifactId) {
      case eArtifactIdInterfaceunifiedDebugLog:
        l_eStatus = OnObtainLoggerserviceLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainLoggerserviceLogRequest()");
        break;

      case eArtifactIdTransmitLog:
        l_eStatus = OnObtainTransmitLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainTransmitLogRequest()");
        break;

      case eArtifactIdPerformanceLog:
        l_eStatus = OnObtainPerformanceLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainPerformanceLogRequest()");
        break;

      case eArtifactIdScreenShot:
        l_eStatus = OnObtainScreenShotRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainScreenShotRequest()");
        break;

      case eArtifactIdKernelLog:
        l_eStatus = OnObtainKernelLogInfoRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainKernelLogInfoRequest()");
        break;

      case eArtifactIdDRInitialLog:
        l_eStatus = OnObtainDRInitialLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainDRInitialLogRequest()");
        break;

      case eArtifactIdDRLocationLog:
        l_eStatus = OnObtainDRLocationLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnObtainDRLocationLogRequest()");
        break;

      case eArtifactIdClearAllLog:
        l_eStatus = OnClearAllLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnClearAllLogRequest()");
        break;

      case eArtifactIdNaviLog:
        l_eStatus = OnNaviLogRequest(f_hApp);
        LOG_STATUS_IF_ERRORED(l_eStatus, "OnNaviLogRequest()");
        break;

      default:
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. Unsupported logging artifact requested: %d.",
               l_requestedArtifactId);
        break;
    }
  }

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnStorageResponseOk
//  brief    : This function services response from the storage thread. It
//             is called when the logs have been stored successfully.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnStorageResponseOk(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  l_eStatus = this->m_loggerPopups.ShowEndPopup(f_hApp, m_errorEventNtfData,
                                                m_archiveDestination);
  LOG_STATUS_IF_ERRORED(
      l_eStatus,
      "this->m_loggerPopups.ShowEndPopup(f_hApp,m_errorEventNtfData,m_archiveDestination)");

  if (m_errorEventNtfData.EventType == eErrorEventTypeDiagEvent) {
    l_eStatus = sendDiagEventResponse();
    LOG_STATUS_IF_ERRORED(l_eStatus, "sendDiagEventResponse()");
  }
  if (m_errorEventNtfData.isNeedReboot == TRUE) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "System will reboot soon, so stop logging function.");
    StopLoggingFunction(f_hApp);
  }
  m_bIsPrevEventCompleted = true;
  l_eStatus = SendLogCompleteRequestToSystemManager(eFrameworkunifiedStatusOK);

  l_eStatus = m_loggerCanEvent.PublishEndEvent(f_hApp, m_errorEventNtfData,
                                               m_currentEventTriggerNumber,
                                               m_time);
  LOG_STATUS_IF_ERRORED(l_eStatus, "m_loggerCanEvent.PublishEndEvent();");
  LOG_STATUS_IF_ERRORED(l_eStatus, "SendLogCompleteRequestToSystemManager()");
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

///////////////////////////////////////////////////////////////////////////
//  Function : OnStorageResponseWriteFailed
//  brief    : This function services response from the storage thread. It
//             is called when the logs failed to be written to the target
//             destination.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnStorageResponseWriteFailed(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  l_eStatus = m_loggerPopups.ShowErrorPopup(f_hApp, m_errorEventNtfData,
                                            (UI_16) eWriteToDeviceFailed);
  LOG_STATUS_IF_ERRORED(
      l_eStatus, "m_loggerPopups.ShowErrorPopup(f_hApp, eWriteToDeviceFailed)");

  if (m_errorEventNtfData.EventType == eErrorEventTypeDiagEvent) {
    sendDiagEventErrorResponse(eDEVICE_WRITE_ERROR);
  }
  if (m_errorEventNtfData.isNeedReboot == TRUE) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "System will reboot soon, so stop logging function.");
    StopLoggingFunction(f_hApp);
  }
  m_bIsPrevEventCompleted = true;
  l_eStatus = SendLogCompleteRequestToSystemManager(eFrameworkunifiedStatusFail);

  l_eStatus = m_loggerCanEvent.PublishErrorEvent(f_hApp, m_errorEventNtfData,
  TRUE,
                                                 m_currentEventTriggerNumber,
                                                 m_time);
  LOG_STATUS_IF_ERRORED(l_eStatus, "m_loggerCanEvent.PublishErrorEvent();");

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnStorageResponseNotFound
//  brief    : This function services response from the storage thread. It
//             is called when the logs failed to be written to the target
//             destination because the target was not found
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnStorageResponseNotFound(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  l_eStatus = m_loggerPopups.ShowErrorPopup(f_hApp, m_errorEventNtfData,
                                            (UI_16) eSelectedDeviceNotFound);
  LOG_STATUS_IF_ERRORED(
      l_eStatus,
      "m_loggerPopups.ShowErrorPopup(f_hApp, eSelectedDeviceNotFound)");

  if (m_errorEventNtfData.EventType == eErrorEventTypeDiagEvent) {
    l_eStatus = sendDiagEventErrorResponse(eDEVICE_NOT_AVAILABLE);
    LOG_STATUS_IF_ERRORED(l_eStatus, "sendDiagEventErrorResponse(eDEVICE_NOT_AVAILABLE)");
  }
  if (m_errorEventNtfData.isNeedReboot == TRUE) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "System will reboot soon, so stop logging function.");
    StopLoggingFunction(f_hApp);
  }
  m_bIsPrevEventCompleted = true;
  l_eStatus = SendLogCompleteRequestToSystemManager(eFrameworkunifiedStatusFail);

  l_eStatus = m_loggerCanEvent.PublishErrorEvent(f_hApp, m_errorEventNtfData,
  TRUE,
                                                 m_currentEventTriggerNumber,
                                                 m_time);
  LOG_STATUS_IF_ERRORED(l_eStatus, "m_loggerCanEvent.PublishErrorEvent();");

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

///////////////////////////////////////////////////////////////////////////
//  Function : OnStorageResponseNoWritten
//  brief    : This function services response from the storage thread. It
//             is called when no logs where found.
///////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CErrorEvent::OnStorageResponseNoWritten(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  l_eStatus = m_loggerPopups.ShowErrorPopup(f_hApp, m_errorEventNtfData,
                                            (UI_16) eNoLogToStore);
  LOG_STATUS_IF_ERRORED(l_eStatus,
                        "m_loggerPopups.ShowErrorPopup(f_hApp, eNoLogToStore)");

  if (m_errorEventNtfData.EventType == eErrorEventTypeDiagEvent) {
    l_eStatus = sendDiagEventErrorResponse(eNO_ERROR_INFO);
    LOG_STATUS_IF_ERRORED(l_eStatus, "sendDiagEventErrorResponse(eNO_ERROR_INFO)");
  }
  if (m_errorEventNtfData.isNeedReboot == TRUE) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "System will reboot soon, so stop logging function.");
    StopLoggingFunction(f_hApp);
  }
  m_bIsPrevEventCompleted = true;
  l_eStatus = SendLogCompleteRequestToSystemManager(eFrameworkunifiedStatusOK);

  l_eStatus = m_loggerCanEvent.PublishErrorEvent(f_hApp, m_errorEventNtfData,
  TRUE,
                                                 m_currentEventTriggerNumber,
                                                 m_time);
  LOG_STATUS_IF_ERRORED(l_eStatus, "m_loggerCanEvent.PublishErrorEvent();");

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

EFrameworkunifiedStatus CErrorEvent::sendDiagEventErrorResponse(EELL_ErrorCode f_errCode) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  if (this->m_ServiceName.length() > 0) {
    l_eStatus = sendDiagEventErrorResponse(f_errCode, this->m_ServiceName);
    this->m_ServiceName = "";
  }

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

EFrameworkunifiedStatus CErrorEvent::sendDiagEventErrorResponse(EELL_ErrorCode f_errCode,
                                                   std::string f_destName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(m_diagsessionhandle, SS_LOGGERCOPYEMERGENCYLOGS_ERROR_RESP, sizeof(EELL_ErrorCode), &f_errCode))) {  // LCOV_EXCL_BR_LINE 4: NSFW error case.  // NOLINT[whitespace/line_length]
    // LCOV_EXCL_START 4: NSFW error case.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "SS_LOGGERCOPYEMERGENCYLOGS_ERROR_RESP Msg send failed = %x",
           l_eStatus);
    // LCOV_EXCL_STOP
  }

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

EFrameworkunifiedStatus CErrorEvent::sendDiagEventResponse(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedSendMsg(m_diagsessionhandle, SS_LOGGERCOPYEMERGENCYLOGS_SUCCESS_RESP, 0, NULL))) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "SS_LOGGERCOPYEMERGENCYLOGS_SUCCESS_RESP Msg send failed = %x",
           l_eStatus);
  }

  m_ServiceName = "";

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

EFrameworkunifiedStatus CErrorEvent::SetDiagEventSourceName(std::string f_serviceName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  if ((f_serviceName.length() > 0)
      && (this->m_ServiceName.length() == 0)) {
    this->m_ServiceName = f_serviceName;
    l_eStatus = eFrameworkunifiedStatusOK;
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error. f_serviceName(%s), m_serviceName(%s)",
           f_serviceName.c_str(), m_ServiceName.c_str());
  }

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

void CErrorEvent::SetDiagSessionHandle(HANDLE f_sessionhandle) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  m_diagsessionhandle = f_sessionhandle;

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

void CErrorEvent::SetMileage(UI_32 f_mileage) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  this->m_loggerUtil.SetMilage(f_mileage);
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

// LCOV_EXCL_START 200: 
EFrameworkunifiedStatus CErrorEvent::SaveNaviLog(EPWR_SHUTDOWN_TRIGGER_TYPE errType) {
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  UI_32 l_logMaxNum = 0;
  std::string l_Filename = "";

  uint32_t l_time;
  uint8_t status;
  Clock_getSystemTimeY2K38(&l_time, &status);
  l_eStatus = m_loggerUtil.getEmmcNaviLogParams(l_time, errType, l_Filename,
                                                l_logMaxNum);

  if (eFrameworkunifiedStatusOK != l_eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           " Error: getEmmcNaviLogParams NaviLog update failed %d", l_eStatus);
  } else {
    if (l_logMaxNum == 0) {
      /*OutputNaviLogNmlMax or OutputNaviLogErrMax = 0. */
      FRAMEWORKUNIFIEDLOG(
          ZONE_WARN,
          __FUNCTION__,
          " Warning: Not update NaviLog. OutputNaviLogNmlMax or OutputNaviLogErrMax = 0");
    } else {
      FILE *fp;
      void *p;
      p = EL_mem_exram_mmap_simple(EL_MEM_ID_NAVI_LOG, PROT_READ | PROT_WRITE,
      MAP_SHARED,
                                   EL_MEM_CACHE_INVALID);
      if (p == MAP_FAILED) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Error : EL_mem_exram_mmap_simple MAP_FAILD");
        l_eStatus = eFrameworkunifiedStatusFail;
      } else {
        fp = fopen(l_Filename.c_str(), "wb");
        if (fp == NULL) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not open file %s",
                 l_Filename.c_str());
          l_eStatus = eFrameworkunifiedStatusAccessError;
        } else {
          fwrite(p, sizeof(unsigned char), EL_mem_getLength(EL_MEM_ID_NAVI_LOG),
                 fp);
          fclose(fp);
        }
        if (0 != EL_mem_exram_munmap(p, EL_mem_getLength(EL_MEM_ID_NAVI_LOG))) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error : EL_mem_exram_munmap");
        }
      }
    }
  }

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

EFrameworkunifiedStatus CErrorEvent::VerifyExtStorage(TLoggerErrorEvent event) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
  std::string f_path;

  f_path = m_pLoggerCfg->getUsb0MountPath();

  if (eFrameworkunifiedStatusOK == l_eStatus) {
    l_eStatus = eFrameworkunifiedStatusFail;

    if (eFrameworkunifiedStatusFail == l_eStatus) {
      // timeout or error
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error : get secure log failed or timeout");
    }
  } else {
    // timeout
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error : ticket verify timeout.");
  }

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

bool CErrorEvent::IsNeedVerify(EErrorEventType type) {
  bool ret = false;
  switch (type) {
    case eErrorEventTypeUserInvokedCollectScreenShot:
    case eErrorEventTypeUserInvokedCollectAllLogs:
    case eErrorEventTypeUserInvokedCollectInterfaceunifiedLogs:
    case eErrorEventTypeInterfaceunifiedEmmcLogs:
    case eErrorEventTypeEelExport:
    case eErrorEventTypeDiagEvent:
    case eErrorEventTypeCanEvent:
      ret = true;
      break;
    default:
      break;
  }
  return ret;
}