myvtm/DevAdapter/grg/idcer.1.1/idcer_impl.cpp

#include <memory.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dlfcn.h>
#include <iconv.h>
#include "idcer_impl.h"
#include "GRGIDRCHKDev.h"
#include "log4vendor.h"

DEVICEBASE_API ErrorCodeEnum  CreateDevComponent(DeviceBaseClass *&baseObj) {
	baseObj = new IDCerClassImpl();
	if (baseObj == NULL)
	{
		return Error_Resource;
	}
	
	cmb::log_init_config config;
    config.dev_name = "IDCer";
	config.log_level = CMB_LOG_LEVEL_TRACE;
#if defined(_MSC_VER)
    config.log_dir = ("C:\\rvc\\dbg\\");
#else
    config.log_dir = ("/opt/rvc/dbg/");
#endif //_MSC_VER
    std::string str;
    cmb::log4vendor::init(config, str);
    printf("init after: %s\n", str.c_str());
    return Error_Succeed;
}
DEVICEBASE_API ErrorCodeEnum  ReleaseDevComponent(DeviceBaseClass *&pBaseObj)
{
	if(pBaseObj == NULL)
    {
        return Error_Param;
    }
    if(IDCerClassImpl* pTmp = dynamic_cast<IDCerClassImpl*>(pBaseObj))
    {
        delete pTmp;
        pTmp = NULL;
        return Error_Succeed;
    }
    return Error_Param;
}

IDCerClassImpl::IDCerClassImpl()
{
	m_DeviceID = -1;
	ZeroDevErrorInfo();
	//m_sSoPath = GeSoFilePath((void*)&EnumScannerDevice);
	m_sSoPath = GeSoFilePath((void*)&CreateDevComponent);
	m_sHeadImageName = "./zp.bmp";
	m_sFrontPath = "./idfront.bmp";
	m_sBackPath = "./idback.bmp";
	if(m_sSoPath != ""){
		m_sFrontPath = m_sSoPath + "/idfront.bmp";
		m_sBackPath = m_sSoPath + "/idback.bmp";
		m_sHeadImageName = m_sSoPath + "/zp.bmp";
	}
}

IDCerClassImpl::~IDCerClassImpl()
{
	remove(const_cast<char*>(m_sHeadImageName.c_str()));
	remove(const_cast<char*>(m_sFrontPath.c_str()));
	remove(const_cast<char*>(m_sBackPath.c_str()));
	DevClose();
}

void IDCerClassImpl::ZeroDevErrorInfo()
{
	memset(&m_DevErrorInfo, 0, sizeof(m_DevErrorInfo));
}

void IDCerClassImpl::FormatDevErrorInfo(const char* funcname, int line)
{
	ZeroDevErrorInfo();
	int errCode = GetLastErrorCode();
	if (errCode != IDDIGITALCOPIER_NO_ERROR)
	{
		char errStr[1024]={ 0 };
		GetLastErrorStr(errStr);
		snprintf(m_DevErrorInfo.szErrMsg, sizeof(m_DevErrorInfo.szErrMsg), "ErrCode:0x%x,Description:Func:%s,Line:%d,Msg:%s", errCode, funcname, line, errStr);
		m_DevErrorInfo.dwErrMsgLen = strlen(m_DevErrorInfo.szErrMsg);
		LOG4VTM(ERROR,m_DevErrorInfo.szErrMsg);
	}
}

ErrorCodeEnum IDCerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	char* szType = "PVER=GRG#MID=IDR-001";
	char* szVendor = "grg";
	char* szModel = "STYLE=IG#FUNCTON=ITF";
	memset(&devCategory,0,sizeof(devCategory));
	strcpy(devCategory.szType, szType);
	strcpy(devCategory.szVendor, szVendor);
	strcpy(devCategory.szModel, szModel);
