myvtm/Module/mod_FingerPrint/FingerPrintFSM.cpp

#include "FingerPrintFSM.h"
#include "EventCode.h"
#include "FingerPrint_UserErrorCode.h"
#include "GetDevInfoHelper.h"

#include <cstdio>
#include <thread>
#include <chrono>
#include <fstream>

#ifdef RVC_OS_LINUX
#include <sys/stat.h>
#include <unistd.h>
#endif // RVC_OS_LIUNX

using namespace SP::Module::Comm;

#define FINGERPRINT_SCAN_TIMEOUT 15000
#define FINGERPRINT_SCAN_INTERNAL 100
#define FINGERPRINT_MATCH_TIMEOUT 15000
#define MAX_FEATURE_LEN 1024

#pragma region event response

void CFingerPrintFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_devState = DEVICE_STATUS_NORMAL;
}

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

unsigned int CFingerPrintFSM::s0_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	Dbg("s0 evt %d", e->iEvt);

	switch (e->iEvt)
	{
	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_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;
	}
	default:
		break;
	}
	return 0;
}

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

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

unsigned int CFingerPrintFSM::s1_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	Dbg("s1 evt(%d)", e->iEvt);

	int ret = 0;
	switch (e->iEvt)
	{
	case USER_EVT_SCAN_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();
	m_devState = DEVICE_STATUS_FAULT;
	m_testResult = Error_InvalidState;
}

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

