myvtm/Module/mod_FingerPrint/FingerPrintFSM.cpp

#include "stdafx.h"
#include "FingerPrintFSM.h"
#include "EventCode.h"
#include "fileutil.h"

#ifdef RVC_OS_WIN
#include <map>
#include "RVCComm.h"
#include "publicFunExport.h"
#else
#include <cstdio>
#include <thread>
#include <chrono>
#include <fstream>
#include <sys/stat.h>
#include <unistd.h>
#endif
#include <winpr/synch.h>

#define FINGERPRINT_SCAN_TIMEOUT 15000
#define FINGERPRINT_GETFINGER_TIMEOUT 25000
#define FINGERPRINT_SCAN_INTERNAL 100
#define FINGERPRINT_MATCH_TIMEOUT 15000
#define MAX_FEATURE_LEN 1024
#define STANDARD_FEATURE_LEN 684

void CFingerPrintFSM::s0_on_entry()
{
	LOG_FUNCTION();
	SetDevState(DEVICE_STATUS_NORMAL);
	m_bCancelScan = false;
}

void CFingerPrintFSM::s0_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s0_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s0 evt %d", e->iEvt);
	switch(e->iEvt)
	{
		case USER_EVT_JS_GET_FINGERPRINT:
			{
				e->SetHandled();
				GetFingerPrintJSEvent* getFingerPrintEvt = dynamic_cast<GetFingerPrintJSEvent*>(e);
				GetFingerPrintJSTask* getFingerPrintTask = new GetFingerPrintJSTask(this);
				getFingerPrintTask->ctx = getFingerPrintEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(getFingerPrintTask);
			}
			break;
		case USER_EVT_JS_GENERATE_TEMPLATE:
			{
				e->SetHandled();
				GenerateTemplateJSEvent* gtEvt = dynamic_cast<GenerateTemplateJSEvent*>(e);
				GenerateTemplateJSTask* gtTask = new GenerateTemplateJSTask(this);
				gtTask->ctx = gtEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(gtTask);
			}
			break;
		case USER_EVT_JS_CANCEL_SCAN:
			{
				e->SetHandled();
				CancelScanJSEvent* pCSE = dynamic_cast<CancelScanJSEvent*>(e);
				//清理遗留的指纹文件
				if (m_fingerPrintFileSet.size() > 0) {
					DeleteRegisterFingerBmp();
				}
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("扫描取消成功");
				pCSE->ctx->Answer(Error_Succeed);
			}
			break;
		case EVT_MAINPAGE_DISPLAY:
			{
				e->SetHandled();
				//清理遗留的指纹文件
				if (m_fingerPrintFileSet.size() > 0) {
					DeleteRegisterFingerBmp();
				}
			}
			break;
		case USER_EVT_ERROR:
			{
				e->SetHandled();
			}
			break;
		case USER_EVT_QUIT:
			{
				e->SetHandled();
			}
			break;
		case USER_EVT_SCAN:
			{
				e->SetHandled();
				ScanEvent* pScanEvt = dynamic_cast<ScanEvent*>(e);
				ScanTask* pScanTask = new ScanTask(this);
				pScanTask->ctx = pScanEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pScanTask);
			}
			break;
		case USER_EVT_SCANEX:
			{
				e->SetHandled();
				ScanExEvent* pScanExEvt = dynamic_cast<ScanExEvent*>(e);
				ScanExTask* pScanExTask = new ScanExTask(this);
				pScanExTask->ctx = pScanExEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pScanExTask);
			}
			break;
		case USER_EVT_GETFINGER:
			{
				e->SetHandled();
				GetFingerEvent* getFingerEvt = dynamic_cast<GetFingerEvent*>(e);
				GetFingerTask* getFingerTask = new GetFingerTask(this);
				getFingerTask->ctx = getFingerEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(getFingerTask);
			}
			break;
		case USER_EVT_GENERATE_TEMPLATE:
			{
				e->SetHandled();
				GenerateTemplateEvent* gtEvt = dynamic_cast<GenerateTemplateEvent*>(e);
				GenerateTemplateTask* gtTask = new GenerateTemplateTask(this);
				gtTask->ctx = gtEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(gtTask);
			}
			break;
		case USER_EVT_CANCEL_SCAN:
			{
				e->SetHandled();
				m_bCancelRegister = true;
			}
			break;
		case USER_EVT_MATCH:
			{
				e->SetHandled();
				MatchEvent* pMatchEvt = dynamic_cast<MatchEvent*>(e);
				MatchTask* pMatchTask = new MatchTask(this);
				pMatchTask->ctx = pMatchEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pMatchTask);
			}
			break;
		case USER_EVT_FWB_OPEN_SUC_FINISHED:
			{
				e->SetHandled();
				return e->param1;
			}

		default:
			break;
	}
	return 0;
}

//Init
void CFingerPrintFSM::s4_on_entry()
{
	LOG_FUNCTION();
	SetDevState(DEVICE_STATUS_NOT_READY);
	InitTask* task = new InitTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}

