myvtm/DevAdapter/keba/ContactlessCard.keba.1.1/rficclassimpl_crt603cz7.cpp

#include "rficclassimpl_crt603cz7.h"
#include "CkLog.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);
   }
}

RFICClassImpl::RFICClassImpl():
        m_bDevOpen(FALSE)
        ,m_pDll(nullptr)
{
    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;
    SaveErrorInfo("RFICClassImpl 成功", DEP_SUCCESS, __FUNCTION__ , __LINE__);
    //--------------------------------------------------------------------
}
RFICClassImpl::~RFICClassImpl()
{
    LOG_FUNCTION();
    DevClose();
    if(m_pDll != nullptr)
    {
        delete m_pDll;
    }
    m_bDevOpen = false;
}
int getFileVer(char* sFile, short &ch1, short &ch2)
{
        ch1 = 0;
        ch2 = 0;
        char* pFind = strstr(sFile, ".so");
        char* pTemp = pFind;
        while(pTemp)
        {
            pFind = pTemp;
            pTemp = strstr(pFind + 3, ".so");
        }
        if(pFind == nullptr) return 0;

        pTemp = pFind - 1;
        while(isdigit(*pTemp) && pTemp > sFile) pTemp--;
        if(*pTemp == '.')
            ch2 = atoi(pTemp + 1);

        pTemp--;
        while(isdigit(*pTemp) && pTemp > sFile) pTemp--;

        if(*pTemp == '.')
            ch1 = atoi(pTemp + 1);

        return 1;
}
ErrorCodeEnum RFICClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG_FUNCTION();
    LogM("RFICClassImpl::Entry->ContactlessCard GetDevCategory()!");
    memset(devCategory.szType, 0, MAX_DEV_TYPE_LEN);
    memset(devCategory.szModel, 0, MAX_DEV_MODEL_LEN);
    memset(devCategory.szVendor, 0, MAX_DEV_VENDOR_LEN);

    memcpy(devCategory.szType, "Keba.RFIC.CRT603CZ7-V1.00.01", strlen("Keba.RFIC.CRT603CZ7-V1.00.01"));
    memcpy(devCategory.szVendor, "keba", strlen("keba"));
    char sPath[256], sFile[128] = {0};
    GetCurModulePath(sPath, sFile);
    short v1,v2;
    getFileVer(sFile, v1, v2);

    devCategory.version.wMajor = v1;
    devCategory.version.wMinor = v2;

    devCategory.version.wRevision = 0xffff;
    devCategory.version.wBuild = FILE_VERSION;

    LogM("devCategory.szType = %s",devCategory.szType);
    LogM("devCategory.szVendor = %s",devCategory.szVendor);
    LogM("RFICClassImpl::Leave->ContactlessCard GetDevCategory() sucessfull!");
    return Error_Succeed;
}
//	Reset device.
//	Do the cleaning work and initialize device again in order to return to
//	the normal condition.
ErrorCodeEnum RFICClassImpl::Reset()
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard Reset()!");
    int nRet = CRT_SUCCESS;
    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }
     nRet = m_pDll->CrtReset();
     if (nRet != CRT_SUCCESS)
     {
         sprintf(szErrorMsg, "复位失败");
         SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
         return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
     }
     LogM("RFICClassImpl::Leave->ContactlessCard Reset() sucessfull!");
    return Error_Succeed;
}
//
//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum RFICClassImpl::DevClose()
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard DevClose()!");
    int nRet = CRT_SUCCESS;
    nRet = m_pDll->CrtDevCLose();
    if (nRet != CRT_SUCCESS)
    {
        sprintf(szErrorMsg, "关闭智能读卡器失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CONNECT, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));

    }
    m_bDevOpen = false;
    LogM("RFICClassImpl::Leave->ContactlessCard DevClose() sucessfull!");
    return Error_Succeed;
}
//	Get last error the device issued.
//	Error message must include explanatory memorandum ,the original error
//	code and anything in favour of location problem.
ErrorCodeEnum RFICClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    LOG_FUNCTION();
    LogM("RFICClassImpl::Entry->ContactlessCard 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("RFICClassImpl::Leave->ContactlessCard GetLastErr() sucessfull!");
    return Error_Succeed;
}
//device initialization
ErrorCodeEnum RFICClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard DevOpen()!");
    int nRet = CRT_SUCCESS;
    CHAR strDllPath[256] = {0};
    char sDevInfo[64+1] = {0};
    char sID[1024] = {0};
    const char * tmpStr = "libCRT_603_CZ7.keba.so";
    strncat(strDllPath, "libCRT_603_CZ7.keba.so",strlen(tmpStr));
    m_pDll = new CDevDllLoad(strDllPath);
    if (nullptr == m_pDll)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() new object CDevDllLoad failed!");
        sprintf(szErrorMsg, "加载依赖的DLL失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_LOADDLL, __FUNCTION__, __LINE__);
        return Error_DevNotAvailable;
    }
    nRet = m_pDll->CrtDevOpen();
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() failed! <=> iRet = %d",nRet);
        if (nRet == CRT_ERR_LOADDLL)
        {
            sprintf(szErrorMsg, "加载依赖的DLL失败");
            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_LOADDLL, __FUNCTION__, __LINE__);
        }
        else
        {
            switch(nRet)
            {
            case CRT_ERR_SET_READERTYPE:
                sprintf(szErrorMsg, "设置读卡器类型失败");
                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
                break;
            case CRT_ERR_SET_READERNAME:
                sprintf(szErrorMsg, "设置读卡器名称失败");
                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
                break;
            case CRT_ERR_CONNECT:
                sprintf(szErrorMsg, "模块链接设备失败");
                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CONNECT, __FUNCTION__, __LINE__);
                break;
            default:
                break;
            }
        }
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    LogM("RFICClassImpl::Entry->ContactlessCard DevOpen() success! <=> iRet = %d",nRet);
    nRet = m_pDll->CrtInitSet();
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtInitSet() failed! <=> iRet = %d",nRet);
        switch(nRet)
        {
        case CRT_ERR_SET_CONTRAL_CMD:
            sprintf(szErrorMsg, "控制命令错");
            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_CONTRAL_CMD, __FUNCTION__, __LINE__);
            break;
        case CRT_ERR_SET_TYPE_CAP:
            sprintf(szErrorMsg, "设置读卡器能读取TYPE B卡能力失败");
            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_SET_TYPE_CAP, __FUNCTION__, __LINE__);
            break;
        default:
            break;
        }
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    LogM("RFICClassImpl::Entry->ContactlessCard CrtInitSet() success! <=> iRet = %d",nRet);
    m_bDevOpen = TRUE;
    LogM("RFICClassImpl::Leave->ContactlessCard DevOpen() sucessfull!");
    return Error_Succeed;
}