unsigned int CFingerPrintFSM::s2_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	if (e->iEvt == USER_EVT_QUIT)
	{
		e->SetHandled();
	}
	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();
	Dbg("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 endregion

#pragma region entity init

ErrorCodeEnum CFingerPrintFSM::OnInit()
{
	LOG_FUNCTION();

	ErrorCodeEnum errDev;
	CSimpleStringA strLibFullPath(true);
	errDev = ExtractVendorLib(strLibFullPath);
	if (errDev != Error_Succeed)
		return errDev;

	CSmartPointer<IConfigInfo> spConfig;
	errDev = QueryRootConfigObj(spConfig);

	if (Error_Succeed != errDev)
		return errDev;

	if (strLibFullPath.IsEndWith("FingerPrint.dll")
		|| strLibFullPath.IsEndWith("libFingerPrint.so"))
	{
		Dbg("No config in root.ini for FingerPrint.");
		GetVendorLibName(spConfig, strLibFullPath);
	}
	Dbg("vendorlib name: %s", strLibFullPath.GetData());

	if(!ExistsFile(strLibFullPath))
	{
		Dbg("No vendor fingerprint adapter in dep.");
		m_devInit = false;
		return Error_Succeed;
	}
	
	errDev = m_hDevHelper.LoadUp(strLibFullPath);
	if (Error_Succeed != errDev)
	{
		Dbg("load vendorlib or create DevAdapterObject failed.");
		return Error_DevLoadFileFailed;
	}

	errDev = DoDevOpen(spConfig);
	if (Error_Succeed != errDev)
		return errDev;

	return DoGetDevInfo();
}

ErrorCodeEnum CFingerPrintFSM::ExtractVendorLib(CSimpleStringA& strLibFullPath)
{
	ErrorCodeEnum errCode = Error_Succeed;

	CDevAdptEntityBase* pEntity = GET_DEV_ENTITY_BASE_POINTER();
	errCode = pEntity->ExtractVendorLibFullPath(strLibFullPath);
	Dbg("Extract Vendor lib name: %s", strLibFullPath.GetData());

	if (errCode != Error_Succeed)
	{
		Dbg("Get vendor libname(%s) failed.", strLibFullPath.GetData());
		LogError(Severity_High, Error_DevLoadFileFailed
			, LOG_ERR_FINGERPRINT_GET_DLLNAME_FAILED_ONINIT
			, "get dllname failed while init");
		errCode = Error_DevLoadFileFailed;
	}

	return errCode;
}

ErrorCodeEnum CFingerPrintFSM::QueryRootConfigObj(CSmartPointer<IConfigInfo>& spConfig)
{
	ErrorCodeEnum errDev = Error_Succeed;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	errDev = spEntityFunction->OpenConfig(Config_Root, spConfig);

	if (errDev != Error_Succeed)
	{
		Dbg("open cfg file failed!");
		LogError(Severity_High, Error_DevLoadFileFailed
				, LOG_ERR_FINGERPRINT_OPEN_ROOT_FAILED_ONINIT
				, "get root config file pointer failed while init");
	}

	return errDev;
}

ErrorCodeEnum CFingerPrintFSM::DoDevOpen(CSmartPointer<IConfigInfo> spConfig)
{
	ErrorCodeEnum errDev = Error_Succeed;

	do
	{
		int tmpPort = 0;
		int baudrate = 0;
		CSimpleStringA tmpVendor(true);
		spConfig->ReadConfigValueInt("Device.FingerPrint", "Port", tmpPort);
		spConfig->ReadConfigValueInt("Device.FingerPrint", "Baudrate", baudrate);
		Dbg("port: %d, baudrate: %d", tmpPort, baudrate);

		if (IsFWBDevice(tmpVendor))
		{
			errDev = CheckCardSwiperStatus();
			if (Error_Succeed != errDev)
			{
				Dbg("this is FWB, device status is not normal now.(%s)", SpStrError(errDev));
				errDev = Error_DevCommFailed;
				break;
			}
			else {
				Dbg("this is FWB, device status is normal now.");
			}
		}

		errDev = m_hDevHelper->DevOpen(tmpPort, baudrate);
		if (errDev != Error_Succeed)
		{
			WORD devErrCode = errDev;
			CSimpleStringA errMsg = "";
			GetAndSplitDevErrInfo(errMsg, devErrCode, "DevOpen"); //TODO: devErrCode???
			LogError(Severity_High, Error_Hardware
					, LOG_ERR_FINGERPRINT_OPEN_FAILED
					, "Fingerprint init(DevOpen) failed.");
			errDev = Error_DevCommFailed;
		}
	} while (0);

	return errDev;
}

ErrorCodeEnum CFingerPrintFSM::DoGetDevInfo()
{
	ErrorCodeEnum errDev = Error_Succeed;

	ZeroMemory(m_devCatInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(m_devCatInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(m_devCatInfo.szVendor, MAX_DEV_VENDOR_LEN);
	errDev = m_hDevHelper->GetDevCategory(m_devCatInfo);
	if (errDev == Error_Succeed)
	{
		Dbg("szModel = %s", m_devCatInfo.szModel);
		Dbg("szType = %s", m_devCatInfo.szType);
		Dbg("szVendor = %s", m_devCatInfo.szVendor);

		m_devInit = true;
		errDev = Error_Succeed;
	}
	else {
		LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_GETDEVINFO_FAILED
				, "Get device info(GetDevCategory) failed.");
		errDev = Error_DevCommFailed;
	}
	return errDev;
}

void CFingerPrintFSM::GetVendorLibName(CSmartPointer<IConfigInfo> spConfig
									 , CSimpleString& dllName)
{
	CSimpleString machineVersion(true);
	CSimpleString machineType(true);
	CSimpleStringA strVendor(true);
	CSimpleStringA strVersion(true);
	CSimpleStringA strBatch(true);

	TerminalMachineInfo terminalInfo = GetTerminalMachineInfo(GetEntityBase());
	machineType = Type2Str(terminalInfo.type);
	machineVersion = CSimpleStringA::Format("%d.%d", terminalInfo.gen.major, terminalInfo.gen.minor);

	spConfig->ReadConfigValue("Device.PinPad", "Vendor", strVendor);
	spConfig->ReadConfigValue("Device.PinPad", "Version", strVersion);
	spConfig->ReadConfigValue("Device.PinPad", "Batch", strBatch);

	if (strVendor.IsNullOrEmpty() || strVersion.IsNullOrEmpty() || strBatch.IsNullOrEmpty())
	{
		Dbg("Some related node is not set, cannot continue.");
		return;
	}
	strBatch = "1";
	if (!strVendor.Compare("Hyosung", true))
	{
		strVersion = "1";
	}
	else {
		switch (terminalInfo.type)
		{
		case RVC_Stand2S:
			strVersion = "7";
			break;
		case RVC_PAD:
			if (IsFWBDevice(strVendor))
				strVersion = "8";
			else
				strVersion = "1";
			break;
		case RVC_Desk2S:
			strVersion = "4";
			strBatch = machineVersion.Compare("1.0") ? "20" : strBatch;
			break;
		case RVC_Desk1S:
			if (!machineVersion.Compare("1.0"))
			{
				strVersion = "4";
				strBatch = "20";
			}
			break;
		case RVC_CardStore:
			strVersion = "5";
			break;
		default:
			strVersion = "1";
			break;
		}
	}
	CSimpleStringA newFileName(GetEntityBase()->GetEntityName());
	CSimpleStringA tmpFileName = newFileName +
		"." + strVendor +
		"." + strVersion +
		"." + strBatch;
	CSimpleStringA libPrefix("lib");

#ifdef RVC_OS_WIN
	newFileName = tmpFileName + ".dll";
#else
	newFileName = libPrefix + tmpFileName + ".so";
#endif // RVC_OS_WIN

	CSimpleStringA strDepPath;
	GetEntityBase()->GetFunction()->GetPath("Dep", strDepPath);

	if (strDepPath.IsNullOrEmpty())
	{
		Dbg("Get Dep path failed!");
	}
	else {
		dllName = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
			, strDepPath.GetData()
			, newFileName.GetData());
	}
}

#pragma endregion

#pragma region entity exit

ErrorCodeEnum CFingerPrintFSM::OnExit()
{
	if (m_hDevHelper)
	{
		ErrorCodeEnum errCode = Error_Succeed;
		m_hDevHelper.TearDown();//TODO:¿¼ÂÇÀ¶ÑÀ¶àºÏÒ»DevClose£¿£¿£¿
		return errCode;
	}
	return Error_Succeed;
}

#pragma endregion

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

#pragma region register

int CFingerPrintFSM::GetImageAndFeature(SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	ScanParam* pScanParam = new ScanParam();
	ErrorCodeEnum errCode = InitParamBeforeScan(pScanParam, ctx->Req.times);

	if (errCode != Error_Succeed)
		ctx->Answer(errCode);
	else {
		ScanProcess(pScanParam, ctx);
		if (pScanParam != NULL && ctx != NULL)
			ProcessAfterScan(pScanParam, ctx);
		else
			ctx->Answer(Error_Param);
	}

	return 0;
}

ErrorCodeEnum CFingerPrintFSM::InitParamBeforeScan(ScanParam* initParam, int scanTime)
{
	ErrorCodeEnum errCode = Error_Succeed;

	errCode = InitCommParam(initParam, RegisterType, scanTime);
	if (errCode != Error_Succeed)
		return errCode;

	switch (scanTime)
	{
	case 1:
		initParam->m_BmpFileName = "finger1.bmp";
		m_BmpFileFullPath1 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
			, initParam->m_DepPath.GetData()
			, initParam->m_BmpFileName.GetData());
		break;
	case 2:
		initParam->m_BmpFileName = "finger2.bmp";
		m_BmpFileFullPath2 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
			, initParam->m_DepPath.GetData()
			, initParam->m_BmpFileName.GetData());
		break;
	case 3:
		initParam->m_BmpFileName = "finger3.bmp";
		m_BmpFileFullPath3 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
			, initParam->m_DepPath.GetData()
			, initParam->m_BmpFileName.GetData());
		break;
	default:
		initParam->m_BmpFileName = "finger.bmp";
		break;
	}
	initParam->m_FullFilePath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
		, initParam->m_DepPath.GetData()
		, initParam->m_BmpFileName.GetData());

	Dbg("get imageName success: %s", initParam->m_FullFilePath.GetData());

	return errCode;
}

