myvtm/DevAdapter/cw/fingerprint.1.1/FingerPrintImpl.cpp

/*
 * Create by LocalUser on 2020/9/22
*/

#include "FingerPrintImpl.h"
#include "log4vendor.h"

FingerPrintImpl::FingerPrintImpl()
{
    _fingerDev = new FingerDev();
//    m_DevStatus = DEVICE_STATUS_NORMAL;
    m_DevErrInfo.dwErrMsgLen = 0;
    memset(m_DevErrInfo.szErrMsg, 0, MAX_DEV_ERROR_MSG_LEN);
    m_sLibPath[0] = 0;
    m_bInitOK = false;
}

FingerPrintImpl::~FingerPrintImpl()
{
    if(_fingerDev != NULL)
        delete _fingerDev;
    _fingerDev = NULL;
}

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 FingerPrintImpl::GetDevCategory(DevCategoryInfo& devCategory)
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "GetDevCategory");
    char sInfo[128];
    int iRet = _fingerDev->GetVersion(sInfo);
    char szType[] = {"PVER=wellcom#MID=JZT-998"};
    char szModel[] = "FWID=%s";
    strcpy(devCategory.szType, szType);
    ErrorCodeEnum errcode =  HandleDevError(iRet, "Reset");
    if (errcode == Error_Succeed) {
        char* pSP = strstr(sInfo, "JZT-998");
        if (pSP)
            sprintf(devCategory.szModel, szModel, pSP + 7);
        else
            sprintf(devCategory.szModel, szModel, sInfo + 8);
        devCategory.eState = DEVICE_STATUS_NORMAL;
    }
    else{
        //"WELLCOM_JZT-998APB-V72_V2.0.1.0_N_R_GA[20201016]
        sprintf(devCategory.szModel, szModel, sInfo + 8);
        devCategory.eState = DEVICE_STATUS_FAULT;
    }
    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 szRet[512] = {0};
    sprintf(szRet, "szType:%s,szModel:%s,szVendor:%s,version.wMajor:%d,version.wMinor:%d,version.wBuild:%d,version.wRevision:%d,eState:%d(0:故障1:正常)",
            devCategory.szType,devCategory.szModel,devCategory.szVendor,devCategory.version.wMajor,devCategory.version.wMinor,devCategory.version.wBuild,devCategory.version.wRevision,devCategory.eState);
    LOG4VTM(INFO, szRet);
    return Error_Succeed;
}

ErrorCodeEnum FingerPrintImpl::Reset()
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "Reset");
    int iRt = 0;
    ErrorCodeEnum errcode = Error_Succeed;
    iRt = _fingerDev->Reset();
    errcode =  HandleDevError(iRt, "Reset");
    return errcode;
}

ErrorCodeEnum FingerPrintImpl::DevClose()
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "GetDevCategory");
    int iRt = 0;
    ErrorCodeEnum errcode = Error_Succeed;
    iRt = _fingerDev->Close();
    errcode = HandleDevError(iRt, "DevClose");
    m_bInitOK = false;
    return errcode;
}

ErrorCodeEnum FingerPrintImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    memcpy(&devErrInfo, &m_DevErrInfo, sizeof(DevErrorInfo));
    return Error_Succeed;
}

ErrorCodeEnum FingerPrintImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
    LOG4VTM_FUNCTION();
    int iRt = 0;

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

    ErrorCodeEnum errcode = Error_Succeed;
    iRt = _fingerDev->Open(cFilePath);
    errcode = HandleDevError(iRt, "DevOpen");
    m_bInitOK = errcode == Error_Succeed;
    return errcode;
}
//采集指纹图片及对应特征值,imagePath保存图片名，lpbFeature保存对应特征，iLength:输入代表buf最大长度,输出为特征实际长度
//dep目录说明：应用在上层目录，动态库在dep目录，生成的临时文件也在dep目录
//当前目录和进程所在目录为上层目录，动态库和临时文件目录为dep子目录
ErrorCodeEnum FingerPrintImpl::Image2Feature(const char* imageName, LPBYTE lpbFeature, int &iLength)
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "Image2Feature");
    char logMsg[1024] = {0};
    char sImgPath[260] = {0};
    sprintf(sImgPath, "%s/%s", m_sLibPath, imageName);
    remove(sImgPath);
    sprintf(logMsg, "Image2Feature imagePath: %s", sImgPath);
    LOG4VTM(INFO, logMsg);

    int iRt = _fingerDev->GetFPIImg2Bmp(sImgPath);
    ErrorCodeEnum errcode = HandleDevError(iRt, "GetFPIImg2Bmp");
    if(Error_Succeed == errcode)
    {
        LOG4VTM(INFO, "获取特征图片成功");
        iRt = _fingerDev->GetFPIBmp2Feature(sImgPath, lpbFeature, iLength);
        errcode = HandleDevError(iRt, "GetFPIBmp2Feature");
    }
    sprintf(logMsg, "Image2Feature Return Length = %d", iLength);
    LOG4VTM(INFO, logMsg);
    return errcode;
}