void CFingerPrintFSM::s4_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s4_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s4 evt %d",pEvt->iEvt);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_ERROR:
		pEvt->SetHandled();
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_INIT_FINISHED:
		{
			pEvt->SetHandled();
			ret = pEvt->param1;
		}
		break;
	default:
		break;
	}
	return ret;
}


void CFingerPrintFSM::s1_on_entry()
{
	LOG_FUNCTION();
}

void CFingerPrintFSM::s1_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s1_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 evt(%d, %d)", e->iEvt, e->param1);
	int ret = 0;
	switch (e->iEvt)
	{
	case USER_EVT_JS_GET_FINGERPRINT_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_JS_GENERATE_TEMPLATE_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_JS_CANCEL_SCAN:
		{
			e->SetHandled();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("扫描取消成功");
			m_bCancelScan = true;
			CancelScanJSEvent* pCSE = dynamic_cast<CancelScanJSEvent*>(e);
			pCSE->ctx->Answer(Error_Succeed);
		}
		break;
	case EVT_MAINPAGE_DISPLAY:
		e->SetHandled();
		m_bCancelScan = true;
		break;
	case USER_EVT_SCAN_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_SCANEX_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_GETFINGER_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_GENERATE_TEMPLATE_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_CANCEL_SCAN:
		e->SetHandled();
		m_bCancelRegister = true;
		break;
	case USER_EVT_EXIT:
		e->SetHandled();
		m_bExit = true;
		break;
	case USER_EVT_QUIT:
		e->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

void CFingerPrintFSM::s2_on_entry()
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FingerPrint entity failed.");
	SetDevState(DEVICE_STATUS_FAULT);
	m_testResult = Error_InvalidState;
}

void CFingerPrintFSM::s2_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s2_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s2 evt %d",e->iEvt);
	switch (e->iEvt)
	{
	case USER_EVT_QUIT:
		e->SetHandled();
		break;
	case USER_EVT_FWB_OPEN_SUC_FINISHED:
		{
			e->SetHandled();
			return e->param1;
		}
	}
	return 0;
}

void CFingerPrintFSM::s3_on_entry()
{
	LOG_FUNCTION();
}

void CFingerPrintFSM::s3_on_exit()
{
	LOG_FUNCTION();
}

unsigned CFingerPrintFSM::s3_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s3 evt %d,%d", e->iEvt, e->param1);

	switch (e->iEvt)
	{
	case USER_EVT_MATCH_FINISHED:
		{
			e->SetHandled();
			MatchFinishedEvent* matchFinishEvt = dynamic_cast<MatchFinishedEvent*>(e);
			if (matchFinishEvt->param1 == 0)
				matchFinishEvt->ctx->Answer(Error_Succeed);
			else
				matchFinishEvt->ctx->Answer((ErrorCodeEnum)matchFinishEvt->param1);
		}
		break;
	case USER_EVT_CANCEL_MATCH:
		{
			e->SetHandled();
			m_bCancelMatch = true;
		}
		break;
	case USER_EVT_EXIT:
		{
			e->SetHandled();
			m_bExit = true;
		}
		break;
	case USER_EVT_QUIT:
		{
			e->SetHandled();		
		}
		break;
	default:
		break;
	}
	return 0;
}

#pragma region entity init

ErrorCodeEnum CFingerPrintFSM::OnInit()
{
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->LoadVendorLibName();
	return Error_Succeed;
}

