myvtm/DevAdapter/cw/idcer.1.1/idcertimpl.cpp

#include "idcertimpl.h"
#include "log4vendor.h"
#include "idcertimpl.h"

IDCertImpl::IDCertImpl()
{
    m_id81Dev = new IDCertConn();
    memset(m_DevErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    strcat(m_DevErrInfo.szErrMsg, "成功");
    m_DevErrInfo.dwErrMsgLen = strlen(m_DevErrInfo.szErrMsg);
    m_bOpen = FALSE;
    m_iCardType = -1;   //证件类型
    m_sLibPath[0] = 0;
    m_bReInsert = false;
}

void IDCertImpl::DeleteBmp()
{
    if (m_sLibPath[0])
    {
        char sFile[300];
        sprintf(sFile, "%s/idfront.bmp", m_sLibPath);
        remove(sFile);
        sprintf(sFile, "%s/idback.bmp", m_sLibPath);
        remove(sFile);
        sprintf(sFile, "%s/zp.bmp", m_sLibPath);
        remove(sFile);
    }
}

IDCertImpl::~IDCertImpl()
{
    if(m_id81Dev)
    {
        delete m_id81Dev;
        m_id81Dev = NULL;
        DeleteBmp();
    }
    m_bOpen= 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 == NULL) 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 IDCertImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
    memset(&devCategory, 0, sizeof(devCategory));
    strcpy(devCategory.szModel , "FWID=snbcid81#STYLE=IG#FUNCTION=ITF");
    strcpy(devCategory.szVendor , "cw");

    char sPath[256], sFile[128] = {0};
    GetCurLibsPath(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;
    char szVer[200] = {0};
//    SAutoLock lock(&m_MutexLock);
    Sleep(800);
    int iRt = m_id81Dev->getFWVersion(szVer);       //"Main Firmware:FV1.001.05
    if (Error_Succeed == iRt)
    {
        LOG4VTM(INFO, "GetDevCategory getFWVersion ok");
        strcpy(devCategory.szType ,szVer);
        devCategory.eState = DEVICE_STATUS_NORMAL;
    }
    else
    {
        LOG4VTM(INFO, "GetDevCategory getFWVersion error");
        strcpy(devCategory.szType ,"ID81 get Firmware error");
        devCategory.eState = DEVICE_STATUS_CONNECTING;
    }
    return Error_Succeed;
}

//	Reset device.
ErrorCodeEnum IDCertImpl::Reset()
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
//    SAutoLock lock(&m_MutexLock);
    CancelWaitMediaInsert();
    int iRt = Error_Succeed;
    iRt = m_id81Dev->Reset(2);
    return HandleDevError(iRt, __FUNCTION__);
}
//
//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum IDCertImpl::DevClose()
{  
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
//    SAutoLock lock(&m_MutexLock);
    CancelWaitMediaInsert();
    int iRt = Error_Succeed;
    Sleep(300);
    iRt = m_id81Dev->closeDevice();
    m_bOpen = FALSE;
    if(iRt == CWERR_IDCARD_SUCCESS)
        return Error_Succeed;
    return Error_Succeed;
}

ErrorCodeEnum IDCertImpl::DevOpen(DWORD dwPort)
{
    LOG4VTM_FUNCTION();
//    SAutoLock lock(&m_MutexLock);
    int iRt = Error_Succeed;
    m_bOpen = FALSE;

    GetCurLibsPath(m_sLibPath, NULL);
    char cFilePath[300] = {0};
    sprintf(cFilePath, "DevOpen GetCurProcPath = %s", m_sLibPath);
    LOG4VTM(INFO, cFilePath);
    sprintf(cFilePath, "%s/cw/libID81M.cw.so", m_sLibPath); //usr symbolic link to point the real so

    iRt = m_id81Dev->openDevice(cFilePath);
    if(iRt == CWERR_IDCARD_SUCCESS)
    {
        m_id81Dev->setAutoFeedEnable(0);
        m_bOpen = TRUE;
    }
    return HandleDevError(iRt, __FUNCTION__);
}