/*
	char versionInfo[128] = { 0 };
	if (IDDIGITALCOPIER_NO_ERROR != GetSWVersion(versionInfo)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	//V1.1.5.1去掉V
	char *tokenPtr=strtok(versionInfo+1,".");
	int ver[4] = {0};
	int index = 0;
	while(tokenPtr!=NULL){
		ver[index++] = atoi(tokenPtr);
		tokenPtr=strtok(NULL,".");
    }
	devCategory.version.wMajor = ver[0];
	devCategory.version.wMinor = ver[1];
	devCategory.version.wRevision = ver[2];
	devCategory.version.wBuild = ver[3];
*/
	devCategory.version.wMajor = 1;
	devCategory.version.wMinor = 1;
	devCategory.version.wRevision = 65535;
	devCategory.version.wBuild = 1;

	DEVSTATUSEx dev;
	int ret = GetDevStatusEx(m_DeviceID,&dev);
	if (ret == IDDIGITALCOPIER_NO_ERROR)
	{
		devCategory.eState = DEVICE_STATUS_CONNECTING;
	}
	else if (ret == IDDIGITALCOPIER_HAVE_NOT_INIT
		|| ret == IDDIGITALCOPIER_PORT_ERROR)
	{
		devCategory.eState = DEVICE_STATUS_NOT_READY;
	}
	else if (ret == IDDIGITALCOPIER_FIRMWARE_ERROR
		|| ret == IDDIGITALCOPIER_VOLTAGE_LOW
		|| ret == IDDIGITALCOPIER_POWER_OFF
		|| dev.iStatusLowVoltage == 1
		|| dev.iStatusPowerOff == 1)
	{
		devCategory.eState = DEVICE_STATUS_FAULT;
	}