int CFingerPrintFSM::Initial()
{
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	SetDevInitFlag(false);
	if (pEntity->vendorLibInfo.IsNotConfig()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("没有配置，将其视为指纹仪设备打开成功");
		return 0;
	}
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	//LogWarn(Severity_Low, Error_Unexpect, FingerPrint_UserErrorCode_ROOT_INFO, m_adapterInfo.adapterFilePath.GetData());
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(m_adapterInfo.adapterFilePath.GetData());
	pEntity->InitializeVendorLogSwitch();
	ErrorCodeEnum err = LoadUpAdapterLibrary();
	if (!IS_SUCCEED(err))
	{
		if (err != Error_NotExist) { //文件存在，只是因为其他原因导致加载失败的
			//2024-12-10：4275780002, 1225300001 两台终端存在该情况
			LogWarn(Severity_High, Error_NotInit, FingerPrint_UserErrorCode_LOAD_ADAPTER_FAILED,
				CSimpleStringA::Format("Load library file: %s failed, GLE=%d", (LPCTSTR)m_adapterInfo.adapterFileName, GetLastError()));
			
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Open_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_LOAD_ADAPTER_FAILED))("加载厂商适配器失败");
			return 2;
		}
		else {
			//2024年12月10日：7555870003 5715350008 两台终端存在该情况
			LogWarn(Severity_High, Error_DevLoadFileFailed, FingerPrint_UserErrorCode_VENDOR_ADAPTER_NOT_EXIST,
				CSimpleStringA::Format("library file: %s is not existed!", (LPCTSTR)m_adapterInfo.adapterFileName));
			
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Open_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_VENDOR_ADAPTER_NOT_EXIST))("厂商适配器不存在dep中");
			return 2;
		}

	}
	ULLINT l_beginTime, l_endTime;
	do
	{
		l_beginTime = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->DevOpen(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		l_endTime = SP::Module::Comm::RVCGetTickCount();
		if (err != Error_Succeed)
		{
			CSimpleStringA addMsg = CSimpleStringA::Format("Initial::DevOpen fail port: %d, baudrate: %d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
			CSimpleStringA contxtStr = CSimpleStringA::Format("{\"addition\": \"%s\"}", addMsg.GetData());
			SetErrorAndLog(err, MEC_DEVAPI_FINGERPRINT_DevOpen, "DevAdapter::DevOpen", __FUNCTION__, false, l_endTime - l_beginTime, "", contxtStr.GetData());

			m_hDevHelper.TearDown();
			return 2;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(l_endTime - l_beginTime)("Initial::DevOpen  port: %d, baudrate: %d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		}
		SetDevInitFlag();
	} while (false);
	ZeroMemory(m_devCatInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(m_devCatInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(m_devCatInfo.szVendor, MAX_DEV_VENDOR_LEN);

	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	err = m_hDevHelper->GetDevCategory(m_devCatInfo);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	
	if (err != Error_Succeed) {
		SetErrorAndLog(err, MEC_DEVAPI_FINGERPRINT_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		m_hDevHelper.TearDown();
		return 2;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime)("Initial::GetDevCategory");
	}
	m_adapterInfo.FulfillCategoryInfo(m_devCatInfo);
	SetDevInitFlag();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("指纹仪设备打开成功");
	return 0;
}

#pragma endregion

#pragma region entity exit

ErrorCodeEnum CFingerPrintFSM::OnExit()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("This is normal device.");
	if (m_hDevHelper != nullptr)
	{
		m_hDevHelper.TearDown();
		SetDevInitFlag(false);
	}
	return Error_Succeed;
}

#pragma endregion

void CFingerPrintFSM::SelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(m_testResult);
}

int CFingerPrintFSM::GetFingerPrintJS(SpReqAnsContext<FingerPrintService_GetFingerPrintJS_Req, FingerPrintService_GetFingerPrintJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	CSimpleStringA strPath;//指纹图片路径
	eErr = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_MATCH, "GetFingerPrintJS::Get dep Path is fail");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_MATCH))("GetFingerPrintJS::Get dep Path is fail");
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_MATCH);//RTA2424
		return 0;
	}

	int scanTimeOut = 0;
	if (ctx->Req.scanTimeOut > 0) {
		scanTimeOut = ctx->Req.scanTimeOut*1000;
	}
	else {
		CSimpleStringA errMsg = CSimpleStringA::Format("GetFingerPrintJS::Param is error,scanTimeOut[%d] is invalid", ctx->Req.scanTimeOut);
		LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GET_FINGERPRINT_PARAM_FAIL, errMsg.GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GET_FINGERPRINT_PARAM_FAIL))("GetFingerPrintJS::Param is error,scanTimeOut[%d] is invalid", ctx->Req.scanTimeOut);
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GET_FINGERPRINT_PARAM_FAIL);//RTA242F
		return 0;
	}

	bool bIsRegister = false;//判定是否注册
	bIsRegister = (ctx->Req.fingerSN == 0) ? false : true;

	//循环扫描

	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	memset(lpbFeature, 0, sizeof(lpbFeature));
	int lpbLength = MAX_FEATURE_LEN;

	CSimpleStringA fileName = CSimpleStringA::Format("finger%d.bmp", ctx->Req.fingerSN);
	strPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName.GetData());//图片位置

	DeleteFingerBmp(strPath);
	
	bool bGetFingerPrintSuc = false;
	bool bNotFindImage = false;
	bool bLenIsNotRight = false;
	bool bFeatureIsNull = false;
	bool bExit = false;
	bool bTimeOut = true;
	ULLINT l_beginTime, l_endTime;
	ULLINT elapsed = 0;
	ULONGLONG dwStart = SP::Module::Comm::RVCGetTickCount();
	ULONGLONG dwEnd = SP::Module::Comm::RVCGetTickCount();


	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");
	while (elapsed < scanTimeOut && !bGetFingerPrintSuc)
	{
		if (m_bExit) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Exit the process.");
			bTimeOut = false;
			bExit = true;
			break;
		}
		if (m_bCancelScan) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("CancelScan the process.");
			bTimeOut = false;
			break;
		}

		Sleep(FINGERPRINT_SCAN_INTERNAL);

		lpbLength = MAX_FEATURE_LEN;
		l_beginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
		l_endTime = SP::Module::Comm::RVCGetTickCount();
		if (eErr == Error_Succeed) {
			UpdateAndWarnFileFindInDepBak(strPath, fileName, FingerPrint_UserErrorCode_FindFile_in_DepBak);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("GetFingerPrint::Image2Feature succ ,strPath:%s, lpbLength:%d", strPath.GetData(), lpbLength);

			Sleep(200);

			if (!ExistsFile(strPath)) {
				//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, Cannot find the fingerprint image %s", strPath.GetData());
				bNotFindImage = true;
				bTimeOut = false;
				break;
			}
			else if(lpbLength != STANDARD_FEATURE_LEN) {
				//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, vendor returned feature length is not right.");
				bTimeOut = false;
				bLenIsNotRight = true;
				break;
			}
			else if (lpbFeature == NULL) {
				//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, Fingerprint feature is NULL.");
				bTimeOut = false;
				bFeatureIsNull = true;
				break;
			}else {
				//成功
				lpbFeature[STANDARD_FEATURE_LEN] = '\0';
				ctx->Ans.feature = (LPCTSTR)lpbFeature;
				bGetFingerPrintSuc = true;
				bTimeOut = false;
				break;
			}

		}

		dwEnd = SP::Module::Comm::RVCGetTickCount();
		elapsed = dwEnd - dwStart;
	}
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, CSimpleStringA::Format("FingerPrint warning off,elapse = %d", elapsed));

	//if (bGetFingerPrintSuc && bIsRegister) {
	//	//临时注册的文件进行缓存
	//	m_fingerPrintFileSet.insert(strPath);
	//}

	if (m_bCancelScan || bExit) {
		//主动取消
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_CANCEL_SCAN))("指纹扫描失败,扫描已取消");
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_CANCEL_SCAN);//RTA2426
	}
	else if (bGetFingerPrintSuc) {
		//成功
		CBlob data;
		ErrorCodeEnum imgErrCode = GetImgBlob(data, strPath);
		if (imgErrCode != Error_Succeed){	
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GET_FINGERBLOB_FAIL))("Failed to load image(%s)", strPath.GetData());
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GET_FINGERBLOB_FAIL);//RTA242A
		}
		else {
			ctx->Ans.fingerImg = data;
			ctx->Ans.fingerImgLen = data.m_iLength;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID)("指纹仪扫描成功");
			ctx->Answer(Error_Succeed);
		}
	}
	else if(bTimeOut){
		//超时
		CSimpleStringA addMsg = CSimpleStringA::Format("Invoke routine 'Image2Feature' timeout, fileName:%s, lpbLength:%d failed while GetFingerPrint.", fileName.GetData(), lpbLength);
		CSimpleStringA contxtStr = CSimpleStringA::Format("{\"addition\": \"%s\"}", addMsg.GetData());
		SetErrorAndLog(eErr, MEC_DEVAPI_FINGERPRINT_Image2Feature, "DevAdapter::Image2Feature", __FUNCTION__, false, l_endTime - l_beginTime, FingerPrint_Scan_ID, contxtStr.GetData());
		
		LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_Match_Timeout, "GetFingerPrint timeout");
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_Match_Timeout);//RTA2411
	}
	else {
		if (bNotFindImage) {
			//未发现文件
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH, "not find fingerprint image in dep while match");
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH))("<GetFingerPrint>, Cannot find the fingerprint image %s", strPath.GetData());
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH);//RTA2416
			
		}
		else if (bLenIsNotRight) {
			//长度不对
			LogWarn(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH, "fingerprint feature len is not right while match");
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH))("指纹扫描失败,返回的指纹特征长度错误");
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH);//RTA2413
			
		}
		else if (bFeatureIsNull) {
			//长度为空
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH, "fingerprint feature is null");
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH))("指纹扫描失败,采集接口调用成功，但返回的特征值为空");
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH);//RTA2414
		
		}
	}

	//清理非注册的指纹文件
	if (!bIsRegister) {
		DeleteFingerBmp(strPath);
	}
	else {
		//临时注册的文件进行缓存
		insertRegisterFingerBmp(strPath);
	}

	//主动和异常退出清理之前的缓存指纹文件
	if (m_bCancelScan || bExit) {
		DeleteRegisterFingerBmp();
	}

	delete[] lpbFeature;
	lpbFeature = NULL;
	return 0;

}

