myvtm/DevAdapter/keba/HSPScanner.keba.1.2/hspscannerimpl.cpp

#include "hspscannerimpl.h"
//#include "CkDBus.h"
LOG_EXTERN()

void GetModulePath(char* lpStrPath)
{
   LOG_FUNCTION();
   char szBuff[MAX_PATH];
   Dl_info path_info;
   std::string strLog = "";
   memset(&path_info, 0x00, sizeof(path_info));
   memset(szBuff, 0x00, sizeof(szBuff));
   int iRet = dladdr((const void*)GetModulePath, &path_info);
   if(!iRet)
   {
       return;
   }
   else
   {
       strcpy(szBuff, path_info.dli_fname);

       char *pLast=strrchr(szBuff, '/'); //find last '/'

       if(nullptr != pLast) *pLast = 0;  //cut


       strcat(szBuff, "/"); //


       if(nullptr != lpStrPath)
       {
           strcpy(lpStrPath, szBuff);
       }
   }
}

HSPSClassImpl::HSPSClassImpl():
    m_pDll(nullptr)
  ,m_bDevOpen(false)
  ,m_bPreview(false)
  ,m_bShow(false)
  ,m_nPort(-1)
  ,m_strIniPath("")
  ,m_strDllPath("")
{
    LOG_FUNCTION();
    memset(m_strModulePath, 0x00, sizeof(m_strModulePath));
    GetModulePath(m_strModulePath); //获取ｓｏ所在路径

    m_strIniPath = m_strModulePath;
    m_strIniPath += "CK-VTM-E1000.INI";
    m_strDllPath = m_strModulePath;

    m_nX = 1280;
    m_nY = 0;
    m_nWidth = 1920;

}

HSPSClassImpl::~HSPSClassImpl()
{
    LOG_FUNCTION();
    DevClose();
    if(m_pDll != nullptr)
    {
        delete m_pDll;
    }
    m_bDevOpen = false;
    m_bPreview = false;
    m_bShow = false;
}

int HSPSClassImpl::ErrorCodeConvert(int nErrorCode)
{
    switch (nErrorCode) {
    case FR_RET_SUCC:
        return DEP_SUCCESS;
    case FR_RET_FAIL:
        return DEP_NO_E_HSPSCANNER_FR_RET_FAIL;
    case FR_RET_PARA:
        return DEP_NO_E_HSPSCANNER_FR_RET_PARA;
    case FR_RET_NDEV:
        return DEP_NO_E_HSPSCANNER_FR_RET_NDEV;
    case FR_RET_NINI:
        return DEP_NO_E_HSPSCANNER_FR_RET_NINI;
    case FR_RET_BUSY:
        return DEP_NO_E_HSPSCANNER_FR_RET_BUSY;
    case FR_RET_DATA:
        return DEP_NO_E_HSPSCANNER_FR_RET_DATA;
    case FR_RET_NLNK:
        return DEP_NO_E_HSPSCANNER_FR_RET_NLNK;
    case FR_RET_NMEM:
        return DEP_NO_E_HSPSCANNER_FR_RET_NMEM;
    case FR_RET_ARDY:
        return DEP_NO_E_HSPSCANNER_FR_RET_ARDY;
    default:
        return DEP_ERROR_CODE_UNRECOGNIZABLE;
    }
}

