/*
 * @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_SystemServices_DeviceDetection
/// \brief    This file contains service interface functions.
///
///////////////////////////////////////////////////////////////////////////////
#include "system_service/ss_devicedetection_service_ifc.h"
#include <native_service/frameworkunified_application.h>
#include <native_service/frameworkunified_framework_if.h>
#include <native_service/frameworkunified_types.h>
#include <native_service/frameworkunified_framework_types.h>
#include <string.h>

#ifdef AGL_STUB
#else
#include "dcmd_sim_mmcsd.h"
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#ifdef AGL_STUB
#else
#include <sys/dcmd_cam.h>
#endif
#include <errno.h>
#include <sys/ioctl.h>
#include <linux/cdrom.h>
#include <asm-generic/param.h>

#include "system_service/ss_services.h"
#include "system_service/ss_devicedetection_service_protocol.h"
#include "system_service/ss_devicedetection_service_protocol_local.h"
#include "system_service/ss_devicedetection_service_notifications.h"
#include "system_service/ss_devicedetection_service_local.h"
#include "system_service/ss_devicedetection_service_types_local.h"
#include "ss_devicedetection_service_if_interfaceunifiedlog.h"

DeviceDetectionServiceIf::DeviceDetectionServiceIf()
    : m_hApp(NULL),
      m_hService(NULL),
      m_hSession(NULL) {
}

DeviceDetectionServiceIf::~DeviceDetectionServiceIf() {
  CloseSessionRequest();  // if the session is still connected
  if ((NULL != m_hApp) && (NULL != m_hService)) {
    FrameworkunifiedCloseService(m_hApp, m_hService);
  }
  m_hService = NULL;
  m_hSession = NULL;
  m_hApp = NULL;
}  // LCOV_EXCL_BR_LINE 10:Because destructor

EFrameworkunifiedStatus DeviceDetectionServiceIf::NotifyOnDeviceDetectionAvailability(
    CbFuncPtr f_pCallBackFn) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;
  if (NULL != m_hApp && NULL != f_pCallBackFn) {
    // Subscriptions
    FrameworkunifiedNotificationCallbackHandler
    g_aryDeviceDetect_Notif_Cbs[] = {
      // Notifications name,                Call back function
      { NTFY_SS_Device_Detection_Service_Availability, f_pCallBackFn},
    };

    if (0 != strcmp(SS_DEV_DETECT_SRV, FrameworkunifiedGetAppName(m_hApp))) {
      // Subscribe and attach call backs to notifications
      if (eFrameworkunifiedStatusOK
          != (eStatus = FrameworkunifiedSubscribeNotificationsWithCallback(
              m_hApp, g_aryDeviceDetect_Notif_Cbs,
              _countof(g_aryDeviceDetect_Notif_Cbs)))) {
        FRAMEWORKUNIFIEDLOG(
            ZONE_ERR,
            __FUNCTION__,
            "Error: FrameworkunifiedAttachNotificationCallbacksToDispatcher Failed Status:0x%x ",
            eStatus);
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::DetachDeviceDetectionAvailabilityCb() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;
  if (NULL != m_hApp) {
    if (0 != strcmp(SS_DEV_DETECT_SRV, FrameworkunifiedGetAppName(m_hApp))) {
      // Unsubscribe and detach call backs to notifications
      if (eFrameworkunifiedStatusOK != (eStatus =
          FrameworkunifiedUnsubscribeNotificationWithCallback(m_hApp, NTFY_SS_Device_Detection_Service_Availability))) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Error: InterfaceunifiedDetachNotificationCallback Failed Status:0x%x ",
               eStatus);
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::NotifyOnOpenSessionAck(
    CbFuncPtr f_pCallBackFn) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;
  if (NULL != m_hApp && NULL != f_pCallBackFn) {
    if (eFrameworkunifiedStatusOK
        != (eStatus = FrameworkunifiedAttachCallbackToDispatcher(m_hApp,
                                                    SS_DEV_DETECT_SRV,
                                                    PROTOCOL_OPEN_SESSION_ACK,
                                                    f_pCallBackFn))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: FrameworkunifiedAttachCallbackToDispatcher Failed Status:0x%x ",
             eStatus);
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::DetachOpenSessionAckCb() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;
  if (NULL != m_hApp) {
    if (eFrameworkunifiedStatusOK
        != (eStatus = FrameworkunifiedDetachCallbackFromDispatcher(m_hApp,
        SS_DEV_DETECT_SRV,
                                                      PROTOCOL_OPEN_SESSION_ACK))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: FrameworkunifiedDetachCallbackFromDispatcher Failed Status:0x%x ",
             eStatus);
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::NotifyOnCloseSessionAck(
    CbFuncPtr f_pCallBackFn) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;

  if (NULL != m_hApp && NULL != f_pCallBackFn) {
    if (eFrameworkunifiedStatusOK
        != (eStatus = FrameworkunifiedAttachCallbackToDispatcher(m_hApp,
        SS_DEV_DETECT_SRV,
                                                    PROTOCOL_CLOSE_SESSION_ACK,
                                                    f_pCallBackFn))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: FrameworkunifiedAttachCallbackToDispatcher Failed Status:0x%x ",
             eStatus);
    }
  }

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

EFrameworkunifiedStatus DeviceDetectionServiceIf::DetachCloseSessionAckCb() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;

  if (NULL != m_hApp) {
    if (eFrameworkunifiedStatusOK
        != (eStatus = FrameworkunifiedDetachCallbackFromDispatcher(
            m_hApp,
            SS_DEV_DETECT_SRV,
            PROTOCOL_CLOSE_SESSION_ACK))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: FrameworkunifiedDetachCallbackFromDispatcher Failed Status:0x%x ",
             eStatus);
    }
  }

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

EFrameworkunifiedStatus DeviceDetectionServiceIf::RegisterForDeviceDetectionEvent(
    SS_DeviceDetectionServerEvents f_eDevDetectEvent, CbFuncPtr f_pCallBackFn,
    PCSTR pFilepath) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;
  char l_filepathname[FILEPATH_SIZE] = { '\0' };
  int len = 0;

  if (NULL != pFilepath) {
    len = strlen(pFilepath);
    strcpy(l_filepathname, pFilepath);  // NOLINT (runtime/printf)
  }

  if (NULL != m_hSession && NULL != f_pCallBackFn) {
    if (CheckDetectEvent(f_eDevDetectEvent)) {
      if (eFrameworkunifiedStatusOK
          != (eStatus = FrameworkunifiedAttachCallbackToDispatcher(m_hApp,
          SS_DEV_DETECT_SRV,
                                                      f_eDevDetectEvent,
                                                      f_pCallBackFn, m_hSession))) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Error: FrameworkunifiedAttachCallbackToDispatcher Failed Status:0x%x ",
               eStatus);
      }

      eStatus = FrameworkunifiedSendMsg(m_hSession, SS_REGISTER_DETECT_EVENT,
                                         sizeof(SS_DeviceDetectionServerEvents),
                                         &f_eDevDetectEvent);
    } else {
      if (eFrameworkunifiedStatusOK
          != (eStatus = FrameworkunifiedAttachCallbackToDispatcher(m_hApp,
          SS_DEV_DETECT_SRV,
                                                      f_eDevDetectEvent,
                                                      f_pCallBackFn, m_hSession))) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Error: FrameworkunifiedAttachCallbackToDispatcher Failed Status:0x%x ",
               eStatus);
      }

      // client registers for the event
      if (eFrameworkunifiedStatusOK
          != (eStatus = FrameworkunifiedRegisterEvent(m_hSession, f_eDevDetectEvent))) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "Error: FrameworkunifiedRegisterEvents Failed Status:0x%x", eStatus);
      }

      if (NULL != pFilepath) {
        eStatus = FrameworkunifiedSendMsg(m_hSession, SS_REGISTER_FILEPATHNAME, len,
                                             l_filepathname);
      }
    }
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::UnRegisterForDeviceDetectionEvent(
    SS_DeviceDetectionServerEvents f_eDevDetectEvent) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;

  if (NULL != m_hSession) {
    if (eFrameworkunifiedStatusOK
        != (eStatus = FrameworkunifiedDetachCallbackFromDispatcher(m_hApp,
                                                      SS_DEV_DETECT_SRV,
                                                      f_eDevDetectEvent,
                                                      m_hSession))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: InterfaceunifiedDetachCallbackToDispatcher Failed Status:0x%x ", eStatus);
    }

    // client registers for the event
    if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedUnRegisterEvent(m_hSession, f_eDevDetectEvent))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "Error: FrameworkunifiedUnRegisterEvents Failed Status:0x%x", eStatus);
    }

    if (eFrameworkunifiedStatusOK != (eStatus = FrameworkunifiedSendMsg(m_hSession, SS_UNREGISTER_DETECT_EVENT,
                                              sizeof(SS_DeviceDetectionServerEvents),
                                              &f_eDevDetectEvent))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             "UnRegister Detect Event[0x%x] Send Error[0x%x]", f_eDevDetectEvent, eStatus);
    }
  }

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

BOOL DeviceDetectionServiceIf::Initialize(HANDLE hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL l_eStatus = TRUE;

  if (NULL != hApp) {
    m_hApp = hApp;
  } else {
    l_eStatus = FALSE;  // eFrameworkunifiedStatusInvldHandle;
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::OpenSessionRequest() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusInvldHandle;
  if (NULL != m_hApp) {
    // if the session is there then we need to close it first!
    if (NULL != m_hService) {
      CloseSessionRequest();
      FrameworkunifiedCloseService(m_hApp, m_hService);
      m_hService = NULL;
    }
    BOOL l_bServiceAvailable = FrameworkunifiedIsServiceAvailable(m_hApp);
    if (FALSE == l_bServiceAvailable) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__,
             "DeviceError: Service is unavailable");
      l_eStatus = eFrameworkunifiedStatusFail;
    } else {
      // Now open the service.
      if (l_bServiceAvailable
          && (NULL != (m_hService = OpenService()))) {  // LCOV_EXCL_BR_LINE 8:Because l_bServiceAvailable is always TRUE
        // [DM: TODO] Check if we need to open a session with some data sent to Server.
        UI_32 l_pTestData = 1;
        if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedOpenSessionWithData(m_hService,
                                                   (PVOID) &l_pTestData,
                                                   sizeof(UI_32)))) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error: FrameworkunifiedOpenSessionWithData Failed");
        }
      } else {
        l_eStatus = eFrameworkunifiedStatusFail;
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error: FrameworkunifiedOpenService Failed");
      }
    }
  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: OpenSessionRequest Failed %X",
           l_eStatus);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

HANDLE DeviceDetectionServiceIf::OpenService() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  HANDLE l_hService = NULL;

  if (NULL == (l_hService = FrameworkunifiedOpenService(m_hApp, SS_DEV_DETECT_SRV))) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error: FrameworkunifiedOpenService : Failed to open Device Detection Service");
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_hService;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::DecodeOpenSessionResponse() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusInvldHandle;

  if (NULL != m_hService && NULL != m_hApp) {  // LCOV_EXCL_BR_LINE 8:Because when m_hApp is NULL, m_hService is NULL
    if (NULL == (m_hSession = FrameworkunifiedGetOpenSessionHandle(m_hApp))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __PRETTY_FUNCTION__, "Error: Error in extracting OpenSessionAck response.");
      l_eStatus = eFrameworkunifiedStatusFail;
    } else {
      l_eStatus = eFrameworkunifiedStatusOK;
      FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Logger Session Name: %s, Session Id: %d",
             FrameworkunifiedGetSessionName(m_hSession), FrameworkunifiedGetSessionId(m_hSession));
    }
  } else {
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        "Error. m_hService: %p, m_hApp: %p is NULL. Open session handle not acquired,"
        " l_eStatus: eFrameworkunifiedStatusInvldHandle.", m_hService, m_hApp);
  }

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

EFrameworkunifiedStatus DeviceDetectionServiceIf::CloseSessionRequest() {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusInvldHandle;

  if (NULL != m_hService && NULL != m_hSession) {
    if (eFrameworkunifiedStatusOK != (l_eStatus = FrameworkunifiedCloseSession(m_hService, m_hSession))) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FrameworkunifiedCloseSession Failed");
    }
    m_hSession = NULL;  // clear our session handle
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

BOOL DeviceDetectionServiceIf::CheckDetectEvent(
    SS_DeviceDetectionServerEvents f_eDevDetectEvent) {
  BOOL chkevt = FALSE;

  switch (f_eDevDetectEvent) {
    case SS_DEV_INFO_ANY_USB_EV:
    case SS_DEV_DETECT_ANY_USB_EV:
    case SS_DEV_DETECT_ANY_SD_EV:
    case SS_DEV_DETECT_ANY_DISC_EV:
    case SS_DEV_DETECT_ANY_USB_NCM_EV:

    case SS_DEV_DETECT_ANY_USB_DCM_NCM_EV:
    case SS_DEV_DETECT_ANY_USB__CWORD57__EV:
    case SS_DEV_DETECT_ANY_USB_ACM_EV:
    case SS_DEV_DETECT_ANY_USB_DEV_MNG_EV:
    case SS_DEV_DETECT_ANY_USB_VEHICLE_CTRL_EV:
    case SS_DEV_DETECT_ANY_USB_DSRC_APP_EV:
    case SS_DEV_DETECT_ANY_USB_DSRC_CTRL_EV:
    case SS_DEV_DETECT_ANY_USB_IR_VICS_DATA_EV:
    case SS_DEV_ERR_USB_OVER_CURRENT_EV:
    case SS_DEV_DETECT_ANY_USB_MTP_EV:
    case SS_DEV_INFO_ANY_USB_NOTIFY_EV:
    case SS_DEV_DETECT_ANY_USB__CWORD57__ROLE_EV:
    case SS_DEV_INFO_SD_FORMAT_COMP_EV:
    case SS_DEV_INFO_ANY_USB_DVDP_EV:
      chkevt = TRUE;
      break;
    default:
      break;
  }
  return chkevt;
}

static void ReadString(const char *file, char *buf, int len) {
  int fd;
  ssize_t r;
  char *tmp;

  if (file == NULL) {  // LCOV_EXCL_BR_LINE 8:Because file is not NULL
    // LCOV_EXCL_START  8:Because file is not NULL
    buf[0] = '\0';
    return;
    // LCOV_EXCL_STOP
  }

  fd = open(file, O_RDONLY);
  if (fd < 0) {  // LCOV_EXCL_BR_LINE 6:Because the sequence at the time of open failure cannot be passed
    // LCOV_EXCL_START 6:Because the sequence at the time of open failure cannot be passed
    buf[0] = '\0';
    return;
    // LCOV_EXCL_STOP
  }

  r = read(fd, buf, len);
  close(fd);
  if (r > 0 && r < len) {
    buf[r] = '\0';
    r--;
    /* If there is a line feed code'\n' at the end of the acquired data, replace it with '\0' */
    while (buf[r] == '\n') {
      buf[r] = '\0';
      if (r == 0)
        break;
      r--;
    }
    /* If there is a line feed code'\n' in the middle of the acquired data, replace with '\0' */
    tmp = buf;
    while ((tmp = strchr(tmp, '\n')) != NULL) {
      *tmp = ' ';
      tmp++;
    }
    return;
  } else {
    buf[0] = '\0';
  }
}