int CFingerPrintFSM::GenerateTemplateJS(SpReqAnsContext<FingerPrintService_GenerateTemplateJS_Req, FingerPrintService_GenerateTemplateJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	
	std::vector<CSimpleStringA> imagePaths;
	CSimpleStringA strPath;
	m_pEntity->GetFunction()->GetPath("Dep", strPath);

	//主动和异常退出清理之前的缓存指纹文件
	if (m_bCancelScan || m_bExit) {		
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_CANCEL_GETTEMPLATE))("指纹模版生成失败,已取消");
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_CANCEL_GETTEMPLATE);//RTA2427
		DeleteRegisterFingerBmp();
		return 0;
	}

	if (ctx->Req.fingerSNList.GetCount() != 3) {	
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GETTEMPLATE_PARAM_FAIL))("指纹模版生成失败，输入参数错误");
		ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GETTEMPLATE_PARAM_FAIL);//RTA242B
		DeleteRegisterFingerBmp();
		return 0;
	}

	for (int i = 0; i < ctx->Req.fingerSNList.GetCount(); ++i)
	{
		CSimpleStringA tempStr = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "finger%d.bmp", strPath.GetData(), ctx->Req.fingerSNList[i]);

		UpdateAndWarnFileFindInDepBak(tempStr, CSimpleStringA::Format("finger%d.bmp", ctx->Req.fingerSNList[i]), FingerPrint_UserErrorCode_FindFile_in_DepBak);

		if (!ExistsFileA(tempStr.GetData()))
		{
			CSimpleStringA errMsg = CSimpleStringA::Format("<GenerateTemplateJS>, image <%s> not exist.", tempStr.GetData());
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_GETTEMPLATE_NO_FILE, errMsg.GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GETTEMPLATE_NO_FILE))("指纹模版生成失败，指纹图片不存在");
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GETTEMPLATE_NO_FILE);//RTA242C
			DeleteRegisterFingerBmp();
			return 0;
		}
		else {
			imagePaths.push_back(tempStr);
			insertRegisterFingerBmp(tempStr);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<GenerateTemplateJS>,imagePaths[%d]=%s", i, tempStr.GetData());
		}
		
	}
	

	ErrorCodeEnum errCode;
	LPBYTE lpbTemplate = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->Image2Template(imagePaths[0], imagePaths[1], imagePaths[2], lpbTemplate, lpbLength);
	l_endTime = SP::Module::Comm::RVCGetTickCount();

	DWORD dwTmpUserErrCode = 0;
	if (Error_Succeed == errCode)
	{
		if (lpbTemplate != NULL && lpbLength == STANDARD_FEATURE_LEN) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::Image2Template").setLogCode(FingerPrint_Generate_Template_ID).setCostTime(l_endTime - l_beginTime)("指纹仪模板生成成功 , template length is %d", lpbLength);
			lpbTemplate[lpbLength] = '\0';
			ctx->Ans.templateFeature = (LPCTSTR)lpbTemplate;
		}
		else {
			CSimpleStringA errMsg = CSimpleStringA::Format("template is NULL or template length is not right(%d)", lpbLength);
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_TEMPLATELEN_ISNOTRIGHT, errMsg.GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::Image2Template").setLogCode(FingerPrint_Generate_Template_ID).setCostTime(l_endTime - l_beginTime).setResultCode(getRTACode(FingerPrint_UserErrorCode_TEMPLATELEN_ISNOTRIGHT))("指纹仪模板生成失败,%s", errMsg.GetData());
			dwTmpUserErrCode = FingerPrint_UserErrorCode_TEMPLATELEN_ISNOTRIGHT;//RTA2428
			errCode = Error_Unexpect;
		}
	}
	else {
		dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_FINGERPRINT_Image2Template, "DevAdapter::Image2Template", __FUNCTION__, false, l_endTime - l_beginTime, "", "指纹仪模板生成失败");//RTA2418
		errCode = Error_Unexpect;
	}

	DeleteRegisterFingerBmp();

	if (errCode == Error_Succeed) {
		ctx->Answer(Error_Succeed);
	}
	else {
		ctx->Answer(errCode, dwTmpUserErrCode);
	}

	delete[] lpbTemplate;
	lpbTemplate = NULL;

	return 0;
}