void CFingerPrintFSM::ScanProcess(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer& ctx)
{
	LOG_FUNCTION();
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");

	while (pScanParam->m_TimeLeft < FINGERPRINT_SCAN_TIMEOUT
		&& !m_bCancelRegister && !pScanParam->m_ScanSuc)
	{
		if (m_bExit)
		{
			Dbg("Exit");
			pScanParam->m_Quit = true;
			break;
		}

		SLEEP(FINGERPRINT_SCAN_INTERNAL);

		pScanParam->m_FeatureLen = MAX_FEATURE_LEN;
		ErrorCodeEnum errCode = m_hDevHelper->Image2Feature(pScanParam->m_BmpFileName
			, pScanParam->m_Feature
			, pScanParam->m_FeatureLen);
		if (errCode == Error_Succeed)
		{
			Dbg("Invoke routine 'Image2Feature' success.'");
			SLEEP(200);

			if (ExistsFile(pScanParam->m_FullFilePath)
				&& pScanParam->m_Feature != NULL
				&& pScanParam->m_FeatureLen > 0)
			{
				Dbg("fingerprint feature length is %d", pScanParam->m_FeatureLen);
				ctx->Ans.imageName = pScanParam->m_BmpFileName;

				if (ctx->Req.times == 3) {
					Dbg("m_strPath1 = %s", m_BmpFileFullPath1.GetData());
					Dbg("m_strPath2 = %s", m_BmpFileFullPath2.GetData());
					Dbg("m_strPath3 = %s", m_BmpFileFullPath3.GetData());

					errCode = m_hDevHelper->Image2Template(m_BmpFileFullPath1, m_BmpFileFullPath2
						, m_BmpFileFullPath3, pScanParam->m_Template
						, pScanParam->m_FeatureLen);

					if (Error_Succeed == errCode)
					{
						Dbg("Invoke routine 'Image2Template' success");

						if (pScanParam->m_Template != NULL && pScanParam->m_FeatureLen == 684)
						{
							ctx->Ans.feature = (CSimpleStringA)(pScanParam->m_Template);
						}
						else {
							Dbg("template len is: %d, or template is NULL", pScanParam->m_FeatureLen);
							pScanParam->m_GetTemplateSuc = false;
							break;
						}
					}else {
						pScanParam->m_GetTemplateSuc = false;
						DevErrorInfo devErrorInfo;
						m_hDevHelper->GetLastErr(devErrorInfo);
						Dbg("Invoke routine 'Image2Template' failed which returned %s(%s)"
							, SpStrError(errCode), devErrorInfo.szErrMsg);
						break;
					}
				}
				pScanParam->m_ScanSuc = true;
				break;
			}
			else if (!ExistsFile(pScanParam->m_FullFilePath)) {
				Dbg("Cannot find the fingerprint image %s", pScanParam->m_BmpFileName);
				pScanParam->m_NotFindImage = true;
				break;
			}
			else {
				Dbg("Fingerprint feature is NULL.");
				pScanParam->m_FeatureIsNull = true;
				break;
			}
		}
		else {
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned %s(%s) while register."
				, SpStrError(errCode), devErrInfo.szErrMsg);
		}
		pScanParam->m_TimeEnd = RVCGetTickCount();
		pScanParam->m_TimeLeft = pScanParam->m_TimeEnd - pScanParam->m_TimeStart;
	}

	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, "FingerPrint warning on");
	m_bExit = false;
}