//
//	Get card reader status
//
ErrorCodeEnum RFICClassImpl::GetDevStatus(RFICReaderStatus &devStatus)
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard GetDevStatus()!");
    int nRet = CRT_SUCCESS;
    int nType = CRT_CARD_TYPE_UNKNOWN;
    BOOL bFind = FALSE;

    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }

    nRet = m_pDll->CrtFindCard(&bFind);
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtFindCard() failed! <=> iRet = %d",nRet);
        sprintf(szErrorMsg, "获取卡状态失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_SATUTS, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    LogM("RFICClassImpl::Entry->ContactlessCard CrtFindCard() success! <=> iRet = %d",nRet);
    if (bFind == TRUE)
        {
            devStatus.eMediaPos = CI_MEDIA_PRESENT;
            nRet = m_pDll->CrtGetCardType(&nType);
            if (nRet != CRT_SUCCESS)
            {
                LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() failed! <=> iRet = %d",nRet);
                sprintf(szErrorMsg, "获取卡类型失败");
                SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_CARD_TYPE, __FUNCTION__, __LINE__);
                return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
            }
            LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %d",nType);
            if (nType == CRT_CARD_TYPE_TYPEA || nType == CRT_CARD_TYPE_TYPEB)
            {
                devStatus.eMediaPos = CI_MEDIA_RF;
            }
            else if (nType == CRT_CARD_TYPE_IDCARD)
            {
                devStatus.eMediaPos = CI_MEDIA_IDCARD;
            }
            else if (nType == CRT_CARD_TYPE_NOCARD)
            {
                devStatus.eMediaPos = CI_MEDIA_NOTPRESENT;
            }
        }
        else
        {
            devStatus.eMediaPos = CI_MEDIA_NOTPRESENT;
        }
    LogM("RFICClassImpl::Entry->ContactlessCard GetDevStatus() success! <=> devStatus.eMediaPos = %d",devStatus.eMediaPos);
    LogM("RFICClassImpl::Leave->ContactlessCard GetDevStatus() sucessfull!");
    return Error_Succeed;
}
//
//	Abort current operation.
//
ErrorCodeEnum RFICClassImpl::AbortRead()
{
    LOG_FUNCTION();
    LogM("RFICClassImpl::Entry->ContactlessCard AbortRead()!");
    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }
    LogM("RFICClassImpl::Leave->ContactlessCard AbortRead() sucessfull!");
    return Error_Succeed;
}
//
//	Active contactless card(Type A,B,Mifare)
//	The first,second,third activation order decided by fstType,scdType,thdType respectively
//	fstType,scdType,thdType can be one of 'A','B','M','0'(30H,no type)
//	outType indicates the type of  activation result
//
ErrorCodeEnum RFICClassImpl::ActiveContactlessICCard(char fstType,char scdType,char thdType,char &outType)
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard ActiveContactlessICCard()!");
    int nRet = CRT_SUCCESS;
    int nType = CRT_CARD_TYPE_UNKNOWN;
    WORD wTime = 0;
    char szGetUID[16] = {0x00};
    CRT_ART_Info crtGetATR = {0x00};

    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }

    do
    {
        nRet = m_pDll->CrtGetCardType(&nType);
        if (nRet == CRT_SUCCESS)
        {
            LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %d",nType);
            if (nType == CRT_CARD_TYPE_TYPEA)
            {
                outType = 'A';
                break;
            }
            else if (nType == CRT_CARD_TYPE_TYPEB)
            {
                outType = 'B';
                break;
            }
            else
            {
                wTime++;
                LogM("Do CrtGetCardType() success! <=> nType = %c",nType);
                //return Error_NotImpl;
            }
        }
        else
        {
            wTime++;
        }
        usleep(100*1000);
        if (wTime > 5)
        {
            LogM("Do CrtGetCardType() Break!");
            break;
        }
    } while ((nRet != CRT_SUCCESS) || ((nType != CRT_CARD_TYPE_TYPEA) && (nType != CRT_CARD_TYPE_TYPEB)));

    if (nType == 0 || nType > 2)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %c",nType);
        return Error_NotImpl;
    }

    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() failed! <=> iRet = %d",nRet);
        sprintf(szErrorMsg, "获取卡类型失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_GET_CARD_TYPE, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }

    LogM("RFICClassImpl::Entry->ContactlessCard CrtGetCardType() success! <=> nType = %c",outType);
    nRet = m_pDll->CrtActiveCard(&crtGetATR);
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtActiveCard() failed! <=> nRet = %d",nRet);
        sprintf(szErrorMsg, "无卡或不支持的卡片");
        SaveErrorInfo(szErrorMsg, DEP_PROTOCOL_UNSUPPORTED, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    m_EjectCard = false;
    LogM("RFICClassImpl::Entry->ContactlessCard CrtActiveCard() success! <=> nRet = %d",nRet);
    LogM("RFICClassImpl::Entry->ContactlessCard CrtActiveCard() <=> crtGetATR = %x",crtGetATR.byATR);
    LogM("RFICClassImpl::Leave->ContactlessCard ActiveContactlessICCard() sucessfull!");
    return Error_Succeed;
}
//
//	Deactivate contactless IC card
//
ErrorCodeEnum RFICClassImpl::DeactContactlessICCard()
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard DeactContactlessICCard()!");
    int nRet = CRT_SUCCESS;
    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }

    nRet = m_pDll->CrtDeActive();
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtDeActive() failed! <=> iRet = %d",nRet);
        sprintf(szErrorMsg, "弹卡下电失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    m_EjectCard = true;
    LogM("RFICClassImpl::Entry->ContactlessCard CrtDeActive() success! <=> iRet = %d",nRet);
    LogM("RFICClassImpl::Leave->ContactlessCard DeactContactlessICCard() sucessfull!");
    return Error_Succeed;
}
//
//	Warm reset card(IC)
//
ErrorCodeEnum RFICClassImpl::WarmReset()
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard WarmReset()!");
    int nRet = CRT_SUCCESS;
    if (m_bDevOpen == FALSE)
    {
        return Error_NotInit;
    }

    nRet = m_pDll->CrtWarmReset();
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtWarmReset() failed! <=> iRet = %d",nRet);
        sprintf(szErrorMsg, "热复位失败");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    LogM("RFICClassImpl::Entry->ContactlessCard CrtWarmReset() success! <=> iRet = %d",nRet);
    LogM("RFICClassImpl::Leave->ContactlessCard WarmReset() sucessfull!");
    return Error_Succeed;
}
//
//	Mifare operation
//	Arguments:
//	- eFunType:function type as load key,authentication and so on
//	- return/data(hex) byte order like BIG EDIAN. ex:0x12345678 --> data[i] = 0x12,data[i+1] = 0x34,data[i+2] = 0x56,data[i+3] = 0x78
//	- sendBuf:[parameter(hex)][data(hex)]
//	- recvBuf:[status(1byte)][return data(hex)]
//		-- [eFunType],[parameter,data],[status(1byte),return data]
//		-- [CI_MIFARE_LOAD_KEY],[key select(1byte),sector num(1byte),uncoded keys(6bytes)],[status(1byte)]
//		-- [CI_MIFARE_AUTH],[key select(1byte),sector num(1byte)],[status(1byte)]
//		-- [CI_MIFARE_READ],[block num(1byte)],[status(1byte),data(16bytes)]
//		-- [CI_MIFARE_WRITE],[block num(1byte),data(16bytes)],[status(1byte)]
//		-- [CI_MIFARE_INC],[source block num(1byte),destination block num(1byte),inc value(4bytes)],[status(1byte)]
//		-- [CI_MIFARE_DEC],[source block num(1byte),destination block num(1byte),dec value(4bytes)],[status(1byte)]
//		-- key select(1byte):AKey(00h),BKey(01h)
//		-- status(1byte):OK(00h),other error code(!00h)
ErrorCodeEnum RFICClassImpl::MifareCommand(MifareFuctionEnum eFunType,CmdInfo sendBuf,CmdInfo &recvBuf)
{
    LOG_FUNCTION();
    LogM("RFICClassImpl::Entry->ContactlessCard MifareCommand()!");
    LogM("RFICClassImpl::Leave->ContactlessCard MifareCommand() sucessfull!");
    return Error_Succeed;
}
//
//	RF Type A,B command.
//	APDU:Application Protocol Data Unit
//	Arguments:
// 	- CmdSend.lpCmd:Command-APDU
// 	- CmdRecv.lpData:Response-APDU
//
ErrorCodeEnum RFICClassImpl::RFTypeABCommand(CmdInfo sendBuf,CmdInfo &recvBuf)
{
    LOG_FUNCTION();
    char szErrorMsg[256] = {0};
    LogM("RFICClassImpl::Entry->ContactlessCard RFTypeABCommand()!");
    int nRet = CRT_SUCCESS;
    if(m_EjectCard == true)
    {
        sprintf(szErrorMsg, "IC卡已下电");
        SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPPOWER, __FUNCTION__, __LINE__);
        return Error_Param;
    }
    CRT_Chip_Info sendChip = {0x00};
    CRT_Chip_Info recvChip = {0x00};

    if (sendBuf.data == NULL || sendBuf.dwSize == 0)
    {
        return Error_Param;
    }

    sendChip.nLen = sendBuf.dwSize;
    memcpy(sendChip.byData, sendBuf.data, sendBuf.dwSize);
    LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() <=> sendChip.byData = %x",sendChip.byData);
    nRet = m_pDll->CrtChipIO(sendChip, &recvChip);
    if (nRet != CRT_SUCCESS)
    {
        LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() failed! <=> iRet = %d",nRet);
        switch(nRet)
        {
        case CRT_ERR_PARAM:
            sprintf(szErrorMsg, "参数错");
            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_PARAM, __FUNCTION__, __LINE__);
            break;
        case CRT_ERR_CHIPIO:
            sprintf(szErrorMsg, "CHIPIO失败");
            SaveErrorInfo(szErrorMsg, DEP_NO_E_ContactlessCard_CHIPIO, __FUNCTION__, __LINE__);
            break;
        default:
            break;
        }
        return ErrorCodeToCMB(m_pDll->CrtGetErrorType(nRet));
    }
    LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() success! <=> iRet = %d",nRet);
    if (recvChip.nLen > 0)
    {
        recvBuf.dwSize = recvChip.nLen;
        memcpy(recvBuf.data, recvChip.byData, recvChip.nLen);
        LogM("RFICClassImpl::Entry->ContactlessCard CrtChipIO() <=> recvBuf.data = %x",recvBuf.data);
    }

    return Error_Succeed;
}
//halt card
//card have been halted must move from induction zone then can be found again
ErrorCodeEnum RFICClassImpl::HaltCard()
{
    return Error_Succeed;
}