ErrorCodeEnum HSPSClassImpl::DevOpen()
{
    LOG_FUNCTION();
    //LogM("HSPSClassImpl::Entry->HSPS DevOpen()!");
    int  iRet;
    CHAR strDllPath[256] = {0};
    char sDevInfo[64+1] = {0};
    char sID[1024] = {0};
    const char * tmpStr = "libBHCamBase.so";
    strncat(strDllPath, "libBHCamBase.so",strlen(tmpStr));
    m_pDll = new CDevDllLoad(strDllPath);
    if (nullptr == m_pDll)
    {
        LogM("HSPSClassImpl::Entry->HSPS DevOpen() new object CDevDllLoad failed!");
        SaveErrorInfo("厂家库libBHCamBase.so调用失败", DEP_DLL_NOT_FOUND, __PRETTY_FUNCTION__, __LINE__);
        return Error_DevNotAvailable;
    }
//    if(m_bDevOpen)
//    {
//        LogM("HSPSClassImpl::DevOpen() already open");
//        SaveErrorInfo("高拍仪已经打开", DEP_ALREADY_EXIST, __PRETTY_FUNCTION__, __LINE__);
//        return Error_DevAlreadyConnected;
//    }
    iRet = m_pDll->HIGH_StartCamera();
    //记日志
    if(iRet != FR_RET_SUCC)
    {
        LogM("HSPSClassImpl::Entry->HSPS DevOpen()->m_pDll->HIGH_StartCamera() failed! <=> iRet = %d",iRet);
        m_bDevOpen = false;
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "设备打开失败，HIGH_StartCamera() =[%d] ", iRet);
        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
        return Error_DevNotAvailable;
    }
    LogM("HSPSClassImpl::Entry->HSPS DevOpen()->m_pDll->HIGH_StartCamera() success! <=> iRet = %d",iRet);
    m_bDevOpen = true;
    memset(sDevInfo, 0, sizeof(sDevInfo));
    memset(sID, 0, sizeof(sID));
    iRet = m_pDll->HIGH_GetFirmwareVersion(sDevInfo);
    if (iRet == FR_RET_SUCC)
    {
        LogM("HSPSClassImpl::Leave->HSPS DevOpen()->m_pDll->HIGH_GetFirmwareVersion sucessfull!");
    }
    m_pDll->HIGH_SetCameraPixel(3264,2448);

    return Error_Succeed;
}



ErrorCodeEnum HSPSClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS GetDevCategory()!");
    int iRet = 0;
    char szDevInfo[128] = {0};
    char sID[1024] = {0};
    //记日志
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);
    memset(szDevInfo, 0, sizeof(szDevInfo));
    memset(sID, 0, sizeof(sID));
    iRet = m_pDll->HIGH_GetFirmwareVersion(szDevInfo);
    if(iRet == FR_RET_SUCC)
    {
        snprintf(devCategory.szType,sizeof (devCategory.szType) ,"PVER=Kai-wang#MID=%s", szDevInfo);
    }
    else
    {
        //memcpy(devCategory.szType, "PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]", strlen("PVER=Wellcom#MID=JZT-998APB-V20_V1.0.4.1_SC_[20150320]"));
        SaveErrorInfo("获取固件版本失败",ErrorCodeConvert(iRet),__PRETTY_FUNCTION__,__LINE__);
        return Error_DevConnFailed;
    }
    memcpy(devCategory.szVendor, "keba", strlen("keba"));
    LogM("devCategory.szType = %s",devCategory.szType);
    LogM("devCategory.szVendor = %s",devCategory.szVendor);
    LogM("HSPSClassImpl::Leave->HSPS GetDevCategory() sucessfull!");
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::Reset()
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS Reset()!");
    DevClose();
    LogM("HSPSClassImpl::Leave->HSPS Reset() sucessfull!");
    return DevOpen();
}