void CFingerPrintFSM::ProcessAfterScan(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer& ctx)
{
	if (pScanParam->m_ScanSuc)
	{
		ctx->Answer(Error_Succeed);
	}
	else if (pScanParam->m_TimeLeft >= FINGERPRINT_SCAN_TIMEOUT)
	{
		ctx->Answer(Error_TimeOut);
	}
	else if (m_bCancelRegister)
	{
		ctx->Answer(Error_Cancel);
	}
	else {
		if (pScanParam->m_NotFindImage)
		{
			LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_NO_IMAGE_IN_DEP_REGISTER
				, "not find fingerprint image in dep while register.");
			ctx->Answer(Error_Unexpect, LOG_ERR_FINGERPRINT_NO_IMAGE_IN_DEP_REGISTER);
		}
		else if (pScanParam->m_FeatureIsNull)
		{
			LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_GETFEATURE_FAILED_REGISTER
				, "fingerprint feature is null while register.");
			ctx->Answer(Error_Unexpect, LOG_ERR_FINGERPRINT_GETFEATURE_FAILED_REGISTER);
		}
		else {
			if (ctx->Req.times == 3 && !pScanParam->m_GetTemplateSuc)
			{
				LogError(Severity_High, Error_Hardware
					, LOG_ERR_FINGERPRINT_GETTEMPLATE_FAILED
					, "Not generate template correctly.");
				ctx->Answer(Error_Unexpect, LOG_ERR_FINGERPRINT_GETTEMPLATE_FAILED);
			}
			else if (pScanParam->m_Quit) {
				LogWarn(Severity_High, Error_Hardware
					, LOG_ERR_FINGERPRINT_REGISTER_FAILED
					, "Exit to homepage when register.");
				ctx->Answer(Error_Unexpect);
			}
		}
	}

	delete[] pScanParam->m_Feature;
	pScanParam->m_Feature = NULL;
	delete[] pScanParam->m_Template;
	pScanParam->m_Template = NULL;
	delete pScanParam;
	pScanParam = NULL;
}