//Private
void RFICClassImpl::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);
    memset(m_szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    sprintf(m_szErrMsg, strJson.toUtf8().data());
    LogM(m_szErrMsg);
    */
}
ErrorCodeEnum RFICClassImpl::ErrorCodeToCMB(int nRes)
{
    ErrorCodeEnum eRet = Error_NotImpl;

    switch(nRes)
    {
    case CRT_SUCCESS:
        eRet = Error_Succeed;
        m_shErrCode = DEP_SUCCESS;
        break;
    case CRT_ERR_TYPE_CONNECT:
        eRet = Error_DevNotAvailable;
        m_shErrCode = DEP_DEV_CONNECT_FAILED;
        break;
    case CRT_ERR_TYPE_HWERROR:
        eRet = Error_Hardware;
        m_shErrCode = DEP_HARDWARE;
        break;
    case CRT_ERR_TYPE_MEDIA:
        eRet = Error_NotImpl;
        m_shErrCode = DEP_EXCEPTION;
        break;
    case CRT_ERR_TYPE_MIFARE:
        eRet = Error_NotImpl;
        m_shErrCode = DEP_EXCEPTION;
        break;
    case CRT_ERR_TYPE_PARAM:
        eRet = Error_Param;
        m_shErrCode = DEP_INVALID_PARAMETER;
        break;
    default:
        break;
    }

    return eRet;
}
int RFICClassImpl::GetDllPathLocal(std::string &dllPath)
{
   char szBuff[MAX_PATH];
   char * pathRtn = getcwd(szBuff,sizeof (szBuff));
   if(pathRtn == nullptr)
   {
       dllPath = "";
       return Error_Null;
   }
   dllPath = szBuff;
   dllPath+="/";
   return Error_Succeed;
}