static bool isMounttedDir(char* pMountDir) {
  char buf[4096];

  if (!pMountDir) {  // LCOV_EXCL_BR_LINE 8:Because pMountDir is not NULL
    // LCOV_EXCL_START 8:Because pMountDir is not NULL
    return false;
    // LCOV_EXCL_STOP
  }

  ReadString("/proc/mounts", buf, sizeof(buf));
  if (strstr(buf, pMountDir)) {  // The mount folder is already in use as a mount point
    return true;
  }

  return false;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::MountSD(uint8_t part_num,
                                             BOOL *already_mounted) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "part_num %d", part_num);

  if (NULL == m_hSession) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_hSession is NULL");
    return eFrameworkunifiedStatusInvldHandle;
  }

  if (part_num > 3) {
    return eFrameworkunifiedStatusInvldParam;
  }

  char mount_dir[256];
  if (part_num != 0) {
    sprintf(mount_dir, "/mnt/mmcblk1p%d", part_num);  // NOLINT (runtime/printf)
  } else {
    sprintf(mount_dir, "/mnt/mmcblk1");  // NOLINT (runtime/printf)
  }
  if (isMounttedDir(mount_dir)) {
    *already_mounted = TRUE;
    return eFrameworkunifiedStatusOK;
  } else {
    *already_mounted = FALSE;
  }

  char filename[256];
  struct stat st;
  if (part_num != 0) {
    sprintf(filename, "/dev/mmcblk1p%d", part_num);  // NOLINT (runtime/printf)
  } else {
    sprintf(filename, "/dev/mmcblk1");  // NOLINT (runtime/printf)
  }
  if (stat(filename, &st) != 0) {
    return eFrameworkunifiedStatusAccessError;
  }

  if (eFrameworkunifiedStatusOK
      == (eStatus = FrameworkunifiedSendMsg(m_hSession, SS_DEV_MOUNT_SD, sizeof(uint8_t),
                               &part_num))) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Send MountSD msg Sucessfully");
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");

  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::UmountSD(uint8_t part_num,
                                              BOOL *already_umounted) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusInvldHandle;

  FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "part_num %d", part_num);

  if (NULL == m_hSession) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "m_hSession is NULL");
    return eFrameworkunifiedStatusInvldHandle;
  }

  if (part_num > 3) {
    return eFrameworkunifiedStatusInvldParam;
  }

  char mount_dir[256];
  if (part_num != 0) {
    sprintf(mount_dir, "/mnt/mmcblk1p%d", part_num);  // NOLINT (runtime/printf)
  } else {
    sprintf(mount_dir, "/mnt/mmcblk1");  // NOLINT (runtime/printf)
  }

  if (isMounttedDir(mount_dir)) {
    *already_umounted = FALSE;
  } else {
    *already_umounted = TRUE;
    return eFrameworkunifiedStatusOK;
  }

  char filename[256];
  struct stat st;

  if (part_num != 0) {
    sprintf(filename, "/dev/mmcblk1p%d", part_num);  // NOLINT (runtime/printf)
  } else {
    sprintf(filename, "/dev/mmcblk1");  // NOLINT (runtime/printf)
  }
  if (stat(filename, &st) != 0) {
    return eFrameworkunifiedStatusAccessError;
  }

  if (eFrameworkunifiedStatusOK
      == (eStatus = FrameworkunifiedSendMsg(m_hSession, SS_DEV_UMOUNT_SD, sizeof(uint8_t),
                               &part_num))) {
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Send UmountSD msg Sucessfully");
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");

  return eStatus;
}