#pragma endregion

#pragma region match

ErrorCodeEnum CFingerPrintFSM::Match(SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	ScanParam* initParam = new ScanParam();
	ErrorCodeEnum errCode = InitParamBeforeMatch(initParam, ctx->Req.templateNum);
	if (errCode != Error_Succeed)
		return errCode;

	ScanBeforeMatch(initParam);

	errCode = MatchProcess(initParam, ctx);
	return errCode;
}

ErrorCodeEnum CFingerPrintFSM::InitParamBeforeMatch(ScanParam* initParam, int templateNum)
{
	ErrorCodeEnum errCode = Error_Succeed;

	errCode = InitCommParam(initParam, MatchType, 0, templateNum);
	if (errCode != Error_Succeed)
		return errCode;

	initParam->m_BmpFileName = "finger.bmp";
	initParam->m_FullFilePath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
		, initParam->m_DepPath.GetData()
		, initParam->m_BmpFileName.GetData());
	Dbg("get imageName success: %s", initParam->m_FullFilePath.GetData());

	return Error_Succeed;
}

void CFingerPrintFSM::ScanBeforeMatch(ScanParam* initParam)
{
	ErrorCodeEnum errCode = Error_Succeed;
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");

	while (initParam->m_TimeLeft < FINGERPRINT_MATCH_TIMEOUT
		&& !m_bCancelMatch && !initParam->m_ScanSuc)
	{
		if (m_bExit)
		{
			Dbg("Exit");
			initParam->m_Quit = true;
			break;
		}
		SLEEP(FINGERPRINT_SCAN_INTERNAL);

		initParam->m_FeatureLen = MAX_FEATURE_LEN;
		errCode = m_hDevHelper->Image2Feature(initParam->m_BmpFileName
			, initParam->m_Feature
			, initParam->m_FeatureLen);
		if (errCode == Error_Succeed)
		{
			Dbg("Invoke routine 'Image2Feature' success.");
			SLEEP(200);

			if (ExistsFile(initParam->m_FullFilePath) && initParam->m_Feature != NULL && initParam->m_FeatureLen > 0)
			{
				Dbg("fingerprint feature length is %d", initParam->m_FeatureLen);
				initParam->m_ScanSuc = true;
				break;
			}
			else if (!ExistsFile(initParam->m_FullFilePath))
			{
				Dbg("Cannot find the fingerprint image finger.bmp");
				initParam->m_NotFindImage = true;
				break;
			}
			else {
				Dbg("Fingerprint feature is NULL.");
				initParam->m_FeatureIsNull = true;
				break;
			}
		}
		else {
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned %s(%s)"
				, SpStrError(errCode), devErrInfo.szErrMsg);
		}
		initParam->m_TimeEnd = RVCGetTickCount();
		initParam->m_TimeLeft = initParam->m_TimeEnd - initParam->m_TimeStart;
	}
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, "FingerPrint warning off");
	m_bExit = false;

	Dbg("after match, clear bmp file");
	DeleteBmp(BmpImage);
}

