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 GET_FINGERPRINT_TIMEOUT	 (27*1000)
#define FINGERPRINT_SCAN_INTERNAL 100
#define FINGERPRINT_MATCH_TIMEOUT 15000
#define MAX_FEATURE_LEN 1024
#define STANDARD_FEATURE_LEN 684

#pragma region event response

void CFingerPrintFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_devState = DEVICE_STATUS_NORMAL;
	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogWarnInfoAboutTerm(this, m_adapterInfo);
	}
}

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_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_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_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();
		Dbg("Set cancel scan flag");
		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();

	CDevAdptEntityBase* pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();

	ErrorCodeEnum errDev;
	CSimpleStringA strLibFullPath(true);
	CSimpleStringA tmpVendor(""), tmpDevSN(""), tmpDLLVersion("");
	//judge if FWB or not
	bool isFWB = false;
	GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", tmpVendor);
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	GetEntityBase()->GetFunction()->GetSysVar("FWBVersion", tmpDLLVersion);

	if (tmpDLLVersion.GetLength() < 2)
		tmpDLLVersion = "8.1";
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb device.");
		isFWB = true;
		m_csDevSN = tmpDevSN;

		CSimpleStringA csDepPath(""), prefix(""), suffix("");
		GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);

#ifdef RVC_OS_WIN
		preix = "FingerPrint.";
		suffix = ".dll";
#else
		prefix = "libFingerPrint.";
		suffix = ".so";
#endif
		strLibFullPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s%s.%s%s"
			, csDepPath.GetData(), prefix.GetData(), tmpVendor.GetData(), tmpDLLVersion.GetData(), suffix.GetData());
	}
	else {
		ErrorCodeEnum errDev;
		errDev = ExtractVendorLib(strLibFullPath);
		if (errDev != Error_Succeed) {
			LogWarn(Severity_High, Error_DevLoadFileFailed
				, FingerPrint_UserErrorCode_GET_DLLNAME_FAILED_ONINIT
				, "get vendorlib failed while init");
			return errDev;
		}
	}

	LogWarn(Severity_Low, Error_DevLoadFileFailed
		, FingerPrint_UserErrorCode_ROOT_INFO
		, strLibFullPath.GetData());

	if (!ExistsFile(strLibFullPath))
	{
		LogWarn(Severity_High, Error_DevLoadFileFailed
			, FingerPrint_UserErrorCode_VENDOR_ADAPTER_NOT_EXIST
			, "No vendor fingerprint adapter in dep.");
		m_devInit = false;
		return Error_Succeed;
	}

	m_adapterInfo.adapterFileName = strLibFullPath;

	errDev = m_hDevHelper.LoadUp(strLibFullPath);
	if (Error_Succeed != errDev)
	{
		LogWarn(Severity_High, Error_NotInit, FingerPrint_UserErrorCode_LOAD_ADAPTER_FAILED,
			"load vendorlib or create DevAdapterObject failed.");
		return Error_DevLoadFileFailed;
	}

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

	if (Error_Succeed != errDev)
		return errDev;

	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());
		LogWarn(Severity_High, Error_DevLoadFileFailed
			, FingerPrint_UserErrorCode_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!");
		LogWarn(Severity_High, Error_DevLoadFileFailed
			, FingerPrint_UserErrorCode_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)
		{
			SetErrPackage(m_errPkg, "Initial::DevOpen", m_csDevSN, errDev, MEC_DEVAPI_FINGERPRINT_DevOpen);
			AlarmDEC(m_errPkg);
			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_adapterInfo.devCatInfo = m_devCatInfo;
		m_devInit = true;
		errDev = Error_Succeed;
	}
	else {
		SetErrPackage(m_errPkg, "Initial::GetDevCategory", m_csDevSN, errDev, MEC_DEVAPI_FINGERPRINT_GetDevCategory);
		AlarmDEC(m_errPkg);
		m_hDevHelper->DevClose();
		errDev = Error_DevCommFailed;
	}
	return errDev;
}