static const uint8_t VBUS_RESET_INTERVAL_MIN = 11;

static EFrameworkunifiedStatus SendUsbVBusResetMsg(HANDLE handle, int8_t port, uint8_t interval) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;

  if (NULL == handle) {
    FRAMEWORKUNIFIEDLOG(ZONE_WARN, __func__, "Invalid Handle.");
    return eFrameworkunifiedStatusInvldHandle;
  }

  int16_t data[] = {port, interval};
  eStatus = FrameworkunifiedSendMsg(handle, SS_USB_VBUS_RESET, sizeof(data), data);

  if (eFrameworkunifiedStatusOK != eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Send Error[0x%x]", eStatus);
    return eStatus;
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "-");
  return eStatus;
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::UsbVBusReset(int8_t port, uint8_t interval) {
  return SendUsbVBusResetMsg(m_hSession, port, interval);
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::UsbVBusReset(int8_t port) {
  return SendUsbVBusResetMsg(m_hSession, port, VBUS_RESET_INTERVAL_MIN);
}

EFrameworkunifiedStatus DeviceDetectionServiceIf::RoleSwStateNotify(
    SS_DEV_ROLE_SW_STATE state) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusFail;
  EFrameworkunifiedStatus result = eFrameworkunifiedStatusFail;
  UI_32 rcvlength = 0;
  UI_32 bufflength;

  if (NULL == m_hSession) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "No Session");
    return eFrameworkunifiedStatusInvldHandle;
  }

  bufflength = sizeof(EFrameworkunifiedStatus);
  eStatus = FrameworkunifiedInvokeSync(m_hSession, SS_DEV_ROLE_SW_STATE_NOTIFY,
                          sizeof(SS_DEV_ROLE_SW_STATE), &state, bufflength,
                          &result, &rcvlength);

  if (eFrameworkunifiedStatusOK != eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedSendMsg Send Error[0x%x]", eStatus);
    return eStatus;
  }

  if (bufflength != rcvlength) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
           "FrameworkunifiedInvokeSync Response Error. bufflen[%d], rcvlen[%d]", bufflength,
           rcvlength);
    return eStatus;
  }

  eStatus = result;

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

EFrameworkunifiedStatus DeviceDetectionServiceIf::FormatSD(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;

  if (NULL == m_hSession) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Invalid Handle.");
    return eFrameworkunifiedStatusInvldHandle;
  }

  if (access("/dev/mmcblk1", F_OK) != 0) {
    return eFrameworkunifiedStatusAccessError;
  }

  eStatus = FrameworkunifiedSendMsg(m_hSession, SS_DEV_FORMAT_SD, 0, NULL);

  if (eFrameworkunifiedStatusOK != eStatus) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "FrameworkunifiedSendMsg Send Error[0x%x]", eStatus);
    return eStatus;
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eStatus;
}  // LCOV_EXCL_BR_LINE 10:Because the last line