//    吞入式身份证读卡器的适配器，
//    1.检测到有卡片插入，但不是身份证时，IDCerAuthenticate返回Error_DevMedia；
//    2.未检测到卡片插入，IDCerAuthenticate返回Error_Unexpect；
//    3.检测到身份证且认证成功（注意：部分厂商不做卡认证直接返回成功，需要根据实际情况按照步骤1和2返回对应值），IDCerAuthenticate返回Error_Succeed。
ErrorCodeEnum IDCertImpl:: IDCerAuthenticate()
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
//    SAutoLock lock(&m_MutexLock);
    int nCardST = 0, iRt = Error_Succeed;
    ErrorCodeEnum eRt = Error_Unexpect;
    m_iCardType = -1;
    iRt = m_id81Dev->GetStatus(nCardST);
    if(CWERR_IDCARD_SUCCESS == iRt)
    {
        switch(nCardST)
        {
        case CWINF_IDCARD_NOCARD:     //无卡
            eRt =  Error_Unexpect;
            break;
        case CWINF_IDCARD_CARDMIDDLE: //在读卡位
            iRt = m_id81Dev->getIDCardType(&m_iCardType);
            if(Error_Succeed == iRt)
            {
                if(0 == m_iCardType || 1 == m_iCardType || 2 == m_iCardType) //0:二代证 1：外国人 2：港澳居住证
                {
                    eRt = Error_Succeed;
                }
            }
            else
            {
                eRt =  Error_DevMedia;
            }
            break;
        default:
            eRt =  Error_Unexpect;
            break;
        }
    }
    return eRt;
}

//dep目录说明：应用在上层目录，动态库在dep目录，生成的临时文件也在dep目录
//当前目录和进程所在目录为上层目录，动态库和临时文件目录为dep子目录
ErrorCodeEnum IDCertImpl::IDCerGetData(IDCerInfo &idCerInfo)
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
    memset(&idCerInfo,0,sizeof(IDCerInfo));

    int iRt = Error_Succeed;
    char strName[256]={0};
    char strNameENG[256]={0};
    char strSex[256]={0};
    char strNation[256]={0};
    char strBirthday[256]={0};
    char strAddress[256]={0};
    char strNumber[256]={0};
    char strDepartment[256]={0};
    char strTimeLimitStart[256]={0};
    char strTimeLimitEnd[256]={0};
    char strVersion[256]={0};
    char strTXZCode[256]={0};
    char strIssuedSN[256]={0};
    char strReserveItem[256]={0};
    char strHeadPath[256] = {0};

    sprintf(strHeadPath, 	"%s/zp.bmp", m_sLibPath);
    remove(strHeadPath);