#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 interface - not use anymore in uos

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 = (LPCTSTR)pScanParam->m_Template;
							Dbg("Ans.feature = %s", ctx->Ans.feature.GetData());
						}
						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.GetData());
				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 off");
	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
				, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER
				, "not find fingerprint image in dep while register.");
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER);
		}
		else if (pScanParam->m_FeatureIsNull)
		{
			LogError(Severity_High, Error_Hardware
				, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER
				, "fingerprint feature is null while register.");
			ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER);
		}
		else {
			if (ctx->Req.times == 3 && !pScanParam->m_GetTemplateSuc)
			{
				LogError(Severity_High, Error_Hardware
					, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED
					, "Not generate template correctly.");
				ctx->Answer(Error_Unexpect, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
			}
			else if (pScanParam->m_Quit) {
				LogWarn(Severity_Middle, Error_Hardware
					, FingerPrint_UserErrorCode_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 register interface - not use anymore in uos

int CFingerPrintFSM::GetImageAndFeatureEx(SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

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

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

	return 0;
}

void CFingerPrintFSM::ScanProcessEx(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_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.'");
			Dbg("FingerPrint feature length is %d", pScanParam->m_FeatureLen);
			SLEEP(200);

			if (ExistsFile(pScanParam->m_FullFilePath)
				&& pScanParam->m_Feature != NULL
				&& pScanParam->m_FeatureLen == STANDARD_FEATURE_LEN)
			{
				ctx->Ans.imageName = pScanParam->m_BmpFileName;
				pScanParam->m_Feature[STANDARD_FEATURE_LEN] = '\0';
				Dbg("after add eof, feature = %s", (LPCTSTR)pScanParam->m_Feature);

				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());

					pScanParam->m_FeatureLen = MAX_FEATURE_LEN;
					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");
						Dbg("template length is %d", pScanParam->m_FeatureLen);

						if (pScanParam->m_Template != NULL && pScanParam->m_FeatureLen == STANDARD_FEATURE_LEN)
						{
							pScanParam->m_Template[STANDARD_FEATURE_LEN] = '\0';
							ctx->Ans.feature = (LPCTSTR)pScanParam->m_Template;
							Dbg("Ans.feature = %s", ctx->Ans.feature.GetData());
						}
						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.GetData());
				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 off");
	m_bExit = false;
}

void CFingerPrintFSM::ProcessAfterScanEx(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer& ctx)
{
	ctx->Ans.reserved1.Init(10);
	ctx->Ans.reserved1.Init(10);
	if (pScanParam->m_ScanSuc)
	{
		ctx->Ans.reserved1[0] = 1;
		ctx->Answer(Error_Succeed);
	}
	else if (pScanParam->m_TimeLeft >= FINGERPRINT_SCAN_TIMEOUT)
	{
		ctx->Ans.reserved1[0] = 2;
		ctx->Answer(Error_Succeed);
	}
	else if (m_bCancelRegister)
	{
		m_bCancelRegister = false;
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Succeed);
	}
	else {
		if (pScanParam->m_NotFindImage)
		{
			LogError(Severity_High, Error_Hardware
				, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER
				, "not find fingerprint image in dep while register.");
			ctx->Answer(Error_NotExist, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER);
		}
		else if (pScanParam->m_FeatureIsNull)
		{
			ctx->Ans.reserved1[0] = 4;
			LogError(Severity_High, Error_Hardware
				, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER
				, "fingerprint feature is null while register.");
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER);
		}
		else {
			if (ctx->Req.times == 3 && !pScanParam->m_GetTemplateSuc)
			{
				ctx->Ans.reserved1[0] = 5;
				LogError(Severity_High, Error_Hardware
					, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED
					, "Not generate template correctly.");
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
			}
			else if (pScanParam->m_Quit) {
				ctx->Ans.reserved1[0] = 6;
				LogWarn(Severity_Middle, Error_Hardware
					, FingerPrint_UserErrorCode_REGISTER_FAILED
					, "Exit to homepage when register.");
				ctx->Answer(Error_Succeed);
			}
		}
	}

	delete[] pScanParam->m_Feature;
	pScanParam->m_Feature = NULL;
	delete[] pScanParam->m_Template;
	pScanParam->m_Template = NULL;
	delete pScanParam;
	pScanParam = NULL;
}
#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();
	if (!m_devInit) {
		Dbg("GetFingerPrint return failed for device isn't init suc.");
		ctx->Answer(Error_NotInit);  //maybe no vendor adapter
		return 0;
	}

	Dbg("ctx->Req.times = %d", ctx->Req.times);
	if (ctx->Req.times <= 0 || ctx->Req.times > 10)
	{
		ctx->Answer(Error_Param);
		return 0;
	}

	ErrorCodeEnum errCode = Error_Succeed;
	ScanParam* pScanParam = new ScanParam();

	errCode = InitCommParam(pScanParam, RegisterType, ctx->Req.times);

	if (errCode != Error_Succeed) {
		Dbg("InitCommParam with EC = 0x%x(%s)", errCode, SpStrError(errCode));
		ctx->Answer(errCode);
	}
	else {
		CollectProcess(pScanParam, ctx);
		if (pScanParam != NULL && ctx != NULL)
			ProcessAfterCollect(pScanParam, ctx);
		else
			ctx->Answer(Error_Param);
	}
	return 0;
}