ErrorCodeEnum CFingerPrintFSM::GetImgBlob(CBlob& data, CSimpleStringA imgPath)
{
	ErrorCodeEnum eErr;
	FILE* fp = fopen(imgPath, "rb");
	if (fp) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetImgBlob %s succeed", imgPath.GetData());
		fseek(fp, 0, SEEK_END);
		long flen = ftell(fp);
		fseek(fp, 0, SEEK_SET);
		data.Alloc(flen);
		fread(data.m_pData, 1, flen, fp);
		fclose(fp);
		eErr = Error_Succeed;
	}
	else {
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetImgBlob %s failed!", imgPath.GetData());
		eErr = Error_IO;
	}
	return eErr;
}

#pragma region register interface - not use anymore in uos


#pragma endregion

#pragma region register interface - not use anymore in uos


#pragma endregion

#pragma region collect finger for register and match interface
//有用接口
int CFingerPrintFSM::GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Ans.reserved1.Init(1);
	if(!m_bOpened) {
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2422")("GetFingerPrint return failed for device isn't init suc.");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_DEVOPENFAILED_GETFINGERPRINT))("GetFingerPrint return failed for device isn't init suc.");
		ctx->Answer(Error_NotInit, FingerPrint_UserErrorCode_DEVOPENFAILED_GETFINGERPRINT);  //maybe no vendor adapter
		return 0;
	}

	if (m_bCancelRegister) //no cancel button anymore while register
	{   //修复当扫描前已取消，需要把参数复制，否则授权实体会lost
		m_bCancelRegister = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹扫描失败,在扫描前,扫描已取消");
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Cancel);
		return 0;


	}
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("ctx->Req.times = %d", ctx->Req.times);
	//times = 10, for QueryAuthorInfo; 1-9, for Register
	if (ctx->Req.times <= 0 || ctx->Req.times > 10)
	{
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2423")("GetFingerPrint return fail, inParam is invalid:%d", ctx->Req.times);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_PARAMFAILED_GETFINGERPRINT))("GetFingerPrint return fail, inParam is invalid:%d", ctx->Req.times);
		ctx->Answer(Error_Param, FingerPrint_UserErrorCode_PARAMFAILED_GETFINGERPRINT);
		return 0;
	}

	DWORD elapsed = 0;
	DWORD dwStart = SP::Module::Comm::RVCGetTickCount();
	DWORD dwEnd = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErr;
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	memset(lpbFeature, 0, sizeof(lpbFeature));
	int lpbLength = MAX_FEATURE_LEN;
	

	CSimpleStringA strPath;
	eErr = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	if(eErr != Error_Succeed)
	{
		delete[] lpbFeature;
		lpbFeature = NULL;
		
		LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_MATCH, "GetFingerPrint::GetPath is fail");
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2424")("GetFingerPrint::GetPath is fail");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_MATCH))("GetFingerPrint::GetPath is fail");
		ctx->Answer(Error_Param);
		return 0;
	}

	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");
	m_bCancelRegister = false;

	CSimpleStringA fileName = CSimpleStringA::Format("finger%d.bmp", ctx->Req.times);
	strPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName.GetData());
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("<GetFingerPrint> imageName = %s", strPath.GetData());

	bool bGetFingerPrintSuc = false;
	bool bNotFindImage = false;
	bool bLenIsNotRight = false;
	bool bFeatureIsNull = false;
	bool bExit = false;
	ULLINT l_beginTime, l_endTime;
	
	while(elapsed < FINGERPRINT_GETFINGER_TIMEOUT && !m_bCancelRegister && !bGetFingerPrintSuc)
	{
		if (m_bExit)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Exit the process.");
			bExit = true;
			break;
		}
		Sleep(FINGERPRINT_SCAN_INTERNAL);
		lpbLength = MAX_FEATURE_LEN;
		l_beginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
		l_endTime = SP::Module::Comm::RVCGetTickCount();
		
		
		if (eErr == Error_Succeed)
		{
			UpdateAndWarnFileFindInDepBak(strPath, fileName, FingerPrint_UserErrorCode_FindFile_in_DepBak);

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("GetFingerPrint::Image2Feature succ ,fileName:%s, lpbLength:%d", fileName.GetData(), lpbLength);
			Sleep(200);//save image may be delayed some time, not must happen
			if (ExistsFileA(strPath)) {
				if (lpbFeature != NULL && lpbLength == STANDARD_FEATURE_LEN) {
					ctx->Ans.imageName = fileName;
					lpbFeature[STANDARD_FEATURE_LEN] = '\0';
					ctx->Ans.feature = (LPCTSTR)lpbFeature;
					bGetFingerPrintSuc = true;
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Image2Feature success.");
					break;
				}
				else if (lpbLength != STANDARD_FEATURE_LEN) {
					//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, vendor returned feature length is not right.");
					bLenIsNotRight = true;
					break;
				}
				else {
					//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, Fingerprint feature is NULL.");
					bFeatureIsNull = true;
					break;
				}
			} else {
				//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("<GetFingerPrint>, Cannot find the fingerprint image %s", fileName.GetData());
				bNotFindImage = true;
				break;
			}
		}
		dwEnd = SP::Module::Comm::RVCGetTickCount();
		elapsed = dwEnd - dwStart;
	}

	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, CSimpleStringA::Format("FingerPrint warning off,elapse = %d",elapsed));
	m_bExit = false;

	bool bIsRegister = false;
	bIsRegister = (ctx->Req.times == 10) ? false : true;

	if (bGetFingerPrintSuc){
		ctx->Ans.reserved1[0] = 1;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID)("指纹仪扫描成功");
		ctx->Answer(Error_Succeed);
	}
	else if(m_bCancelRegister){
		m_bCancelRegister = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹扫描失败,扫描已取消");
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Succeed);
	}
	else if(elapsed >= FINGERPRINT_SCAN_TIMEOUT){

		CSimpleStringA addMsg = CSimpleStringA::Format("Invoke routine 'Image2Feature' timeout, fileName:%s, lpbLength:%d failed while GetFingerPrint.", fileName.GetData(), lpbLength);
		CSimpleStringA contxtStr = CSimpleStringA::Format("{\"addition\": \"%s\"}", addMsg.GetData());
		SetErrorAndLog(eErr, MEC_DEVAPI_FINGERPRINT_Image2Feature, "DevAdapter::Image2Feature", __FUNCTION__, false, l_endTime - l_beginTime, FingerPrint_Scan_ID, contxtStr.GetData());

		m_bCancelRegister = false;
		ctx->Ans.reserved1[0] = 2;
		if (bIsRegister) {
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_Registe_Timeout, "register timeout");
		}else {
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_Match_Timeout, "match timeout");
		}
		ctx->Answer(Error_Succeed);
	}
	else{
		if(bNotFindImage){
			ctx->Ans.reserved1[0] = 7;
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH, "not find fingerprint image in dep while match");
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH))("指纹扫描失败,采集接口调用成功，但未在dep中找到图片文件");
		}else if(bFeatureIsNull){
			ctx->Ans.reserved1[0] = 4;
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH, "fingerprint feature is null while match");
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH))("指纹扫描失败,采集接口调用成功，但返回的特征值为空");
		}else if(bLenIsNotRight){
			ctx->Ans.reserved1[0] = 5;
			LogWarn(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH, "fingerprint feature len is not right while match");
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH))("指纹扫描失败,返回的指纹特征长度错误");
		}else if(bExit){
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_REGISTER_FAILED, "Exit to homepage when register.");
			ctx->Ans.reserved1[0] = 6;
			ctx->Answer(Error_Succeed);
		}
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return 0;
}