//    iRt = m_id81Dev->GetStatus(nCardST);
//    if((CWERR_IDCARD_INIT == iRt) || (CWERR_IDCARD_PORT_ERROR == iRt))
//    {
//        //LOG4VTM(INFO, "GetStatus failed!");
//        return HandleDevError(iRt,"GetStatus-nCardST = %d",nCardST);
//    }
//    SAutoLock lock(&m_MutexLock);
    iRt = m_id81Dev->GetID2InfoAll(strHeadPath, strName, strNameENG,
                                  strSex, strNation, strBirthday,
                                  strAddress, strNumber, strDepartment,
                                  strTimeLimitStart, strTimeLimitEnd, strVersion,
                                  strTXZCode, strReserveItem, strIssuedSN,
                                  m_iCardType);

    if(iRt != 0)
        return HandleDevError(iRt, __FUNCTION__);

    if (CWERR_IDCARD_SUCCESS == iRt)
    {
        char WZBuffer[64] = {0};
        char strTmp[30] = {0};
        //姓名
        memcpy(idCerInfo.name.data,strName,strlen(strName));
        idCerInfo.name.dwSize = strlen(strName);
        //性别
        memcpy(idCerInfo.sex.data,strSex,strlen(strSex));
        idCerInfo.sex.dwSize = strlen(strSex);
        //民族
        memcpy(idCerInfo.nation.data,strNation,strlen(strNation));
        idCerInfo.nation.dwSize = strlen(strNation);
        //出生日期
        memset(WZBuffer, 0, 64);
        memset(strTmp, 0, 30);
        memcpy(WZBuffer,strBirthday,8);
        memcpy(idCerInfo.birthday.data,&WZBuffer[0],4);
        strcat(idCerInfo.birthday.data,"年");
        memcpy(strTmp,&WZBuffer[4],2);
        strcat(idCerInfo.birthday.data,strTmp);
        strcat(idCerInfo.birthday.data,"月");
        memcpy(strTmp,&WZBuffer[6],2);
        strcat(idCerInfo.birthday.data,strTmp);
        strcat(idCerInfo.birthday.data,"日");
        idCerInfo.birthday.dwSize = 14;
        //地址
        memcpy(idCerInfo.address.data,strAddress,strlen(strAddress));
        idCerInfo.address.dwSize = strlen(strAddress);
        //身份证号码
        memcpy(idCerInfo.idno.data,strNumber,strlen(strNumber));
        idCerInfo.idno.dwSize = strlen(strNumber);
        //发证机关
        memcpy(idCerInfo.department.data,strDepartment,strlen(strDepartment));
        idCerInfo.department.dwSize = strlen(strDepartment);
        //有效期始
        memset(WZBuffer, 0, 64);
        memset(strTmp, 0, 30);
        memcpy(WZBuffer,strTimeLimitStart,8);
        memcpy(idCerInfo.startDate.data,&WZBuffer[0],4);
        strcat(idCerInfo.startDate.data,".");
        memcpy(strTmp,&WZBuffer[4],2);
        strcat(idCerInfo.startDate.data,strTmp);
        strcat(idCerInfo.startDate.data,".");
        memcpy(strTmp,&WZBuffer[6],2);
        strcat(idCerInfo.startDate.data,strTmp);
        idCerInfo.startDate.dwSize = 10;
        //有效期止
        if(strlen(strTimeLimitEnd)<8) //长期身份证
        {
            memcpy(idCerInfo.endDate.data,&strTimeLimitEnd[0],6);
            idCerInfo.endDate.dwSize = 6;
        }
        else
        {
            memset(WZBuffer, 0, 64);
            memset(strTmp, 0, 30);
            memcpy(WZBuffer,strTimeLimitEnd,8);
            memcpy(idCerInfo.endDate.data,&WZBuffer[0],4);
            strcat(idCerInfo.endDate.data,".");
            memcpy(strTmp,&WZBuffer[4],2);
            strcat(idCerInfo.endDate.data,strTmp);
            strcat(idCerInfo.endDate.data,".");
            memcpy(strTmp,&WZBuffer[6],2);
            strcat(idCerInfo.endDate.data,strTmp);
            idCerInfo.endDate.dwSize = 10;
        }
        //set result
        memcmp(idCerInfo.photoPath.data, strHeadPath, strlen(strHeadPath));
        idCerInfo.photoPath.dwSize = strlen(idCerInfo.photoPath.data);
    }
    return Error_Succeed;
}

//dep目录说明：应用在上层目录，动态库在dep目录，生成的临时文件也在dep目录
//当前目录和进程所在目录为上层目录，动态库和临时文件目录为dep子目录
ErrorCodeEnum IDCertImpl::IDCerGetDataEx(IDCerInfoEx &idCerInfoEx)
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
    memset(&idCerInfoEx,0,sizeof(IDCerInfoEx));

    int iRt = Error_Succeed;
    char strName[256]={0};
    char strNameENG[256]={0};
    char strSex[256]={0};
    char strNation[256]={0};
    char strBirthday[256]={0};
    char strAddress[256]={0};
    char strNumber[256]={0};
    char strDepartment[256]={0};
    char strTimeLimitStart[256]={0};
    char strTimeLimitEnd[256]={0};
    char strVersion[256]={0};
    char strTXZCode[256]={0};
    char strIssuedSN[256]={0};
    char strReserveItem[256]={0};
    char strHeadPath[256] = {0};

    sprintf(strHeadPath, 	"%s/zp.bmp", m_sLibPath);