ErrorCodeEnum HSPSClassImpl::DevClose()
{
    LOG_FUNCTION();
    int iRet = -1;
    LogM("HSPSClassImpl::Entry->HSPS DevClose()!");
    if(!m_bDevOpen)
    {
        return Error_Succeed;
    }
    //CLOSEDEV();
	iRet = m_pDll->HIGH_CloseWindow();
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "窗口关闭失败，HIGH_CloseWindow() =[%d] ", iRet);
        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
    }
    iRet = m_pDll->HIGH_StopCamera();
    
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "摄像头关闭失败，HIGH_StopCamera() =[%d] ", iRet);
        SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
    }

    if(iRet == FR_RET_SUCC)
        m_bPreview = false;

    m_pDll->FreeDLL();
    m_bDevOpen = false;
    LogM("HSPSClassImpl::Leave->HSPS DevClose() sucessfull!");
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    /*LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS GetLastErr()!");
    devErrInfo.dwErrMsgLen = 0;
    memset(devErrInfo.szErrMsg, 0, sizeof(devErrInfo.szErrMsg));

    devErrInfo.dwErrMsgLen = (m_shErrCode << 16);
    sprintf(devErrInfo.szErrMsg, m_szErrMsg);
    devErrInfo.dwErrMsgLen += (strlen(devErrInfo.szErrMsg) & 0x0000FFFF);
    LogM("devErrInfo.szErrMsg = %s",devErrInfo.szErrMsg);
    LogM("HSPSClassImpl::Leave->HSPS GetLastErr() sucessfull!");
    return Error_Succeed;*/
    LOG_FUNCTION();
    devErrInfo.dwErrMsgLen = strlen(m_szErrMsg);
    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    memcpy(devErrInfo.szErrMsg, m_szErrMsg, devErrInfo.dwErrMsgLen<MAX_DEV_ERROR_MSG_LEN? devErrInfo.dwErrMsgLen:MAX_DEV_ERROR_MSG_LEN);
    return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetParam(ParamType type, ParamTypeValue value)
{
    LOG_FUNCTION();
    int iRet = -1;
    if(!m_bDevOpen)
    {
        SaveErrorInfo("SetParam设备未打开，设置参数失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->SetParam() failed 设备未打开");
        return Error_DevNotAvailable;

    }
	LogM("HSPSClassImpl::SetParam(type=%d,value=%d),line=%d",type,value,__LINE__);
    if(type == HSPS_MODEL_COLOR)
    {
        if(value == HSPS_COLOR_FULL)
        iRet = m_pDll->HIGH_SetColorType(0);

        else if (value == HSPS_COLOR_GREY) {
            iRet = m_pDll->HIGH_SetColorType(1);
        }
        else {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam输入色彩参数有误，type[%d] value[%d]", type, value);
            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::leave HSPS->SetParam(COLOR) ParamTypeValue error(%d)", value);
            return Error_Param;
        }
        if(iRet != FR_RET_SUCC)
        {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam色彩设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
            return Error_DevMedia;
        }

    }
    else if (type == HSPS_MODEL_ROTATE)
    {
        if(value == HSPS_ROTATE_NOANGLE)
            iRet = m_pDll->HIGH_SetRotateSize(0);

        else if (value == HSPS_ROTATE_LEFT)
            iRet = m_pDll->HIGH_SetRotateSize(1);

        else if (value == HSPS_ROTATE_MIRROR)
            iRet = m_pDll->HIGH_SetRotateSize(2);

        else if (value == HSPS_ROTATE_RIGHT)
            iRet = m_pDll->HIGH_SetRotateSize(3);

        else {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam输入旋转方向参数有误，type[%d] value[%d]", type, value);
            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::leave HSPS->SetParam(ROTATE) ParamTypeValue error(%d)", value);
            return Error_Param;
        }
        if(iRet != FR_RET_SUCC)
        {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam图像旋转失败，type[%d] value[%d]，return[%d]", type, value,iRet);
            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
            return Error_DevMedia;
        }
    }
    else if (type == HSPS_MODEL_SCANSIZE)
    {
        //自动纠偏
        if(value == HSPS_SCAN_FULL){
            iRet = m_pDll->HIGH_SetAutoCrop(false);
        }
            //

        else if (value == HSPS_SCAN_A4){
            iRet = m_pDll->HIGH_SetAutoCrop(false);
        }
            //

        else if (value == HSPS_SCAN_IDCARD){
            iRet = m_pDll->HIGH_SetAutoCrop(true);
        }
            //

        else {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam自动纠偏参数有误，type[%d] value[%d]", type, value);
            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::leave HSPS->SetParam(SCANSIZE) ParamTypeValue error(%d)", value);
            return Error_Param;
        }
        if(iRet != FR_RET_SUCC)
        {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam自动纠偏设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
            return Error_DevMedia;
        }
    }
    else if (type == HSPS_MODEL_VIEW)
    {
        if(value == HSPS_VIEW_HIDE)
            iRet = m_pDll->HIGH_HideWindow(1);


        else if (value == HSPS_VIEW_SHOW)
            iRet = m_pDll->HIGH_HideWindow(0);

        else {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetParam显示隐藏参数有误，type[%d] value[%d]", type, value);
            SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::leave HSPS->SetParam(VIEW) ParamTypeValue error(%d)", value);
            return Error_Param;
        }
        if(iRet != FR_RET_SUCC)
        {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "显示隐藏设置失败，type[%d] value[%d]，return[%d]", type, value,iRet);
            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
            LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] HIGH_SetAutoCrop error,line=%d",type,value,iRet,__LINE__);
            return Error_DevMedia;
        }

    }
    else
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "SetParam类型参数有误，type[%d] value[%d]", type, value);
        SaveErrorInfo(strMsg, DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->SetParam error(%d)", type);
        return Error_Param;
    }