/*
	DEVSTATUSEx devStatus;
	if (IDDIGITALCOPIER_NO_ERROR != GetDevStatusEx(m_DeviceID, &devStatus)) {
		//FormatDevErrorInfo(__FUNCTION__, __LINE__);
		devCategory.eState = DEVICE_STATUS_NOT_READY;
	}else{
		devCategory.eState = DEVICE_STATUS_NORMAL;
	}
*/
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//	Reset device.
//	Do the cleaning work and initialize device again in order to return to
//	the normal condition.
ErrorCodeEnum IDCerClassImpl::Reset()
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	if (IDDIGITALCOPIER_NO_ERROR != ResetDevice(m_DeviceID)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//	
//	Close device and do the cleaning work.
//	ex. close connection,close port,release memery and so on
ErrorCodeEnum IDCerClassImpl::DevClose()
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	DEVSTATUSEx dev;
	if (IDDIGITALCOPIER_NO_ERROR == GetDevStatusEx(m_DeviceID, &dev))
	{
		if (dev.iStatusCardJam == 1
			|| dev.iStatusMiddleSensorHaveCard == 1
			|| dev.iStatusScanSensorHaveCard == 1)
		{
			BackIdCard(m_DeviceID);
		}
	}

	if (IDDIGITALCOPIER_NO_ERROR != CloseConnection(m_DeviceID)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	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 IDCerClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
	memset(&devErrInfo,0,sizeof(devErrInfo));
	memcpy(&devErrInfo, &m_DevErrorInfo, sizeof(devErrInfo));
	return Error_Succeed;
}

//IDCerClass
//
//	Open device.
//	if usb device,set dwPort=0
//
ErrorCodeEnum IDCerClassImpl::DevOpen(DWORD dwPort)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	unsigned DeviceCount = 8;
	ScannerInfoRec  ScannerInfo[8]={0};
	int retv = EnumScannerDevice(ScannerInfo,&DeviceCount);
	m_DeviceID = ScannerInfo[0].DeviceID;
	//printf("EnumScannerDevice :retv=%d,count=%d,DeviceID=%d\n",retv,DeviceCount,m_DeviceID);
	//default image format is bmp
	if (IDDIGITALCOPIER_NO_ERROR != OpenConnection(m_DeviceID)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_DevConnFailed;
	}
	if (IDDIGITALCOPIER_NO_ERROR != SetInitFeedMode(m_DeviceID,0)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	
	if (IDDIGITALCOPIER_NO_ERROR != SetButtonEnable(m_DeviceID,1)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	
	if (IDDIGITALCOPIER_NO_ERROR != SetAutoFeedEnable(m_DeviceID,0)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//
//	Optional.
//	Open or close RF. 
//	Arguments:
//	- bControl:true:open RF,false close RF
//	-	对于吸入式，为true接收身份证插入，为false时弹出身份证并关闭接收身份证插入
//
ErrorCodeEnum IDCerClassImpl::IDCerRFControl(bool bControl)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	DEVSTATUSEx dev;
	if (IDDIGITALCOPIER_NO_ERROR != GetDevStatusEx(m_DeviceID, &dev))
	{
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Hardware;
	}

	if (bControl)
	{
		if (dev.iStatusMiddleSensorHaveCard == 1
			|| dev.iStatusScanSensorHaveCard == 1)
		{
			if (IDDIGITALCOPIER_NO_ERROR != BackIdCardToRerec(m_DeviceID))
			{
				FormatDevErrorInfo(__FUNCTION__, __LINE__);
			}
		}

		if (IDDIGITALCOPIER_NO_ERROR != SetAutoFeedEnable(m_DeviceID,1))
		{
			FormatDevErrorInfo(__FUNCTION__, __LINE__);
			return Error_Unexpect;
		}
	}
	else
	{
		if (dev.iStatusMiddleSensorHaveCard == 1
			|| dev.iStatusScanSensorHaveCard == 1)
		{
			if (IDDIGITALCOPIER_NO_ERROR != BackAndHoldIdCard(m_DeviceID))
			{
				FormatDevErrorInfo(__FUNCTION__, __LINE__);
				return Error_DevMedia;
			}
		}
		int ret = SetAutoFeedEnable(m_DeviceID,0);
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;

/*
	int ret = 0;
	int checktime = 30 * 1000;//先设定30秒
	if (bControl) {
		ret = CheckHaveIdCard(m_DeviceID, checktime);
	}
	else {
		ret = BackAndHoldIdCard(m_DeviceID);
	}
	if (IDDIGITALCOPIER_NO_ERROR != ret) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	return Error_Succeed;
*/
}

//
//	Optional.
//	Certificate authentication.
//
ErrorCodeEnum IDCerClassImpl::IDCerAuthenticate()
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	DEVSTATUS dev;
	if (IDDIGITALCOPIER_NO_ERROR != GetDevStatus(m_DeviceID, &dev))
	{
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_DevCommFailed;
	}

	// 先判断在内部
	if (dev.iStatusCardJam == 1
		|| dev.iStatusMiddleSensorHaveCard == 1
		|| dev.iStatusScanSensorHaveCard == 1
		)
	{
		//in
		LOG4VTM(INFO,__FUNCTION__<<" in");

	}
	else if (dev.iStatusInputSensorHaveCard == 1)
	{
		//out
		LOG4VTM(INFO,__FUNCTION__<<" out");
	}
	else
	{
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
/*
	int checktime = 30 * 1000;
	if (IDDIGITALCOPIER_NO_CARD == CheckHaveIdCard(m_DeviceID, checktime)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
*/
	//如果没有识别到卡类型则表示无效卡
	int iCardType;
	if (IDDIGITALCOPIER_NO_ERROR != GetIDCardType(m_DeviceID, &iCardType)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_DevMedia;
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//  即将废弃，请使用IDCerGetDataEx
//	Get Identity Card info.
//
//是否包含字符串\0结束符
#define EOF_LEN 1
#define UTF8_BUFF_SIZE 1024
ErrorCodeEnum IDCerClassImpl::IDCerGetData(IDCerInfo &idCerInfo)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	IDInfo idInfo = {0};
	memset(&idCerInfo, 0, sizeof(idCerInfo));
	if (IDDIGITALCOPIER_NO_ERROR != GetID2Info(m_DeviceID, &idInfo, const_cast<char*>(m_sHeadImageName.c_str()))) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	//姓名
	char utf8buf[UTF8_BUFF_SIZE] = {0};
	GbkToUtf8(idInfo.name,strlen(idInfo.name),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.name.data, utf8buf);
	idCerInfo.name.dwSize = strlen(utf8buf);
	//性别
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(idInfo.sex,strlen(idInfo.sex),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.sex.data, utf8buf);
	idCerInfo.sex.dwSize = strlen(utf8buf);
	//民族
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(idInfo.nation,strlen(idInfo.nation),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.nation.data, utf8buf);
	idCerInfo.nation.dwSize = strlen(utf8buf);
	//生日
	std::string Newbirthday = ForDataFormat(std::string(idInfo.birthday), "for");
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(const_cast<char*>(Newbirthday.c_str()),strlen(Newbirthday.c_str()),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.birthday.data, utf8buf);
	idCerInfo.birthday.dwSize = strlen(utf8buf);
	//住址
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(idInfo.address,strlen(idInfo.address),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.address.data, utf8buf);
	idCerInfo.address.dwSize = strlen(utf8buf);
	//证件号
	int len = sizeof(idCerInfo.idno.data) > strlen(idInfo.number) ? strlen(idInfo.number) : sizeof(idCerInfo.idno.data);
	strncpy(idCerInfo.idno.data, idInfo.number, len);
	idCerInfo.idno.dwSize = len;
	//签发机关
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(idInfo.department,strlen(idInfo.department),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.department.data, utf8buf);
	idCerInfo.department.dwSize = strlen(utf8buf);
	//处理有效期
	std::string beginTime = "", endTime = "";
	std::string data = std::string(idInfo.timeLimit);
	if (data.length() > 0)
	{
		int location = data.find_first_of("-");
		if (location > 0)
		{
			beginTime = data.substr(0, location);
			beginTime = ForDataFormat(beginTime, ".");
			endTime = data.substr(location + 1, data.length());
			endTime = ForDataFormat(endTime, ".");
		}
	}
	//有效日期签发日
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(const_cast<char*>(beginTime.c_str()),strlen(beginTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.startDate.data, utf8buf);
	idCerInfo.startDate.dwSize = strlen(utf8buf);
	//有效日期终止日
	memset(utf8buf,0,UTF8_BUFF_SIZE);
	GbkToUtf8(const_cast<char*>(endTime.c_str()),strlen(endTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
	strcpy(idCerInfo.endDate.data, utf8buf);
	idCerInfo.endDate.dwSize = strlen(utf8buf);
	//头像信息
	strcpy(idCerInfo.photoPath.data, idInfo.Image);
	idCerInfo.photoPath.dwSize = strlen(idInfo.Image);

	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//  获取证件信息，包括二代身份证、外国人永久居留证
//	Get Identity Card info.
//
ErrorCodeEnum IDCerClassImpl::IDCerGetDataEx(IDCerInfoEx &idCerInfoEx)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	int iCardType;
	memset(&idCerInfoEx, 0, sizeof(idCerInfoEx));
	if (IDDIGITALCOPIER_NO_ERROR != GetIDCardType(m_DeviceID, &iCardType)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	switch (iCardType)
	{
	case 0://普通身份证
	{
		IDInfo idInfo = {0};
		if (IDDIGITALCOPIER_NO_ERROR != GetID2Info(m_DeviceID, &idInfo, const_cast<char*>(m_sHeadImageName.c_str()))) {
			FormatDevErrorInfo(__FUNCTION__, __LINE__);
			return Error_Unexpect;
		}
		//姓名
		char utf8buf[UTF8_BUFF_SIZE] = {0};
		GbkToUtf8(idInfo.name,strlen(idInfo.name),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.name.data, utf8buf);
		idCerInfoEx.name.dwSize = strlen(utf8buf);
		//性别
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfo.sex,strlen(idInfo.sex),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.sex.data, utf8buf);
		idCerInfoEx.sex.dwSize = strlen(utf8buf);
		//民族
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfo.nation,strlen(idInfo.nation),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.nation.data, utf8buf);
		idCerInfoEx.nation.dwSize = strlen(utf8buf);
		//生日
		std::string Newbirthday = ForDataFormat(std::string(idInfo.birthday), "for");
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(Newbirthday.c_str()),strlen(Newbirthday.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.birthday.data, utf8buf);
		idCerInfoEx.birthday.dwSize = strlen(utf8buf);
		//住址
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfo.address,strlen(idInfo.address),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.address.data, utf8buf);
		idCerInfoEx.address.dwSize = strlen(utf8buf);
		//证件号
		int len = sizeof(idCerInfoEx.idno.data) > strlen(idInfo.number) ? strlen(idInfo.number) : sizeof(idCerInfoEx.idno.data);
		strncpy(idCerInfoEx.idno.data, idInfo.number, len);
		idCerInfoEx.idno.dwSize = len;
		//签发机关
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfo.department,strlen(idInfo.department),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.department.data, utf8buf);
		idCerInfoEx.department.dwSize = strlen(utf8buf);
		//处理有效期
		std::string beginTime = "", endTime = "";
		std::string data = std::string(idInfo.timeLimit);
		if (data.length() > 0)
		{
			int location = data.find_first_of("-");
			if (location > 0)
			{
				beginTime = data.substr(0, location);
				beginTime = ForDataFormat(beginTime, ".");
				endTime = data.substr(location + 1, data.length());
				endTime = ForDataFormat(endTime, ".");
			}
		}
		//有效日期签发日
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(beginTime.c_str()),strlen(beginTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.startDate.data, utf8buf);
		idCerInfoEx.startDate.dwSize = strlen(utf8buf);
		//有效日期终止日
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(endTime.c_str()),strlen(endTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.endDate.data, utf8buf);
		idCerInfoEx.endDate.dwSize = strlen(utf8buf);
		//头像信息
		strcpy(idCerInfoEx.photoPath.data, idInfo.Image);
		idCerInfoEx.photoPath.dwSize = strlen(idInfo.Image);
		break;
	}
	case 1://外国人居住证
	{
		IDInfoForeign idInfoFore;
		if (IDDIGITALCOPIER_NO_ERROR != GetIDInfoForeign(m_DeviceID, &idInfoFore, const_cast<char*>(m_sHeadImageName.c_str()))) {
			FormatDevErrorInfo(__FUNCTION__, __LINE__);
			return Error_Unexpect;
		}
		char utf8buf[UTF8_BUFF_SIZE] = {0};
		//英文姓名
		strcpy(idCerInfoEx.englishName.data, idInfoFore.NameENG);
		idCerInfoEx.englishName.dwSize = strlen(idInfoFore.NameENG);
		//国籍
		GbkToUtf8(idInfoFore.Nation,strlen(idInfoFore.Nation),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.nationality.data, utf8buf);
		idCerInfoEx.nationality.dwSize = strlen(utf8buf);
		//证件类型
		strcpy(idCerInfoEx.idType.data, "I");
		idCerInfoEx.idType.dwSize = strlen("I");
		//证件版本
		strcpy(idCerInfoEx.idVersion.data, idInfoFore.IDVersion);
		idCerInfoEx.idVersion.dwSize = strlen(idInfoFore.IDVersion);
		//保留字段
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoFore.Reserve,strlen(idInfoFore.Reserve),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.reserved.data, utf8buf);
		idCerInfoEx.reserved.dwSize = strlen(utf8buf);
		//中文姓名
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoFore.NameCHN,strlen(idInfoFore.NameCHN),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.name.data, utf8buf);
		idCerInfoEx.name.dwSize = strlen(utf8buf);
		//性别
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoFore.Sex,strlen(idInfoFore.Sex),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.sex.data, utf8buf);
		idCerInfoEx.sex.dwSize = strlen(utf8buf);
		//生日
		std::string Newbirthday = ForDataFormat(std::string(idInfoFore.Born), "for");
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(Newbirthday.c_str()),strlen(Newbirthday.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.birthday.data, utf8buf);
		idCerInfoEx.birthday.dwSize = strlen(utf8buf);
		//证件号
		strcpy(idCerInfoEx.idno.data, idInfoFore.IDCardNO);
		idCerInfoEx.idno.dwSize = strlen(idInfoFore.IDCardNO);
		//签发机关
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoFore.Department,strlen(idInfoFore.Department),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.department.data, utf8buf);
		idCerInfoEx.department.dwSize = strlen(utf8buf);
		//有效日期签发日
		std::string NewTimeLimitBegin = GetForeignTimeLimit(std::string(idInfoFore.TimeLimitBegin), ".");
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(NewTimeLimitBegin.c_str()),strlen(NewTimeLimitBegin.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.startDate.data, utf8buf);
		idCerInfoEx.startDate.dwSize = strlen(utf8buf);
		//有效日期终止日
		std::string NewTimeLimitEnd = GetForeignTimeLimit(std::string(idInfoFore.TimeLimitEnd), ".");
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(NewTimeLimitEnd.c_str()),strlen(NewTimeLimitEnd.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.endDate.data, utf8buf);
		idCerInfoEx.endDate.dwSize = strlen(utf8buf);
		//头像信息
		int len = sizeof(idCerInfoEx.photoPath.data) > strlen(idInfoFore.Image) ? strlen(idInfoFore.Image) : sizeof(idCerInfoEx.photoPath.data);
		strncpy(idCerInfoEx.photoPath.data, idInfoFore.Image, len);
		idCerInfoEx.photoPath.dwSize = len;
		break;
	}
	case 2://港澳台居住证
	{
		IDInfoGAT idInfoGAT;
		if (IDDIGITALCOPIER_NO_ERROR != GetIDInfoGAT(m_DeviceID, &idInfoGAT, const_cast<char*>(m_sHeadImageName.c_str()))) {
			FormatDevErrorInfo(__FUNCTION__, __LINE__);
			return Error_Unexpect;
		}
		//姓名
		char utf8buf[UTF8_BUFF_SIZE] = {0};
		GbkToUtf8(idInfoGAT.name,strlen(idInfoGAT.name),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.name.data, utf8buf);
		idCerInfoEx.name.dwSize = strlen(utf8buf);
		//性别
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoGAT.sex,strlen(idInfoGAT.sex),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.sex.data, utf8buf);
		idCerInfoEx.sex.dwSize = strlen(utf8buf);
		//民族
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoGAT.nation,strlen(idInfoGAT.nation),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.nation.data, utf8buf);
		idCerInfoEx.nation.dwSize = strlen(utf8buf);
		//生日
		std::string Newbirthday = ForDataFormat(std::string(idInfoGAT.birthday), "for");
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(Newbirthday.c_str()),strlen(Newbirthday.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.birthday.data, utf8buf);
		idCerInfoEx.birthday.dwSize = strlen(utf8buf);
		//住址
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoGAT.address,strlen(idInfoGAT.address),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.address.data, utf8buf);
		idCerInfoEx.address.dwSize = strlen(utf8buf);
		//证件号
		int len = sizeof(idCerInfoEx.idno.data) > strlen(idInfoGAT.number) ? strlen(idInfoGAT.number) : sizeof(idCerInfoEx.idno.data);
		strncpy(idCerInfoEx.idno.data, idInfoGAT.number, len);
		idCerInfoEx.idno.dwSize = len;
		//签发机关
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(idInfoGAT.department,strlen(idInfoGAT.department),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.department.data, utf8buf);
		idCerInfoEx.department.dwSize = strlen(utf8buf);
		//有效日期签发日
		std::string beginTime = "", endTime = "";
		std::string data = std::string(idInfoGAT.timeLimit);
		if (data.length() > 0)
		{
			int location = data.find_first_of("-");
			if (location > 0)
			{
				beginTime = data.substr(0, location);
				beginTime = ForDataFormat(beginTime, ".");
				endTime = data.substr(location + 1, data.length());
				endTime = ForDataFormat(endTime, ".");
			}
		}
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(beginTime.c_str()),strlen(beginTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.startDate.data, utf8buf);
		idCerInfoEx.startDate.dwSize = strlen(utf8buf);
		//有效日期终止日
		memset(utf8buf,0,UTF8_BUFF_SIZE);
		GbkToUtf8(const_cast<char*>(endTime.c_str()),strlen(endTime.c_str()),utf8buf,UTF8_BUFF_SIZE);
		strcpy(idCerInfoEx.endDate.data, utf8buf);
		idCerInfoEx.endDate.dwSize = strlen(utf8buf);
		//头像信息
		strcpy(idCerInfoEx.photoPath.data, idInfoGAT.Image);
		idCerInfoEx.photoPath.dwSize = strlen(idInfoGAT.Image);
		//通行证号码
		strcpy(idCerInfoEx.txzCode.data, idInfoGAT.passport);
		idCerInfoEx.txzCode.dwSize = strlen(idInfoGAT.passport);
		//签发次数
		strcpy(idCerInfoEx.issuedSN.data, idInfoGAT.issue);
		idCerInfoEx.issuedSN.dwSize = strlen(idInfoGAT.issue);
		//证件类型
		strcpy(idCerInfoEx.idType.data, "J");
		idCerInfoEx.idType.dwSize = strlen("J");
		break;
	}
	default:
		break;
	}
	
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//	强制弹出身份证等证件
//	Force ID Card to eject。
//
ErrorCodeEnum IDCerClassImpl::ForceIDEject()
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	if (IDDIGITALCOPIER_NO_ERROR != BackIdCard(m_DeviceID)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}

	SetAutoFeedEnable(m_DeviceID,0);

	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