//    iRt = m_id81Dev->GetStatus(nCardST);
//    if((CWERR_IDCARD_INIT == iRt) || (CWERR_IDCARD_PORT_ERROR == iRt))
//    {
//        //LOG4VTM(INFO, "GetStatus failed!");
//        return HandleDevError(iRt,"GetStatus-nCardST = %d",nCardST);
//    }
//    SAutoLock lock(&m_MutexLock);
    iRt = m_id81Dev->GetID2InfoAll(strHeadPath, strName, strNameENG,
                                   strSex, strNation, strBirthday,
                                   strAddress, strNumber, strDepartment,
                                   strTimeLimitStart, strTimeLimitEnd, strVersion,
                                   strTXZCode, strReserveItem, strIssuedSN,
                                   m_iCardType);

    if(iRt != 0)
        return HandleDevError(iRt, __FUNCTION__);

    char WZBuffer[64] = {0};
    char strTmp[30] = {0};
    sprintf(strTmp, "GetID2InfoAll type=%d",m_iCardType);
    LOG4VTM(INFO, strTmp);

    //姓名
    memcpy(idCerInfoEx.name.data,strName,strlen(strName));
    idCerInfoEx.name.dwSize = strlen(strName);
    //性别
    memcpy(idCerInfoEx.sex.data,strSex,strlen(strSex));
    idCerInfoEx.sex.dwSize = strlen(strSex);
    //出生日期
    memset(WZBuffer, 0, 64);
    memset(strTmp, 0, 30);
    memcpy(WZBuffer,strBirthday,8);
    memcpy(idCerInfoEx.birthday.data,&WZBuffer[0],4);
    strcat(idCerInfoEx.birthday.data,"年");
    memcpy(strTmp,&WZBuffer[4],2);
    strcat(idCerInfoEx.birthday.data,strTmp);
    strcat(idCerInfoEx.birthday.data,"月");
    memcpy(strTmp,&WZBuffer[6],2);
    strcat(idCerInfoEx.birthday.data,strTmp);
    strcat(idCerInfoEx.birthday.data,"日");
    idCerInfoEx.birthday.dwSize = 14;
    //身份证号码
    memcpy(idCerInfoEx.idno.data,strNumber,strlen(strNumber));
    idCerInfoEx.idno.dwSize = strlen(strNumber);
    //发证机关
    memcpy(idCerInfoEx.department.data,strDepartment,strlen(strDepartment));
    idCerInfoEx.department.dwSize = strlen(strDepartment);
    //有效期始
    memset(WZBuffer, 0, 64);
    memset(strTmp, 0, 30);
    memcpy(WZBuffer,strTimeLimitStart,8);
    memcpy(idCerInfoEx.startDate.data,&WZBuffer[0],4);
    strcat(idCerInfoEx.startDate.data,".");
    memcpy(strTmp,&WZBuffer[4],2);
    strcat(idCerInfoEx.startDate.data,strTmp);
    strcat(idCerInfoEx.startDate.data,".");
    memcpy(strTmp,&WZBuffer[6],2);
    strcat(idCerInfoEx.startDate.data,strTmp);
    idCerInfoEx.startDate.dwSize = 10;
    //有效期止
    if(strlen(strTimeLimitEnd)<8) //长期身份证
    {
        memcpy(idCerInfoEx.endDate.data,&strTimeLimitEnd[0],8);
        idCerInfoEx.endDate.dwSize = strlen(strTimeLimitEnd);
    }
    else
    {
        memset(WZBuffer, 0, 64);
        memset(strTmp, 0, 30);
        memcpy(WZBuffer,strTimeLimitEnd,8);
        memcpy(idCerInfoEx.endDate.data,&WZBuffer[0],4);
        strcat(idCerInfoEx.endDate.data,".");
        memcpy(strTmp,&WZBuffer[4],2);
        strcat(idCerInfoEx.endDate.data,strTmp);
        strcat(idCerInfoEx.endDate.data,".");
        memcpy(strTmp,&WZBuffer[6],2);
        strcat(idCerInfoEx.endDate.data,strTmp);
        idCerInfoEx.endDate.dwSize = 10;
    }

    //set result
    memcmp(idCerInfoEx.photoPath.data, strHeadPath, strlen(strHeadPath));
    idCerInfoEx.photoPath.dwSize = strlen(idCerInfoEx.photoPath.data);
    //不同证件类型字段区分开来
    switch(m_iCardType)
    {
    case 0://二代身份证
        {
            LOG4VTM(INFO, "证件类型为二代身份证");
            //类型：空
            memset(idCerInfoEx.idType.data, NULL, IDCER_EIGHT_BYTE_SIZE);
            //民族
            memcpy(idCerInfoEx.nation.data,strNation,strlen(strNation));
            idCerInfoEx.nation.dwSize = strlen(strNation);
            //地址
            memcpy(idCerInfoEx.address.data,strAddress,strlen(strAddress));
            idCerInfoEx.address.dwSize = strlen(strAddress);
        }
        break;
    case 1://外国人永久居留证
        {
            LOG4VTM(INFO, "IDCerGetDataEx 证件类型为外国人永久居留证");
            //类型：I
            memcpy(idCerInfoEx.idType.data, "I", 1);
            //英文姓名
            memcpy(idCerInfoEx.englishName.data,strNameENG,strlen(strNameENG));
            idCerInfoEx.englishName.dwSize = strlen(strNameENG);
            //国籍
            memcpy(idCerInfoEx.nationality.data,strNation,strlen(strNation));
            idCerInfoEx.nationality.dwSize = strlen(strNation);
            //证件版本号
            memcpy(idCerInfoEx.idVersion.data,strVersion,strlen(strVersion));
            idCerInfoEx.idVersion.dwSize = strlen(strVersion);
            //保留字段
            memcpy(idCerInfoEx.reserved.data,strReserveItem,strlen(strReserveItem));
            idCerInfoEx.reserved.dwSize = strlen(strReserveItem);
        }
        break;
    case 2://港澳台居民居住证
        {
            LOG4VTM(INFO, "IDCerGetDataEx 证件类型为港澳台居住证");
            //类型：J
            memcpy(idCerInfoEx.idType.data, "J", 1);
            //居住证号码
            memcpy(idCerInfoEx.txzCode.data,strTXZCode,strlen(strTXZCode));
            idCerInfoEx.txzCode.dwSize = strlen(strTXZCode);
            //签发次数
            memcpy(idCerInfoEx.issuedSN.data,strIssuedSN,strlen(strIssuedSN));
            idCerInfoEx.issuedSN.dwSize = strlen(strIssuedSN);
            //地址
            memcpy(idCerInfoEx.address.data,strAddress,strlen(strAddress));
            idCerInfoEx.address.dwSize = strlen(strAddress);
        }
        break;
    default:
        LOG4VTM(INFO, "IDCerGetDataEx 证件类型有误");
        break;
    }
    return Error_Succeed;
}