#pragma endregion

#pragma region generate template
//有用接口
int CFingerPrintFSM::GenerateTemplate(SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	
	if(!m_bOpened) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode("RTA2425")("GenerateTemplate return failed for device isn't init suc.");
		ctx->Answer(Error_NotInit, FingerPrint_UserErrorCode_DEVOPENFAILED_GenerateTemplate);  //maybe no vendor adapter
		return 0;
	}

	if (m_bCancelRegister) //no cancel button anymore while register
	{
		ctx->Answer(Error_Cancel);
		m_bCancelRegister = false;
		return 0;
	}

	ErrorCodeEnum errCode;
	LPBYTE lpbTemplate = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;

	std::vector<CSimpleStringA> imagePaths;
	CSimpleStringA strPath;
	m_pEntity->GetFunction()->GetPath("Dep", strPath);

	for (int i = 0; i < ctx->Req.FingerIDList.GetCount(); ++i)
	{
		CSimpleStringA tempStr = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "finger%d.bmp", strPath.GetData(), ctx->Req.FingerIDList[i]);

		UpdateAndWarnFileFindInDepBak(tempStr, CSimpleStringA::Format("finger%d.bmp", ctx->Req.FingerIDList[i]), FingerPrint_UserErrorCode_FindFile_in_DepBak);

		imagePaths.push_back(tempStr);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("imageName:%s", imagePaths[i].GetData());
		if (!ExistsFileA(imagePaths[i])) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode("RTA242C")("<GenerateTemplate>, image <%s> not exist.", imagePaths[i].GetData());
			DeleteBmp(BmpImage);
			ctx->Answer(Error_NoTarget);
			return 0;
		}
	}

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->Image2Template(imagePaths[0], imagePaths[1], imagePaths[2], lpbTemplate, lpbLength);
	l_endTime = SP::Module::Comm::RVCGetTickCount();

	if (Error_Succeed == errCode)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::Image2Template").setCostTime(l_endTime - l_beginTime)("Invoke routine 'Image2Template' success , template length is %d", lpbLength);
		if (lpbTemplate != NULL && lpbLength == STANDARD_FEATURE_LEN) {
			lpbTemplate[lpbLength] = '\0';
			ctx->Ans.templateFeature = (LPCTSTR)lpbTemplate;
		}
		else {
			CSimpleStringA errMsg = CSimpleStringA::Format("template is NULL or template length is not right(%d)", lpbLength);
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT, errMsg.GetData());
			errCode = Error_Unexpect;
		}
	}
	else {
		SetErrorAndLog(errCode, MEC_DEVAPI_FINGERPRINT_Image2Template, "DevAdapter::Image2Template", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		errCode = Error_Unexpect;
	}

	DeleteBmp(BmpImage);
	if (errCode == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID)("指纹仪模板生成成功");
		ctx->Answer(Error_Succeed);
	}
	else {
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode("RTA2419")("指纹仪模板生成失败");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID).setResultCode(getRTACode(FingerPrint_UserErrorCode_GETTEMPLATE_FAILED))("指纹仪模板生成失败");
		ctx->Answer(errCode, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
	}

	delete[] lpbTemplate;
	lpbTemplate = NULL;
	return 0;
}