//生成特征模板（注册时使用）
//Convert image to template
ErrorCodeEnum FingerPrintImpl::Image2Template(const char* imagePath1, const char* imagePath2, const char* imagePath3, LPBYTE lpbTemplate, int &iLength)
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "Image2Template");
    char logMsg[1024] = {0};
    sprintf(logMsg, "imagePath1:%s,imagePath2:%s,imagePath3:%s", imagePath1, imagePath2, imagePath3);
    LOG4VTM(INFO, logMsg);
    int iRt = 0;
    ErrorCodeEnum errcode = Error_Succeed;
    iRt = _fingerDev->GetFPIBmp2Template(imagePath1, imagePath2, imagePath3, lpbTemplate, iLength);
    errcode = HandleDevError(iRt, "Image2Template");
    sprintf(logMsg, "Return Length = %d", iLength);
    LOG4VTM(INFO, logMsg);
    return errcode;
}

//比对校验
//Match the feature
ErrorCodeEnum FingerPrintImpl::Match(LPBYTE lpbTemplate[], int iTemplateLen[] ,int templateNum, LPBYTE lbpFeature, int &iFeatureLen ,int level)
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "Match");

    char logMsg[1024] = {0};
    int iRt = 0;
    ErrorCodeEnum errcode = Error_Succeed;
    //保存各个模板长度
    int *templen = new int[templateNum + 1];
    memset(templen, 0, templateNum + 1);
    memcpy(templen, iTemplateLen, templateNum);
    //初始化比对结果
    memset(iTemplateLen, 0, templateNum);
    for (int i = 0; i < templateNum; i++)
    {
        sprintf(logMsg, "TemplateNum:%d, Template%d[Length:%d], level:%d", templateNum, i+1, templen[i], level);
        LOG4VTM(INFO, logMsg);
        iRt = _fingerDev->FPIMatch(lpbTemplate[i], lbpFeature, level);
        if(LS_ERROR_SUCCESS == iRt)
        {
            //比对成功，设置标志为1
            iTemplateLen[i] = 1;
        }
        else if(LS_ERROR_MATCH == iRt || LS_ERROR_FEATURE == iRt || LS_ERROR_TEMPLATE == iRt)
        {
            //比对失败，设置标志为0
            iTemplateLen[i] = 0;
        }
        else
        {
            //其他异常错误，直接返回失败
            errcode = HandleDevError(iRt, "FPIMatch");
            break;
        }
        sprintf(logMsg, "iTemplateLen[%d]:%s(%d)", i, iTemplateLen[i] == 1 ? "比对成功" : "比对失败", iRt);
        LOG4VTM(INFO, logMsg);
    }
    //释放缓冲区
    delete []templen;
    return errcode;
}

//取消采集指纹图片
ErrorCodeEnum FingerPrintImpl::Cancel()
{
    LOG4VTM_FUNCTION();
    if (!m_bInitOK)
        return HandleDevError(LS_ERROR_DEVICE_NOT_INIT, "Cancel");

    int iRt = 0;
    ErrorCodeEnum errcode = Error_Succeed;
    iRt = _fingerDev->Cancel();
    errcode = HandleDevError(iRt, "Cancel");
    if(Error_Succeed == errcode)
    {
        LOG4VTM(INFO, "取消成功");
    }
    return errcode;
}