//	强制弹出身份证等证件
//	Force ID Card to eject。
//
ErrorCodeEnum IDCertImpl:: ForceIDEject()
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
//    SAutoLock lock(&m_MutexLock);
    CancelWaitMediaInsert();
    Sleep(300);
    int nCardST = 0;
    int iRt = m_id81Dev->GetStatus(nCardST);
    if(iRt != CWERR_IDCARD_SUCCESS)
        return HandleDevError(iRt, "ForceIDEject GetStatus");

    iRt = m_id81Dev->Tackout();
    return HandleDevError(iRt, __FUNCTION__);
}

//dep目录说明：应用在上层目录，动态库在dep目录，生成的临时文件也在dep目录
//当前目录和进程所在目录为上层目录，动态库和临时文件目录为dep子目录
ErrorCodeEnum IDCertImpl:: ScanIDAndSaveImage()
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
    char szIDFront[MAX_PATH] = {0};
    char szIDBack[MAX_PATH] = {0};
    sprintf(szIDFront, "%s/idfront.bmp", m_sLibPath);
    sprintf(szIDBack, "%s/idback.bmp", m_sLibPath);
//    SAutoLock lock(&m_MutexLock);
    if (m_bReInsert)    Sleep(1000);
    int iRt = m_id81Dev->DoScan(szIDFront,szIDBack);
    if(CWERR_IDCARD_SUCCESS != iRt)
    {
        return HandleDevError(iRt, __FUNCTION__);
    }
//    iRt = m_id81Dev->ejectToRerec();
//    if(CWERR_IDCARD_SUCCESS != iRt)
//    {
//        LOG4VTM(ERROR, "EjectToRerec Failed!");
//    }
    return HandleDevError(iRt, __FUNCTION__);
}