ErrorCodeEnum CFingerPrintFSM::MatchProcess(ScanParam* initParam, SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer& ctx)
{
	ErrorCodeEnum errCode = Error_Succeed;

	if (initParam->m_ScanSuc)
	{
		Dbg("templateNum=%d", ctx->Req.templateNum);

		int templateNum = ctx->Req.templateNum;
		LPBYTE* lpbTemplates = new LPBYTE[templateNum];
		int* lpbTemplateLen = new int[templateNum];

		for (int i = 0; i < templateNum; ++i)
		{
			lpbTemplates[i] = new BYTE[MAX_FEATURE_LEN];
			memset(lpbTemplates[i], 0, sizeof(lpbTemplates[i]));
			strcpy((char*)lpbTemplates[i], ctx->Req.templates[i]);
			lpbTemplateLen[i] = ctx->Req.templateLen[i];
		}

		ULLINT startMatch = RVCGetTickCount();
		errCode = m_hDevHelper->Match(lpbTemplates, lpbTemplateLen, templateNum,
			initParam->m_Feature, initParam->m_FeatureLen);
		ULLINT endMatch = RVCGetTickCount();
		int duration = endMatch - startMatch;
		LogWarn(Severity_High, Error_Debug, LOG_ERR_FINGERPRINT_MATCH_TIME,
			GenerateAlarmJson("FingerPrint", duration).GetData());

		if (errCode == Error_Succeed) //always true
		{
			Dbg("Invoke routine 'Match' success");
			ctx->Ans.result.Init(templateNum);
			for (int i = 0; i < templateNum; ++i)
				ctx->Ans.result[i] = lpbTemplateLen[i];
		}
		else {
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_INVOKE_MATCH_FAILED
				, "Invoke routine 'Match' failed.");//no this situation
			Dbg("Invoke routine 'Match' failed which returned %s(%s)"
				, SpStrError(errCode), devErrInfo.szErrMsg);
			errCode = Error_Unexpect;
		}
		for (int i = 0; i < templateNum; ++i)
		{
			delete[] lpbTemplates[i];
			lpbTemplates[i] = NULL;
		}
		delete[] lpbTemplateLen;
		lpbTemplateLen = NULL;
		delete[] lpbTemplates;
		lpbTemplates = NULL;
	}
	else if (initParam->m_TimeLeft >= FINGERPRINT_MATCH_TIMEOUT)
	{
		Dbg("Match timeout(Invoke vendor failed or not press finger)");
		errCode = Error_TimeOut;
	}
	else if (m_bCancelMatch)
	{
		errCode = Error_Cancel;
	}
	else
	{
		if (initParam->m_NotFindImage)
		{
			LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_NO_IMAGE_IN_DEP_MATCH
				, "not find fingerprint image in dep while match.");
		}
		else if (initParam->m_FeatureIsNull)
		{
			LogError(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_GETFEATURE_FAILED_MATCH
				, "fingerprint feature is null while match.");
		}
		else if (initParam->m_Quit)
		{
			LogWarn(Severity_High, Error_Hardware
				, LOG_ERR_FINGERPRINT_MATCH_FAILED
				, "Exit to homepage when match.");
		}
		errCode = Error_Unexpect;
	}
	delete[] initParam->m_Feature;
	initParam->m_Feature = NULL;
	delete initParam;
	initParam = NULL;

	return errCode;
}

#pragma endregion

#pragma region common function