//    if(iRet != FR_RET_SUCC)
//    {
//        SaveErrorInfo(iRet);
//        LogM("HSPSClassImpl::SetParam(type=%d,value=%d) = [%d] error,line=%d",type,value,iRet,__LINE__);
//        return Error_DevMedia;
//    }
     return Error_Succeed;
}

ErrorCodeEnum HSPSClassImpl::SetPreview(short nValue)
{
    LOG_FUNCTION();
	LogM("HSPSClassImpl::SetPreview(nValue=%d),line=%d",nValue,__LINE__);
    int iRet = -1;
    if(!m_bDevOpen)
    {
        SaveErrorInfo("SetPreview设备离线，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->SetPreview() failed");
        return Error_DevNotAvailable;
    }
    if(nValue == 1)
    {
        m_pDll->HIGH_GetStatus( &DevStatus);
        if(FR_DS_ONLINE==DevStatus)
        {           
            iRet = m_pDll->HIGH_CreateWindow(m_nX, m_nY, m_nWidth, m_nHeight);
            if(iRet == FR_RET_SUCC)
            {
                 m_bShow = 1;
                 m_bPreview = true;
            }
        }
        else {
            LogM("HSPSClassImpl::SetPreview() DevStatus = [%d] DevError:1->OFFLIN,2->BUSY,3->HARDWAREERROR,4->UNKNOW,line=%d",DevStatus,__LINE__);
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetPreview设备状态异常，HIGH_GetStatus() =[%d] ", DevStatus);
            SaveErrorInfo(strMsg, DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
            return Error_DevMedia;
        }
   }
    else if (nValue == 0)
    {
        iRet = m_pDll->HIGH_CloseWindow();
        if(iRet == FR_RET_SUCC)
        {
            m_bShow = 0;
            m_bPreview = false;
        }
        else
        {
            CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
            sprintf(strMsg, "SetPreview关闭窗口失败，HIGH_CloseWindow() =[%d] ", iRet);
            SaveErrorInfo(strMsg, ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
            return Error_DevMedia;
        }

    }

    else {
        SaveErrorInfo("SetPreview参数错误",DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__ );
        LogM("HSPSClassImpl::leave HSPS->SetPreview(%d) error", nValue);
        return Error_Param;
    }
    if(iRet != FR_RET_SUCC)
    {
        LogM("HSPSClassImpl::SetPreview(value=%d) = [%d] error,line=%d",nValue,iRet,__LINE__);
        return Error_DevMedia;
    }

    return Error_Succeed;
}


ErrorCodeEnum HSPSClassImpl::ScanImage(const char* pszFileName)
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::ScanImage(pszFileName=%s),line=%d",pszFileName,__LINE__);
    int iRet = -1;
    if(!m_bDevOpen)
    {
        SaveErrorInfo("ScanImage设备未打开，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImage() failed 设备未打开");
        return Error_DevNotAvailable;
    }
    if(!m_bPreview)
    {
        SaveErrorInfo("ScanImage设备不在预览状态",DEP_NO_E_HSPSCANNER_NOT_IN_PREVIEW, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImage() failed 设备不在预览状态");
        return Error_DevNotAvailable;
    }
    iRet = m_pDll->HIGH_TakePicture(pszFileName);

    //iRet = m_pDll->HIGH_CreateWindow(m_nX, m_nY, 0, m_nWidth*9/16);
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "ScanImage保存图片失败，HIGH_TakePicture(%s) =[%d] ",pszFileName,iRet);
        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::ScanImage(pszFileName=%s) = [%d] error,line=%d",pszFileName,iRet,__LINE__);
        return Error_DevMedia;
    }
    iRet = m_pDll->HIGH_HideWindow(TRUE);
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "ScanImage结束后，隐藏窗口失败，HIGH_HideWindow(TRUE) =[%d] ",iRet);
        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::ScanImage(pszFileName=%s) = [%d] error,line=%d",pszFileName,iRet,__LINE__);
        return Error_DevMedia;
    }
    m_bShow = 0;
    return Error_Succeed;
}