//	获取卡片是否插入或者取走
//	Query if ID Card have been inserted or fetched。
//	pos:
//		-- 0，未检测到任何证件；1，证件在读卡器内部；2，证件在进卡口
ErrorCodeEnum IDCertImpl:: QueryCardPos(int &pos)
{
    LOG4VTM_FUNCTION();
    if (!m_bOpen)
        HandleDevError(DEV_NOT_OPEN, __FUNCTION__);
    int iRt = Error_Succeed;
    int nCardST = 0;
//    SAutoLock lock(&m_MutexLock);
    iRt = m_id81Dev->GetStatus(nCardST);
    if(CWERR_IDCARD_SUCCESS == iRt)
    {
        switch(nCardST)
        {
        case CWINF_IDCARD_NOCARD:
            pos = 0;
            break;
        case CWINF_IDCARD_CARDMIDDLE:
        case CWINF_IDCARD_CARDSCAN:
            pos = 1;
            break;
        case CWINF_IDCARD_CARDENTRY:
            pos = 2;
            break;
        }
        char szRet[1024] = {0};
        sprintf(szRet, "QueryCardPos Card pos=%d Status(%d):NOCARD(1) SCAN(2) MIDDLE(3) ENTRY(4) JAM(5) UNKNOWN(9)",pos, nCardST);
        LOG4VTM(INFO, szRet);
        return Error_Succeed;
    }
    return HandleDevError(iRt, __FUNCTION__);
}

BOOL IDCertImpl::RecordSoftVersion(DevSoftVersion &devSoftVersion)
{
    return TRUE;
}

//	Get last error the device issued.
//	Error message must include explanatory memorandum ,the original error
//	code and anything in favour of location problem.
ErrorCodeEnum IDCertImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    ErrorCodeEnum eRt = Error_Succeed;
    devErrInfo.dwErrMsgLen = m_DevErrInfo.dwErrMsgLen;
    memset(devErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    memcpy(devErrInfo.szErrMsg,m_DevErrInfo.szErrMsg,m_DevErrInfo.dwErrMsgLen&0x0000FFFF);
    return eRt;
}