//	扫描证件并保留扫描文件到默认路径（dep目录下），证件正面使用“idfront.bmp”,证件反面使用“idback.bmp”
//	Scan ID Card and save the image to the position(dep/),using default name "idfront.bmp" and "idback.bmp"。
//
ErrorCodeEnum IDCerClassImpl::ScanIDAndSaveImage()
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	const int max_len = 16 * 1024 * 1024;//驱动接口最大支持16M
	char* cFrontImgBuf = (char*)malloc(max_len);
	char* cRearImgBuf = (char*)malloc(max_len);
	int iFrontLen = max_len;
	int iRearLen = max_len;
	memset(cFrontImgBuf,0x0,max_len);
	memset(cRearImgBuf,0x0,max_len);
	//remove bmp
	//remove(const_cast<char*>(m_sFrontPath.c_str()));
	//remove(const_cast<char*>(m_sBackPath.c_str()));
	ErrorCodeEnum errCode = Error_Succeed;
	int ret = StartScanIdCard(m_DeviceID);
	if (ret != IDDIGITALCOPIER_NO_ERROR) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		errCode = Error_Unexpect;
		goto End;
	}
	ret = SavePicToMemory(m_DeviceID, cFrontImgBuf, cRearImgBuf, &iFrontLen, &iRearLen);
	if (ret != IDDIGITALCOPIER_NO_ERROR) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		errCode = Error_Unexpect;
		goto End;
	}
	ret = SavePicToFile(m_DeviceID, cFrontImgBuf, iFrontLen, const_cast<char*>(m_sFrontPath.c_str()), 0);
	if (ret != IDDIGITALCOPIER_NO_ERROR) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		errCode = Error_Unexpect;
		goto End;
	}
	ret = SavePicToFile(m_DeviceID, cRearImgBuf, iRearLen, const_cast<char*>(m_sBackPath.c_str()), 0);
	if (ret != IDDIGITALCOPIER_NO_ERROR) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		errCode = Error_Unexpect;
		goto End;
	}