ErrorCodeEnum HSPSClassImpl::ScanImageEx(BYTE* pBtImg,  int& nBtLen, const char* pszFileName)
{
    LOG_FUNCTION();

    LogM("HSPSClassImpl::ScanImageEx(pBtImg, nBtLen=[%d], pszFileName=[%s])", nBtLen, pszFileName);

    int iRet = -1;
    if(!m_bDevOpen)
    {
        SaveErrorInfo("ScanImageEx设备未打开，打开预览失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备未打开");
        return Error_DevNotAvailable;
    }
    if(!m_bPreview)
    {
        SaveErrorInfo("ScanImageEx设备不在预览状态",DEP_NO_E_HSPSCANNER_NOT_IN_PREVIEW, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备不在预览状态");
        return Error_DevNotAvailable;
    }
    iRet = m_pDll->HIGH_TakePicture("tmp.jpg");
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "ScanImageEx保存临时图片失败，HIGH_TakePicture(tmp.jpg) =[%d] ",iRet);
        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::ScanImageEx HIGH_TakePicture = [%d] error,line=%d",iRet,__LINE__);
        return Error_DevMedia;
    }
    iRet = m_pDll->HIGH_HideWindow(TRUE);
    if(iRet != FR_RET_SUCC)
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "ScanImageEx结束后，隐藏窗口失败，HIGH_HideWindow(TRUE) =[%d] ",iRet);
        SaveErrorInfo(strMsg,ErrorCodeConvert(iRet), __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::ScanImageEx HIGH_HideWindow = [%d] error,line=%d",iRet,__LINE__);
        return Error_DevMedia;
    }
    m_bShow = 0;
    //读取tmp.jpg为字节流
    FILE *fp = NULL;
    char* pFileData = NULL;
    int file_size = 0;
    fp = fopen("tmp.jpg","rb");
    if(fp != NULL)
    {
        fseek(fp, 0, SEEK_END);
        file_size = ftell(fp);
        fseek(fp, 0, SEEK_SET);
        pFileData = new char[file_size+1];
        fread(pFileData, 1, file_size, fp);
        fclose(fp);
    }
    else {
        SaveErrorInfo("读取 tmp.jpg 失败",DEP_FILE_NOT_FOUND, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 读取 tmp.jpg 失败");
        return Error_NoTarget;
    }
    //memcpy(pBtImg, pFileData, file_size);
    pBtImg = (BYTE*)pFileData;
    nBtLen = file_size;

    if(nullptr != pszFileName && strlen(pszFileName) > 0)
    {
        string command = "cp ";
        command  += "tmp.jpg";
        command  += " ";
        command  += pszFileName;
        system((char*)command.c_str());
    }
    remove("tmp.jpg");

    if(nBtLen < file_size)
    {
        memcpy(pBtImg, pFileData, file_size);
        nBtLen = file_size;
        SaveErrorInfo("图片大小超限",DEP_LENGTH_LIMIT_EXCEEDED, __PRETTY_FUNCTION__, __LINE__);
        LogM("ScanImageEx()->nBtLen[%d] < file_size[%d]",nBtLen,file_size);
        return Error_TooSmallBuffer;
    }
    memcpy(pBtImg, pFileData, file_size);
    nBtLen = file_size;
    return Error_Succeed;
}