ErrorCodeEnum CFingerPrintFSM::InitCommParam(ScanParam* initParam, int operateType, int scanTime, int templateNum)
{
	ErrorCodeEnum errCode = Error_Succeed;

	if (!initParam)
		return Error_Param;

	if (!m_devInit)
		errCode = Error_NotInit; //maybe no vendor adapter

	if ((operateType & RegisterType) == RegisterType)
	{
		if (m_bCancelRegister) //no cancel button anymore while register
		{
			m_bCancelRegister = false;
			errCode = Error_Cancel;
		}
	}
	if ((operateType & MatchType) == MatchType && templateNum <= 0)
		errCode = Error_Param;

	if (errCode != Error_Succeed) {
		delete initParam;
		initParam = NULL;
		return errCode;
	}

	initParam->m_TimeStart = RVCGetTickCount();
	initParam->m_TimeEnd = RVCGetTickCount();
	initParam->m_TimeLeft = 0;

	initParam->m_Feature = new BYTE[MAX_FEATURE_LEN];
	initParam->m_FeatureLen = MAX_FEATURE_LEN;
	initParam->m_FullFilePath = "";

	initParam->m_ScanSuc = false;
	initParam->m_NotFindImage = false;
	initParam->m_FeatureIsNull = false;
	initParam->m_Quit = false;

	if (scanTime == 1)
	{
		m_BmpFileFullPath1 = "";
		m_BmpFileFullPath2 = "";
		m_BmpFileFullPath3 = "";
	}
	Dbg("before scan fingerprint, clear bmp file");
	DeleteBmp(BmpImage);
	Dbg("before scan fingerprint, finish doing clear job");

	if ((operateType & RegisterType) == RegisterType)
	{
		initParam->m_Template = new BYTE[MAX_FEATURE_LEN];
		initParam->m_GetTemplateSuc = true;
		m_bCancelRegister = false;

		memset(initParam->m_Template, 0, sizeof(initParam->m_Template));
	}
	else
		m_bCancelMatch = false;

	memset(initParam->m_Feature, 0, sizeof(initParam->m_Feature));

	errCode = m_pEntity->GetFunction()->GetPath("Dep", initParam->m_DepPath);
	if (errCode != Error_Succeed)
	{
		delete[] initParam->m_Feature;
		initParam->m_Feature = NULL;

		if ((operateType & RegisterType) == RegisterType)
		{
			delete[] initParam->m_Template;
			initParam->m_Template = NULL;

			Dbg("Get dep path failed while register.");
			LogError(Severity_High, Error_DevLoadFileFailed
				, LOG_ERR_FINGERPRINT_GET_DEP_PATH_FAILED_REGISTER
				, "Get dep path failed while register.");
		}
		else {
			Dbg("Get dep path failed while match.");
			LogError(Severity_High, Error_DevLoadFileFailed
				, LOG_ERR_FINGERPRINT_GET_DEP_PATH_FAILED_MATCH
				, "get dep path failed while match.");
		}

		delete initParam;
		initParam = NULL;

		return Error_Param;
	}
	return Error_Succeed;
}

ErrorCodeEnum CFingerPrintFSM::GetDevCatInfo(DevCategoryInfo& devInfo)
{
	Dbg("m_devCatInfo.szModel:%s, len:%d", m_devCatInfo.szModel, strlen(m_devCatInfo.szModel));
	Dbg("m_devCatInfo.szType:%s, len:%d", m_devCatInfo.szModel, strlen(m_devCatInfo.szType));
	Dbg("m_devCatInfo.szVendor:%s, len:%d", m_devCatInfo.szModel, strlen(m_devCatInfo.szVendor));

#ifdef RVC_OS_WIN
	strncpy_s(devInfo.szModel, MAX_DEV_MODEL_LEN, m_devCatInfo.szModel, strlen(m_devCatInfo.szModel));
	strncpy_s(devInfo.szType, MAX_DEV_TYPE_LEN, m_devCatInfo.szType, strlen(m_devCatInfo.szType));
	strncpy_s(devInfo.szVendor, MAX_DEV_VENDOR_LEN, m_devCatInfo.szVendor, strlen(m_devCatInfo.szVendor));
#else
	strncpy(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN > strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN);
	strncpy(devInfo.szType, m_devCatInfo.szType, (MAX_DEV_TYPE_LEN > strlen(m_devCatInfo.szType)) ? strlen(m_devCatInfo.szType) : MAX_DEV_TYPE_LEN);
	strncpy(devInfo.szVendor, m_devCatInfo.szVendor, (MAX_DEV_VENDOR_LEN > strlen(m_devCatInfo.szVendor)) ? strlen(m_devCatInfo.szVendor) : MAX_DEV_VENDOR_LEN);
#endif // RVC_OS_WIN

	return Error_Succeed;
}