void CFingerPrintFSM::CollectProcess(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer& ctx)
{
	LOG_FUNCTION();

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

	CSimpleStringA fileName = CSimpleStringA::Format("finger%d.bmp", ctx->Req.times);
	pScanParam->m_FullFilePath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", pScanParam->m_DepPath.GetData(), fileName.GetData());
	Dbg("<GetFingerPrint> imageName = %s", fileName.GetData());

	while (pScanParam->m_TimeLeft < GET_FINGERPRINT_TIMEOUT
		&& !m_bCancelRegister && !m_bCancelMatch && !pScanParam->m_bGetFingerPrintSuc)
	{
		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(fileName
			, pScanParam->m_Feature
			, pScanParam->m_FeatureLen);
		if (errCode == Error_Succeed)
		{
			SLEEP(200);
			if (ExistsFile(pScanParam->m_FullFilePath)
				&& pScanParam->m_Feature != NULL
				&& pScanParam->m_FeatureLen == STANDARD_FEATURE_LEN)
			{
				ctx->Ans.imageName = fileName;
				pScanParam->m_Feature[STANDARD_FEATURE_LEN] = '\0';
				ctx->Ans.feature = (LPCTSTR)pScanParam->m_Feature;
				pScanParam->m_bGetFingerPrintSuc = true;
				Dbg("Image2Feature success.");
				break;
			}
			else if (!ExistsFile(pScanParam->m_FullFilePath))
			{
				Dbg("Cannot find the fingerprint image %s", fileName.GetData());
				pScanParam->m_NotFindImage = true;
				break;
			}
			else if (pScanParam->m_FeatureLen != STANDARD_FEATURE_LEN) {
				Dbg("vendor returned feature length is not right.");
				pScanParam->m_bLenIsNotRight = 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 off");
	m_bExit = false;
}

void CFingerPrintFSM::ProcessAfterCollect(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer& ctx)
{
	LOG_FUNCTION();
	ctx->Ans.reserved1.Init(10);
	if (pScanParam->m_bGetFingerPrintSuc)
	{
		ctx->Ans.reserved1[0] = 1;
		ctx->Answer(Error_Succeed);
	}
	else if (pScanParam->m_TimeLeft >= FINGERPRINT_SCAN_TIMEOUT)
	{
		m_bCancelRegister = false;
		m_bCancelMatch = false;
		ctx->Ans.reserved1[0] = 2;
		ctx->Answer(Error_Succeed);
	}
	else if (m_bCancelRegister || m_bCancelMatch) {
		m_bCancelRegister = false;
		m_bCancelMatch = false;
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Succeed);
	}
	else {
		if (pScanParam->m_NotFindImage) {
			LogError(Severity_High, Error_Hardware, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER, "not find fingerprint image in dep while register.");
			ctx->Ans.reserved1[0] = 7;
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER);
		}
		else if (pScanParam->m_FeatureIsNull) {
			LogError(Severity_High, Error_Hardware, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER, "fingerprint feature is null while register.");
			ctx->Ans.reserved1[0] = 4;
			ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER);
		}
		else if (pScanParam->m_bLenIsNotRight) {
			LogError(Severity_High, Error_Hardware, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT, "fingerprint feature len is not right.");
			ctx->Ans.reserved1[0] = 5;
			ctx->Answer(Error_Succeed);
		}
		else if (pScanParam->m_Quit) {
			LogWarn(Severity_High, Error_Hardware, FingerPrint_UserErrorCode_REGISTER_FAILED, "Exit to homepage when register.");
			ctx->Ans.reserved1[0] = 6;
			ctx->Answer(Error_Succeed);
		}
	}

	delete[] pScanParam->m_Feature;
	pScanParam->m_Feature = NULL;
	if (pScanParam->m_Template != NULL) {
		delete[] pScanParam->m_Template;
		pScanParam->m_Template = NULL;
	}
	delete pScanParam;
	pScanParam = NULL;
}
#pragma endregion