ErrorCodeEnum HSPSClassImpl::SetViewPos(int nX, int nY, int nWidth)
{
    LOG_FUNCTION();
	LogM("HSPSClassImpl::SetViewPos(nX=%d, nY=%d, nWidth=%d),line=%d",nX, nY, nWidth,__LINE__);

    int iRet = -1;
    if(!m_bDevOpen)
    {
        SaveErrorInfo("SetViewPos设备未打开，设置失败",DEP_DEV_CONNECT_FAILED, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->ScanImageEx() failed 设备未打开");
        return Error_DevNotAvailable;
    }
    if(nX >= 0 && nY >= 0 )
    {
        m_nX = nX;
        m_nY = nY;
        if(nWidth > 0)
        {
            m_nWidth = nWidth;

            if (m_nWidth*9/16 <= 1)
                m_nHeight = 1;
            else
            {
                m_nHeight  = m_nWidth*9/16;
            }
        }

    }
    else
    {
        CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
        sprintf(strMsg, "SetViewPos坐标参数有误，nX[%d] nY[%d]",nX,nY);
        SaveErrorInfo(strMsg,DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
        LogM("HSPSClassImpl::leave HSPS->SetViewPos() failed");
        return Error_Param;
    }


    //iRet = m_pDll->HIGH_PauseAndPlay(true);
    if(m_bPreview)
    {


            if(nWidth > 0)
            {
                LogM("HSPSClassImpl::SetViewPos(nWidth) = [%d] error,line=%d",nWidth,__LINE__);
                iRet = m_pDll->HIGH_CloseWindow();
                iRet = m_pDll->HIGH_CreateWindow(m_nX, m_nY, m_nWidth, m_nHeight);
            }
            else if( nWidth == 0)
            {
                LogM("HSPSClassImpl::SetViewPos(nWidth) = [%d] error,line=%d",nWidth,__LINE__);
                iRet = m_pDll->HIGH_CloseWindow();
                iRet = m_pDll->HIGH_CreateWindow(m_nX, m_nY, 1, 2);
            }

            else
            {

                CHAR strMsg[MAX_DEV_ERROR_MSG_LEN] = {0};
                sprintf(strMsg, "SetViewPos宽度参数有误，nWidth[%d]",nWidth);
                SaveErrorInfo(strMsg,DEP_INVALID_PARAMETER, __PRETTY_FUNCTION__, __LINE__);
                LogM("HSPSClassImpl::leave HSPS->SetViewPos() failed");
                return Error_Param;
            }
    }
    return Error_Succeed;
}



ErrorCodeEnum HSPSClassImpl::SetProperty()
{
    return Error_Succeed;
}


ErrorCodeEnum HSPSClassImpl::GetDevStatus(HspsDevStatus& status)
{
    LOG_FUNCTION();

    status.inPreview = (short)m_bPreview;
    status.inShow = (short)m_bShow;
    m_pDll->HIGH_GetStatus( &DevStatus);
    LogM("HSPSClassImpl::HIGH_GetStatus() = [%d] success!,line=%d",DevStatus,__LINE__);
    if(DevStatus == 1)
    {
        status.isConnected = 0;
    }
    else {
        status.isConnected = 1;
    }
    LogM("HSPSClassImpl::GetDevStatus success! inPreview = [%d] inShow = [%d]  isConnected = [isConnected]",status.inPreview,status.inShow,status.isConnected);
    return Error_Succeed;
}

void HSPSClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode, const CHAR* strFunc, int nLine)
{
    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    sprintf(m_szErrMsg, "{\"Errcode\":%d,\"Description\":%s}", errCode,chJson);
    LogM(m_szErrMsg);

    /*
    CHAR chJson[MAX_DEV_ERROR_MSG_LEN] = {0};
    QJsonObject root_Obj;
    QJsonDocument root_Doc;
    sprintf(chJson, "Func:%s,Line:%d,Msg:%s", strFunc, nLine, errMsg);
    root_Obj.insert("ErrCode", errCode);
    root_Obj.insert("Description", chJson);
    root_Doc.setObject(root_Obj);
    //QByteArray root_str = root_Doc.toJson(QJsonDocument::Compact);  //紧凑格式
    QByteArray root_str = root_Doc.toJson(QJsonDocument::Indented);   //标准JSON格式    QString strJson(root_str);
    QString strJson(root_str);
    //QByteArray ba = strJson.toLatin1();
    //char* sErrMsg = ba.data();
    //memset(m_szErrMsg, 0x00, sizeof(m_szErrMsg));
    //sprintf(m_szErrMsg, sErrMsg);
    //LogM(m_szErrMsg);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    sprintf(m_szErrMsg, strJson.toUtf8().data());
    LogM(m_szErrMsg);
    */
}
/*void HSPSClassImpl::SaveErrorInfo(CHAR* errMsg, int errCode)
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS SaveErrorInfo(CHAR* errMsg, int errCode)! <=> errMsg = %s errCode = %d",errMsg,errCode);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    snprintf(m_szErrMsg, sizeof (m_szErrMsg),"%s[%d]", errMsg, errCode);
    LogM("HSPSClassImpl::Leave->HSPS DevOpen()->m_pDll->SaveErrorInfo(CHAR* errMsg, int errCode) sucessfull!");
}

void HSPSClassImpl::SaveErrorInfo(DevErrorInfo devErrorInfo)
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS SaveErrorInfo(DevErrorInfo devErrorInfo)! <=> devErrorInfo.szErrMsg = %s",devErrorInfo.szErrMsg);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%s",devErrorInfo.szErrMsg);
    LogM("HSPSClassImpl::Leave->HSPS DevOpen()->m_pDll->SaveErrorInfo(DevErrorInfo devErrorInfo) sucessfull!");
}
void HSPSClassImpl::SaveErrorInfo(int nErrorCode)
{
    LOG_FUNCTION();
    LogM("HSPSClassImpl::Entry->HSPS SaveErrorInfo(int nErrorCode)! <=> nErrorCode = %d",nErrorCode);
    ErrorCodeEnum ret;
    switch (nErrorCode)
    {
    case FR_RET_SUCC:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_SUCC, "成功");
        m_shErrCode = DEC_SUCCESS;
        ret = Error_Succeed;
        break;
    case FR_RET_FAIL:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_FAIL, "失败");
        m_shErrCode = DEC_EXCEPTION;
        ret = Error_Param;
        break;
    case FR_RET_PARA:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_PARA, "参数错误");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FR_RET_NDEV:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_NDEV, "打开设备失败");
        m_shErrCode = DEC_DEV_NOT_FOUND;
        ret = Error_Param;
        break;
    case FR_RET_NINI:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FR_RET_NINI, "未打开设备");
        m_shErrCode = DEC_DEV_NOT_OPENED;
        ret = Error_DevConnFailed;
        break;
    case FR_RET_BUSY:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_BUSY, "设备繁忙");
        m_shErrCode = DEC_DEV_NOT_OPENED;
        ret = Error_NotInit;
        break;
    case FR_RET_DATA:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_DATA, "图像数据不正确");
        m_shErrCode = DEC_INVALID_PARAMETER;
        ret = Error_Param;
        break;
    case FR_RET_NLNK:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_NLNK, "设备断开");
        m_shErrCode = DEC_DEV_NOT_OPENED;
        ret = Error_Param;
        break;
    case FR_RET_NMEM:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",FR_RET_NMEM, "内存分配失败");
        m_shErrCode = DEC_NULL_POINTER;
        ret = Error_Param;
        break;
    case FR_RET_ARDY:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg,sizeof(m_szErrMsg), "%d:%s",FR_RET_ARDY, "已经打开设备");
        m_shErrCode = DEC_RESET_FAILED;
        ret = Error_Param;
        break;
    default:
        memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
        snprintf(m_szErrMsg, sizeof(m_szErrMsg),"%d:%s",nErrorCode, "其它未定义的错误");
        m_shErrCode = DEC_ERROR_CODE_UNRECOGNIZABLE;
        ret = Error_Param;
        break;
    }
    LogM("HSPSClassImpl::Leave->HSPS DevOpen()->m_pDll->SaveErrorInfo(int nErrorCode) sucessfull!");
}*/