ErrorCodeEnum FingerPrintImpl::HandleDevError(int nRt, LPCTSTR lpszFormat, ...)
{
    ErrorCodeEnum eRt = Error_Succeed;
    int wHWErrorCode = LS_ERROR_SUCCESS;	//硬件设备错误码
    char strErrInfo[128];
    switch (nRt)
    {
    case LS_ERROR_SUCCESS:
        wHWErrorCode = LS_ERROR_SUCCESS;
        eRt = Error_Succeed;
        strcpy(strErrInfo, "成功");
        break;
    case LS_ERROR_DEVICE_NOT_INIT://未初始化
        wHWErrorCode = LS_ERROR_DEVICE_NOT_INIT;
        eRt = Error_DevConnFailed;
        strcpy(strErrInfo, "未初始化");
        break;
    case LS_ERROR_DEVICE_NOT_FOUND: //设备不存在
        wHWErrorCode = LS_ERROR_DEVICE_NOT_FOUND;
        eRt = Error_DevConnFailed;
        strcpy(strErrInfo, "设备不存在");
        break;
    case LS_ERROR_INVALID_PARAMETER://参数非法
        wHWErrorCode = LS_ERROR_INVALID_PARAMETER;
        eRt = Error_Param;
        strcpy(strErrInfo, "参数非法");
        break;
    case LS_ERROR_NOT_ENOUGH_MEMORY://内存溢出
        wHWErrorCode = LS_ERROR_NOT_ENOUGH_MEMORY;
        eRt = Error_Stoped;
        strcpy(strErrInfo, "内存溢出");
        break;
    case LS_ERROR_NOT_SUPPORT_FUNCTION://功能未开放
        wHWErrorCode = LS_ERROR_NOT_SUPPORT_FUNCTION;
        eRt = Error_Stoped;
        strcpy(strErrInfo, "功能未开放");
        break;
    case LS_ERROR_INVALIDE_CODE://非法错误号
        wHWErrorCode = LS_ERROR_INVALIDE_CODE;
        eRt = Error_Stoped;
        strcpy(strErrInfo, "非法错误号");
        break;
    case LS_ERROR_TIMEOUT://超时
        wHWErrorCode = LS_ERROR_TIMEOUT;
        eRt = Error_TimeOut;
        strcpy(strErrInfo, "超时");
        break;
    case LS_ERROR_FEATURE://特征错误
        wHWErrorCode = LS_ERROR_FEATURE;
        eRt = Error_DevLoadFileFailed;
        strcpy(strErrInfo, "特征错误");
        break;
    case LS_ERROR_TEMPLATE://模板错误
        wHWErrorCode = LS_ERROR_TEMPLATE;
        eRt = Error_DevLoadFileFailed;
        strcpy(strErrInfo, "模板错误");
        break;
    case LS_ERROR_KEY://密钥错误
        wHWErrorCode = LS_ERROR_KEY;
        eRt = Error_DevLoadFileFailed;
        strcpy(strErrInfo, "密钥错误");
        break;
    case LS_ERROR_IMAGE_ERR://密钥错误
        wHWErrorCode = LS_ERROR_IMAGE_ERR;
        eRt = Error_DevLoadFileFailed;
        strcpy(strErrInfo, "图像错误");
        break;
    default:
        wHWErrorCode = LS_ERROR_OTHERERROR;
        eRt = Error_Stoped;
        strcpy(strErrInfo, "未知错误码");
        break;
    }

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

    strcat(errMsg, " ");
    strcat(errMsg, strErrInfo);
    //对dwErrMsgLen字段进行拆分
    // 高两字节存储硬件设备错误码 (dwErrMsgLen & 0xFFFF0000)
    // 低两字节保留以前的作用即：存储错误信息字符串szErrMsg的实际有效长度
    m_DevErrInfo.dwErrMsgLen = (eRt<<16)&0xFFFF0000;
    m_DevErrInfo.dwErrMsgLen += strlen(m_DevErrInfo.szErrMsg)&0x0000FFFF;
    sprintf(m_DevErrInfo.szErrMsg, "{\"ErrCode\":\"%04x\"，\"Description\":\"%s\"}", eRt, errMsg);
//    memset(m_DevErrInfo.szErrMsg,0,MAX_DEV_ERROR_MSG_LEN);
//    memcpy(m_DevErrInfo.szErrMsg,strErrInfo.data(),strErrInfo.length());

    if (eRt != Error_Succeed)
        LOG4VTM(WARN, m_DevErrInfo.szErrMsg);
    else
        LOG4VTM(INFO, m_DevErrInfo.szErrMsg);
    return eRt;
}