#pragma region generate template

int CFingerPrintFSM::GenerateTemplate(SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	if (!m_devInit) {
		Dbg("GenerateTemplate return failed for device isn't init suc.");
		ctx->Answer(Error_NotInit);
		return 0;
	}

	if (m_bCancelRegister) {
		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)
	{
		char buf[8];
		ZeroMemory(buf, 8);
		_itoa(ctx->Req.FingerIDList[i], buf, 10);
		CSimpleStringA tempStr = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "finger%d.bmp", strPath.GetData(), ctx->Req.FingerIDList[i]);
		imagePaths.push_back(tempStr);
		Dbg("imageName:%s", imagePaths[i].GetData());
		if (!ExistsFile(imagePaths[i]))
		{
			Dbg("image <%s> not exist.", imagePaths[i].GetData());
			DeleteBmp(BmpImage);
			ctx->Answer(Error_NoTarget);
			return 0;
		}
	}

	errCode = m_hDevHelper->Image2Template(imagePaths[0], imagePaths[1], imagePaths[2], lpbTemplate, lpbLength);

	if (Error_Succeed == errCode)
	{
		Dbg("Invoke routine 'Image2Template' success");
		Dbg("template length is %d", lpbLength);
		if (lpbTemplate != NULL && lpbLength == STANDARD_FEATURE_LEN) {
			//Dbg("before add eof, template = %s", (LPCTSTR)lpbTemplate);
			lpbTemplate[lpbLength] = '\0';
			//Dbg("after add eof, template = %s", (LPCTSTR)lpbTemplate);
			ctx->Ans.templateFeature = (LPCTSTR)lpbTemplate;
		}
		else {
			Dbg("template is NULL or template length is not right.");
			errCode = Error_Unexpect;
		}
	}
	else {
		SetErrPackage(m_errPkg, "GenerateTemplate::Image2Template", m_csDevSN, errCode, MEC_DEVAPI_FINGERPRINT_Image2Template);
		AlarmDEC(m_errPkg);
		errCode = Error_Unexpect;
	}

	DeleteBmp(BmpImage);
	if (errCode == Error_Succeed)
		ctx->Answer(Error_Succeed);
	else {
		SetErrPackage(m_errPkg, "generate template failed", m_csDevSN, Error_Unexpect, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
		ctx->Answer(errCode, AlarmDEC(m_errPkg));
	}

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

#pragma endregion

#pragma region match - old interface
 
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_Middle, Error_Debug, FingerPrint_UserErrorCode_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
				, FingerPrint_UserErrorCode_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
				, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH
				, "not find fingerprint image in dep while match.");
		}
		else if (initParam->m_FeatureIsNull)
		{
			LogError(Severity_High, Error_Hardware
				, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH
				, "fingerprint feature is null while match.");
		}
		else if (initParam->m_Quit)
		{
			LogWarn(Severity_Middle, Error_Hardware
				, FingerPrint_UserErrorCode_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)
{
	LOG_FUNCTION();
	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
	//	{
	//		Dbg("cancel flag");
	//		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_bLenIsNotRight = false;
	initParam->m_bGetFingerPrintSuc = 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)
	{
		Dbg("operateType = %d", RegisterType);
		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
				, FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_REGISTER
				, "Get dep path failed while register.");
		}
		else {
			Dbg("Get dep path failed while match.");
			LogError(Severity_High, Error_DevLoadFileFailed
				, FingerPrint_UserErrorCode_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.szType, strlen(m_devCatInfo.szType));
	Dbg("m_devCatInfo.szVendor:%s, len:%d", m_devCatInfo.szVendor, 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));
		pCardSwiperClient->SafeDelete();
	}
	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();
	}

	return errCode;
}

void CFingerPrintFSM::DeleteBmp(int type)
{
	if ((type & BmpImage) == BmpImage)
	{
		Dbg("to delete fingerprint images...");
		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::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