CSimpleString CFingerPrintFSM::GenerateAlarmJson(CSimpleString entityName, int cost)
{
	return CSimpleString::Format("[{\"name\":\"%s\",\"cost\":%d}]", entityName.GetData(), cost);
}

ErrorCodeEnum CFingerPrintFSM::GetDevState(int& state)
{
	ErrorCodeEnum errCode;
	state = 0;
	if (!m_devInit) {
		return Error_Succeed;
	}

	CSimpleStringA fileName = "testFinger.bmp";
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;
	errCode = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
	if (errCode == Error_Succeed)
	{
		state = 1;
		DeleteBmp(TestImage);
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return Error_Succeed;
}

bool CFingerPrintFSM::IsFWBDevice(CSimpleString& vendorName)
{
	CSimpleStringA tmpDevSN("");
	bool isFWB = false;
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb device.");
		GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", vendorName);
		isFWB = true;
	}
	return isFWB;
}

ErrorCodeEnum CFingerPrintFSM::CheckCardSwiperStatus()
{
	ErrorCodeEnum errCode = Error_Unexpect;
	CardSwiperService_ClientBase* pCardSwiperClient = new CardSwiperService_ClientBase(this->GetEntityBase());
	errCode = pCardSwiperClient->Connect();
	if (errCode != Error_Succeed)
	{
		Dbg("connect CardSwiper fail %s.", SpStrError(errCode));
	}
	else {
		CardSwiperService_GetDevInfo_Req req = {};
		CardSwiperService_GetDevInfo_Ans ans = {};
		errCode = pCardSwiperClient->GetDevInfo(req, ans, 3000);

		if (errCode != Error_Succeed)
		{
			Dbg("CardSwiper::GetDevInfo() fail: 0x%x", errCode);
		}
		else {
			Dbg("CardSwiper::GetDevInfo() return state: %d", ans.state);
			if (ans.state == DEVICE_STATUS_NOT_READY)
			{
				SLEEP(500);
				CardSwiperService_GetDevInfo_Req req2 = {};
				CardSwiperService_GetDevInfo_Ans ans2 = {};
				errCode = pCardSwiperClient->GetDevInfo(req2, ans2, 3000);
				if (errCode != Error_Succeed)
				{
					Dbg("CardSwiper::GetDevInfo() again fail with err(%s)", SpStrError(errCode));
				}
				else {
					Dbg("CardSwiper::GetDevInfo() again return state: %d", ans2.state);
					if (ans2.state != DEVICE_STATUS_NORMAL)
						errCode = Error_DevNotAvailable;
				}
			}
			else if (ans.state != DEVICE_STATUS_NORMAL)
				errCode = Error_DevNotAvailable;
		}
		pCardSwiperClient->GetFunction()->CloseSession();
	}
	if (pCardSwiperClient != NULL)
	{
		pCardSwiperClient->SafeDelete();
		pCardSwiperClient = NULL;
	}

	return errCode;
}

void CFingerPrintFSM::DeleteBmp(int type)
{
	if ((type & BmpImage) == BmpImage)
	{
		Dbg("to delete fingerprint images...");
		DeleteFileIfExisted("finger.bmp");
		DeleteFileIfExisted("finger1.bmp");
		DeleteFileIfExisted("finger2.bmp");
		DeleteFileIfExisted("finger3.bmp");
	}
	if ((type & TestImage) == TestImage)
	{
		DeleteFileIfExisted("testFinger.bmp");
	}
}  

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

	if (ExistsFileA(strObjPath))
	{
		if (RemoveFileA(strObjPath))
		{
			Dbg("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else {
			Dbg("DeleteFile(%s) failed LastError(%s).", strObjPath.GetData(), GetLastError());
			return Error_Unexpect;
		}
	}
	else {
		Dbg("file %s not exist.", fileName);
		return Error_Succeed;
	}
}

#pragma endregion