#pragma endregion

#pragma region match - old interface


#pragma endregion

#pragma region common function

ErrorCodeEnum CFingerPrintFSM::GetDevCatInfo(DevCategoryInfo& devInfo)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("DevCatgoryInfo len:%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), strlen(m_devCatInfo.szVendor));
	strncpy(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN > strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN - 1);
	strncpy(devInfo.szType, m_devCatInfo.szType, (MAX_DEV_TYPE_LEN > strlen(m_devCatInfo.szType)) ? strlen(m_devCatInfo.szType) : MAX_DEV_TYPE_LEN - 1);
	strncpy(devInfo.szVendor, m_devCatInfo.szVendor, (MAX_DEV_VENDOR_LEN > strlen(m_devCatInfo.szVendor)) ? strlen(m_devCatInfo.szVendor) : MAX_DEV_VENDOR_LEN - 1);
	return Error_Succeed;
}

ErrorCodeEnum CFingerPrintFSM::GetCurDevState(int& state)
{
	ErrorCodeEnum errCode;
	state = 0;
	if (!m_bOpened) {
		return Error_Succeed;
	}
	CSimpleStringA fileName = "testFinger.bmp";
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;
	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("GetDevState:%d",state);

	if (errCode == Error_Succeed)
	{
		state = 1;
		DeleteBmp(TestImage);
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return Error_Succeed;
}

void CFingerPrintFSM::DeleteBmp(int type)
{
	if ((type & BmpImage) == BmpImage)
	{
		CSimpleStringA imageName;
		DeleteFileIfExisted("finger.bmp");
		for (int i = 1; i <= 10; ++i) {
			imageName = CSimpleString::Format("finger%d.bmp", i);
			DeleteFileIfExisted(imageName.GetData());
		}
	}
	if ((type & TestImage) == TestImage)
	{
		DeleteFileIfExisted("testFinger.bmp");
	}
}

ErrorCodeEnum CFingerPrintFSM::DeleteFingerBmp(CSimpleStringA imgPath)
{
	if (ExistsFileA(imgPath))
	{
		if (RemoveFileA(imgPath))
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", imgPath.GetData());
			return Error_Succeed;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA242G")("DeleteFile(%s) failed LastError(%d).", imgPath.GetData(), errno);
			return Error_Unexpect;
		}
	}
	else {
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", imgPath);
		return Error_Succeed;
	}
}