ErrorCodeEnum IDCertImpl::HandleDevError(int nRt, LPCTSTR lpszFormat, ...)
{
    ErrorCodeEnum eRt = Error_Succeed;
    WORD wHWErrorCode = DEC_SUCCESS;	//硬件设备错误码

    char errMsg[300] = {0};
    va_list arglist;
    va_start(arglist, lpszFormat);
    _vsnprintf(errMsg, 128, lpszFormat, arglist);
    va_end(arglist);

    string m_strError;
    switch (nRt)
    {
    case 0:
        wHWErrorCode = DEC_SUCCESS;
        eRt = Error_Succeed;
        strcat(errMsg, " success");
        break;
    case CWERR_PUBLIC_TIMEOUT:
        wHWErrorCode = DEC_TIMEOUT;
        eRt = Error_TimeOut;
        strcat(errMsg, " TimeOut");
        break;
    case CWERR_PUBLIC_WINAPI:
        wHWErrorCode = DEC_FILE_NOT_FOUND;
        strcat(errMsg, " FILE_NOT_FOUND");
        eRt = Error_Stoped;
        break;
    case -1:
        wHWErrorCode = DEC_HARDWARE;
        strcat(errMsg, " device error");
        eRt = Error_Hardware;
        break;
    case DEV_NOT_OPEN:
        wHWErrorCode = DEC_DEV_NOT_OPENED;
        strcat(errMsg, " device not open");
        eRt = Error_Stoped;
        break;
    case CWERR_IDCARD_CARD_JAM:
        strcat(errMsg, " CARD_JAM");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_DevMedia;
        break;
//    case CWERR_IDCARD_NOT_CONNECTED:
//        strInfo += _T("-CWERR_IDCARD_NOT_CONNECTED");
//        wHWErrorCode = DEC_HARDWARE;
//        eRt = Error_Stoped;
//        break;
    case CWERR_IDCARD_PORT_ERROR:
        strcat(errMsg, " PORT_ERROR");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    case CWERR_IDCARD_COVER_OPENED:
        strcat(errMsg, " COVER_OPENED");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    case CWERR_IDCARD_NO_CARD:
        strcat(errMsg, " NO_CARD");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    case CWERR_IDCARD_IDDATA_ERR:
        strcat(errMsg, " IDDATA_ERR");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    case CWERR_IDCARD_NO_IDDATA:
        strcat(errMsg, " NO_IDDATA");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    default:
        strcat(errMsg, " other error");
        wHWErrorCode = DEC_HARDWARE;
        eRt = Error_Stoped;
        break;
    }

    //if(!strInfo.IsEmpty())
    //	strInfo = strInfo +_T("+") + strInfo;
    //对dwErrMsgLen字段进行拆分
    // 高两字节存储硬件设备错误码 (dwErrMsgLen & 0xFFFF0000)
    // 低两字节保留以前的作用即：存储错误信息字符串szErrMsg的实际有效长度
    memset(m_DevErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    //int k = wcstombs(m_DevErrInfo.szErrMsg,wc,MAX_DEV_ERROR_MSG_LEN);
    //int nReturnlen=WideCharToMultiByte(CP_ACP,0,strInfo.GetBuffer(0),-1,m_DevErrInfo.szErrMsg,MAX_DEV_ERROR_MSG_LEN,NULL,NULL);

    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", eRt, errMsg);
//    memcpy(m_DevErrInfo.szErrMsg, strInfo.data(), strInfo.length());

    m_DevErrInfo.dwErrMsgLen = (wHWErrorCode<<16)&0xFFFF0000;
    m_DevErrInfo.dwErrMsgLen += strlen(m_DevErrInfo.szErrMsg)&0x0000FFFF;
    if (eRt != Error_Succeed)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return eRt;
}

void IDCertImpl::CancelWaitMediaInsert()
{
    m_id81Dev->setAutoFeedEnable(0);
}

ErrorCodeEnum IDCertImpl:: IDCerRFControl(bool bControl)
{
    LOG4VTM_FUNCTION();
    m_iCardType = -1;
//    SAutoLock lock(&m_MutexLock);
//    CancelWaitMediaInsert();
//    int nCardST = 0;
//    int iRt = m_id81Dev->GetStatus(nCardST);
//    if(iRt != CWERR_IDCARD_SUCCESS)
//        return HandleDevError(iRt, "IDCerRFControl GetStatus");

    int iRt = 0;
    if(bControl)
    {
        char sMsg[300] = {0};
        DeleteBmp();
        int iPos = 0;
        LOG4VTM(INFO, "IDCerRFControl enable");
        iRt = m_id81Dev->GetStatus(iPos);
        sprintf(sMsg, "IDCerRFControl enable ret %d pos %d", iRt, iPos);
        LOG4VTM(INFO, sMsg);
        if(iRt != CWERR_IDCARD_SUCCESS)
            return HandleDevError(iRt, "IDCerRFControl true GetStatus");
        if (iPos == CWINF_IDCARD_CARDJAM)
        {
            LOG4VTM(INFO, "IDCerRFControl CARDJAM");
            m_id81Dev->Reset(2);
            LOG4VTM(INFO, "IDCerRFControl GetStatus2");
            m_id81Dev->GetStatus(iPos);
        }
        if (iPos == CWINF_IDCARD_CARDENTRY)
        {
            /*
            m_id81Dev->doCardIn();
            m_id81Dev->GetStatus(iPos);
            if (iPos == CWINF_IDCARD_CARDENTRY)
            {
                iRt = m_id81Dev->BackInside();
                return HandleDevError(iRt, "IDCerRFControl true BackInside");
            }
            return HandleDevError(0, "IDCerRFControl true doCardIn ok");
            /*/
            m_bReInsert = true;
            LOG4VTM(INFO, "IDCerRFControl BackInside");
            iRt = m_id81Dev->BackInside();
            return HandleDevError(iRt, "IDCerRFControl true BackInside");
            //*/
        }
        else
        {
            m_bReInsert = false;
            iRt = m_id81Dev->setAutoFeedEnable(1);
            return HandleDevError(iRt, "IDCerRFControl true setAutoFeedEnable 1");
        }
    }
    else
    {
        m_id81Dev->setAutoFeedEnable(0);
        iRt = m_id81Dev->eject();
        return HandleDevError(iRt, "IDCerRFControl false setAutoFeedEnable 0");
    }
}

void    IDCertImpl::ThreadRun()
{

}

void	IDCertImpl::Start()
{
    pthread_attr_t	attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
    pthread_create(&m_hThreadID, &attr, Proc, (void*) this);
    pthread_attr_destroy(&attr);
}

void*	IDCertImpl::Proc(void* inPara)
{
    IDCertImpl*	pCtrl = (IDCertImpl*)inPara;
    pCtrl->ThreadRun();
    CloseThread(pCtrl->m_hThreadID);
    return 0;
}

void IDCertImpl::CloseThread(pthread_t& h)
{
    pthread_exit(0);
}