End:
	if(cFrontImgBuf){
		free(cFrontImgBuf);
	}
	
	if(cRearImgBuf){
		free(cRearImgBuf);
	}
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return errCode;
}

//	获取卡片是否插入或者取走
//	Query if ID Card have been inserted or fetched。
//	pos:
//		-- 0，未检测到任何证件；1，证件在读卡器内部；2，证件在进卡口
//
ErrorCodeEnum IDCerClassImpl::QueryCardPos(int &pos)
{
	LOG4VTM_FUNCTION();
	LOG4VTM(INFO,__FUNCTION__);
	DEVSTATUSEx DevStatusEx;	
	if (IDDIGITALCOPIER_NO_ERROR != GetDevStatusEx(m_DeviceID, &DevStatusEx)) {
		FormatDevErrorInfo(__FUNCTION__, __LINE__);
		return Error_Unexpect;
	}
	pos = 0;

	if (DevStatusEx.iStatusMiddleSensorHaveCard > 0 ||
		DevStatusEx.iStatusScanSensorHaveCard > 0 ||
		DevStatusEx.iStatusCardJam > 0)
	{
		pos = 1;
	}else if (DevStatusEx.iStatusInputSensorHaveCard > 0)
	{
		pos = 2;
	}
	LOG4VTM(INFO,__FUNCTION__<<" pos = "<<pos);
	LOG4VTM(INFO,__FUNCTION__<<" OK");
	return Error_Succeed;
}