ErrorCodeEnum CFingerPrintFSM::DeleteRegisterFingerBmp()
{
	m_fingerfileMtx.lock();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("execute DeleteRegisterFinger begin,imgPathSet count: %d", m_fingerPrintFileSet.size());
	auto it = m_fingerPrintFileSet.begin();
	while (it != m_fingerPrintFileSet.end()) {
		CSimpleStringA imgPath = *it;
		if (ExistsFileA(imgPath))
		{
			if (RemoveFileA(imgPath))
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", imgPath.GetData());
				it = m_fingerPrintFileSet.erase(it);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA242G")("DeleteFile(%s) failed LastError(%d).", imgPath.GetData(), errno);
				m_fingerfileMtx.unlock();
				return Error_Unexpect;
			}
		}
		else {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", imgPath);
			it = m_fingerPrintFileSet.erase(it);
		}
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("execute DeleteRegisterFinger after,imgPathSet count: %d", m_fingerPrintFileSet.size());
	m_fingerfileMtx.unlock();
	return Error_Succeed;
}

void CFingerPrintFSM::insertRegisterFingerBmp(CSimpleStringA bmpPath)
{
	m_fingerfileMtx.lock();
	m_fingerPrintFileSet.insert(bmpPath);
	m_fingerfileMtx.unlock();
}

DWORD CFingerPrintFSM::GetFsmStateErrCode()
{
	CSimpleStringA currStateName = GetCurrStateName();

	if (currStateName.Compare("Normal") == 0) {
		return FingerPrint_UserErrorCode_PROCESS_NORMAL;
	}
	else if (currStateName.Compare("Scan") == 0) {
		return FingerPrint_UserErrorCode_PROCESS_SCAN;
	}
	else if (currStateName.Compare("Fail") == 0) {
		return FingerPrint_UserErrorCode_PROCESS_FAIL;
	}
	else  if (currStateName.Compare("Init") == 0) {
		return FingerPrint_UserErrorCode_PROCESS_INIT;
	}
	else {
		return FingerPrint_UserErrorCode_PROCESS_CANNOT_PROCESS;
	}
}

ErrorCodeEnum CFingerPrintFSM::DeleteFileIfExisted(const char* fileName)
{
	if (strlen(fileName) == 0 || strchr(fileName, (int)'*') != NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA242G")("Invalid or empty filename(%s)", fileName);
		return Error_Param;
	}
	CSimpleStringA strPath, strOldPath, strObjPath;
	ErrorCodeEnum errCode = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	strObjPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName);

	UpdateAndWarnFileFindInDepBak(strObjPath, fileName, FingerPrint_UserErrorCode_FindFile_in_DepBak);
	if (ExistsFileA(strObjPath))
	{
		if (RemoveFileA(strObjPath))
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA242G")("DeleteFile(%s) failed LastError(%d).", strObjPath.GetData(), errno);
			return Error_Unexpect;
		}
	}
	else {
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", fileName);
		return Error_Succeed;
	}
}

#pragma endregion