std::string IDCerClassImpl::ForDataFormat(std::string str, std::string frm)
{
	if (str.empty())
	{
		return"";
	}
	str.erase(0, str.find_first_not_of(" "));
	str.erase(str.find_last_not_of(" ") + 1);
	const char *pData = str.c_str();
	if (pData == NULL)return"";
	std::string newStr = "";

	if (str.length() > 7)
	{

		std::string year(pData, 4);
		pData += 4;
		std::string mon(pData, 2);
		pData += 2;
		std::string data(pData, 2);

		if (frm == ".")
		{
			newStr = year + "." + mon + "." + data;
		}
		else
		{
			newStr = year + "年" + mon + "月" + data + "日";
		}
	}
	else
	{
		newStr = str;
	}
	return newStr;
}

std::string IDCerClassImpl::GetForeignTimeLimit(std::string time_, std::string format_)
{
	if (time_.length() < 8)return "";
	std::string year = time_.substr(0, 4);
	std::string yue = time_.substr(4, 2);
	std::string day = time_.substr(6, 2);
	std::string newData = year + format_ + yue + format_ + day;
	return newData;
}

std::string IDCerClassImpl::GeSoFilePath(void* Fun)   
{
    Dl_info dl_info;
    if(dladdr(Fun, &dl_info))
	{
		char *sFilePath = strdup(dl_info.dli_fname);
 		char *pName = strrchr(sFilePath, '/');
		*pName = '\0'; 
		std::string sPath(sFilePath);
		return sPath;
	}
	return "";
}

int IDCerClassImpl::GbkToUtf8(char *str_str, size_t src_len, char *dst_str, size_t dst_len)
{
	iconv_t cd;
	char **pin = &str_str;
	char **pout = &dst_str;

	cd = iconv_open("utf8", "gbk");
	if (cd == 0)
		return -1;
	memset(dst_str, 0, dst_len);
	if (iconv(cd, pin, &src_len, pout, &dst_len) == -1)
		return -1;
	iconv_close(cd);
	**pout = '\0';

	return 0;
}