myvtm/Module/mod_FingerPrint/FingerPrintFSM.cpp

#include "FingerPrintFSM.h"
#include "EventCode.h"
#include "FingerPrint_UserErrorCode.h"
#include "GetDevInfoHelper.h"
#include "path.h"
#include "DevEntityCommBase.hpp"
#include <thread>
#include <chrono>
#include <fstream>
#include <cstdio>

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

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();
			Dbg("s0 on event error");
			break;
		}
		case USER_EVT_QUIT:
		{
			e->SetHandled();
			Dbg("s0 on event quit");
			break;
		}
		case USER_EVT_SCAN:
		{
			e->SetHandled();
			ScanEvent* pSe = dynamic_cast<ScanEvent*>(e);
			ScanTask* pSt = new ScanTask(this);
			pSt->ctx = pSe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pSt);
			break;
		}
		case USER_EVT_CANCEL_SCAN:
		{
			e->SetHandled();
			Dbg("s0 set cancel flag!");
			m_bCancelRegister = true;
			break;
		}
		case USER_EVT_MATCH:
		{
			e->SetHandled();
			MatchEvent* pMe = dynamic_cast<MatchEvent*>(e);
			MatchTask* pMt = new MatchTask(this);
			pMt->ctx = pMe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pMt);
			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();
		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();
	Dbg("FingerPrint failed.");
	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);
	int ret = 0;
	switch(e->iEvt)
	{
		case USER_EVT_MATCH_FINISHED:
		{
			e->SetHandled();
			MatchFinishedEvent* mfe = dynamic_cast<MatchFinishedEvent*>(e);
			if (mfe->param1 == 0)
				mfe->ctx->Answer(Error_Succeed);
			else
				mfe->ctx->Answer((ErrorCodeEnum)mfe->param1);
			break;
		}
		case USER_EVT_CANCEL_MATCH:
		{
			e->SetHandled();
			Dbg("Set cancel match flag");
			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;
}

ErrorCodeEnum CFingerPrintFSM::OnInit()
{
	CSimpleStringA strLibFullPath;
	CDevAdptEntityBase *pEntity = GET_DEV_ENTITY_BASE_POINTER();
	ErrorCodeEnum errDev = pEntity->ExtractVendorLibFullPath(strLibFullPath);
	Dbg("Extract Vendor lib name: %s", (const char*)strLibFullPath);	

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

	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", (const char*)strLibFullPath);

	if (!IsFileExist(strLibFullPath))
	{
		Dbg("No vendor fingerprint adapter in dep.");
		m_devInit = false;
		return Error_Succeed;
	}

	m_DevAdptLibHelper = new DevAdptLibHelper<FingerPrintClass>();
	errDev = m_DevAdptLibHelper->LoadUp(strLibFullPath);
	if (Error_Succeed != errDev)
	{
		Dbg("load vendorlib or create DevAdapterObject failed.");
		delete m_DevAdptLibHelper;    //TODO: 考虑蓝牙多合一 DevClose()
		m_DevAdptLibHelper = nullptr;
		return Error_DevLoadFileFailed;
	}

	m_pFingerPrint = m_DevAdptLibHelper->GetDevPointer();

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

	return DoGetDevInfo();
}

ErrorCodeEnum CFingerPrintFSM::OnExit()
{
	if (nullptr != m_DevAdptLibHelper)
	{
		delete m_DevAdptLibHelper;
		m_DevAdptLibHelper = nullptr;
	}

	return Error_Succeed;
}

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

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" 
												 , (const char*)initParam->m_DepPath
												 , (const char*)initParam->m_BmpFileName);
		break;
	case 2:
		initParam->m_BmpFileName = "finger2.bmp";
		m_BmpFileFullPath2 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
												 , (const char*)initParam->m_DepPath
												 , (const char*)initParam->m_BmpFileName);
		break;
	case 3:
		initParam->m_BmpFileName = "finger3.bmp";
		m_BmpFileFullPath3 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
												 , (const char*)initParam->m_DepPath
												 , (const char*)initParam->m_BmpFileName);
		break;
	default:
		initParam->m_BmpFileName = "finger.bmp";
		break;
	}
	initParam->m_FullFilePath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s"
													, (const char*)initParam->m_DepPath
													, (const char*)initParam->m_BmpFileName);

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

	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;
		}

		std::this_thread::sleep_for(std::chrono::milliseconds(FINGERPRINT_SCAN_INTERNAL));

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

			//save image may be delayed some time, not must happen
			std::this_thread::sleep_for(std::chrono::milliseconds(200));
			std::ifstream bmpImage((const char*)pScanParam->m_FullFilePath, std::ifstream::binary);

			if (bmpImage && 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_pFingerPrint->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 > 0) {
							Dbg("template length is %d", pScanParam->m_FeatureLen);
							ctx->Ans.feature = (LPCTSTR)pScanParam->m_Template;
						}
						else {
							Dbg("template is NULL");
							pScanParam->m_GetTemplateSuc = false;
							break;
						}
					}else {
						pScanParam->m_GetTemplateSuc = false;
						DevErrorInfo devErrorInfo;
						m_pFingerPrint->GetLastErr(devErrorInfo);
						Dbg("Invoke routine 'Image2Template' failed which returned %s(%s)", SpStrError(errCode), devErrorInfo.szErrMsg);
						break;
					}
				}
				pScanParam->m_ScanSuc = true;
				break;
			}else if (!bmpImage) {
				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_pFingerPrint->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned %s(%s) while register."
				, SpStrError(errCode), devErrInfo.szErrMsg);
		}
		pScanParam->m_TimeEnd = clock();
		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;
}

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"
		, (const char*)initParam->m_DepPath
		, (const char*)initParam->m_BmpFileName);
	Dbg("get imageName success: %s", initParam->m_FullFilePath);

	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;
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(FINGERPRINT_SCAN_INTERNAL));
		//Sleep(FINGERPRINT_SCAN_INTERNAL);
		initParam->m_FeatureLen = MAX_FEATURE_LEN;
		errCode = m_pFingerPrint->Image2Feature(initParam->m_BmpFileName
											  , initParam->m_Feature
											  , initParam->m_FeatureLen);
		if (errCode == Error_Succeed)
		{
			//TODO: union test
			Dbg("Invoke routine 'Image2Feature' success.");
			std::this_thread::sleep_for(std::chrono::milliseconds(200));
			//Sleep(200);//save image may be delayed some time, not must happen

			std::ifstream bmpImage((const char*)initParam->m_FullFilePath, std::fstream::binary);
			if (bmpImage && initParam->m_Feature != NULL && initParam->m_FeatureLen > 0)
			{
				Dbg("fingerprint feature length is %d", initParam->m_FeatureLen);
				initParam->m_ScanSuc = true;
				break;
			}
			else if (!bmpImage) 
			{
				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_pFingerPrint->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned %s(%s)"
				, SpStrError(errCode), devErrInfo.szErrMsg);
		}
		initParam->m_TimeEnd = clock();
		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];
		}

		clock_t startMatch = clock();
		errCode = m_pFingerPrint->Match(lpbTemplates, lpbTemplateLen, templateNum,
										initParam->m_Feature, initParam->m_FeatureLen);
		clock_t endMatch = clock();
		int duration = (endMatch - startMatch) * 1000 / CLOCKS_PER_SEC;
		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_pFingerPrint->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;
}

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;
	}

	initParam->m_TimeStart = clock();
	initParam->m_TimeEnd = clock();
	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("DevCatgoryInfo len:%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), 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::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 dllname failed while init");
	}

	return errDev;
}

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

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

		if (IsFWBDevice())
		{
			if (Error_Succeed != CheckCardSwiperStatus())
			{
				Dbg("this is FWB, device status is not normal now.%d", CheckCardSwiperStatus());

				delete m_DevAdptLibHelper;
				m_DevAdptLibHelper = nullptr;

				return Error_DevCommFailed;
			}else {
				Dbg("this is FWB, device status is normal now.");
			}
		}

		errDev = m_pFingerPrint->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.");

			delete m_DevAdptLibHelper;
			m_DevAdptLibHelper = nullptr;

			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_pFingerPrint->GetDevCategory(m_devCatInfo);
	if (errDev == Error_Succeed)
	{
		Dbg("%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), strlen(m_devCatInfo.szVendor));

		if (strlen(m_devCatInfo.szModel) < 256)
			Dbg("szMode=%s", m_devCatInfo.szModel);

		if (nullptr != m_DevAdptLibHelper && nullptr != m_pFingerPrint)
		{
			m_devInit = true;
			errDev = Error_Succeed;
		}
		else
			errDev = Error_NotInit;
	}
	else {
		Dbg("Invoke vendor routine 'GetDevCategory' failed.");
		LogError(Severity_High, Error_Hardware
			, LOG_ERR_FINGERPRINT_GETDEVINFO_FAILED
			, "Get device info(GetDevCategory) failed.");

		delete m_DevAdptLibHelper;
		m_DevAdptLibHelper = nullptr;

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

	GetMachineInfo(machineVersion, machineType);
	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.");
	}else {
		strBatch = "1";
		if (!strVendor.Compare("Hyosung", true)) 
		{
			strVersion = "1";
		}else {
			if (!machineType.Compare("RVC.Stand2S", true)) 
			{
				strVersion = "7";
				//TODO: Support new or old edition machine.
			}else if (!machineType.Compare("RVC.PAD", true)) 
			{
				if (IsFWBDevice())
				{
					//蓝牙多合一
					GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", strVendor);
					strVersion = "8";
				}else {
					strVersion = "1";
				}
			}
			else if (!machineType.Compare("RVC.Desk2S", true))
			{
				strVersion = "4";
				if (machineVersion.Compare("1.0", true))
				{
					strBatch = "20"; //低柜一体机(贵宾理财2.0&非贵宾理财2.1)
				}
			}else if (!machineType.Compare("RVC.Desk1S", true) && !machineVersion.Compare("1.0")) 
			{
				strVersion = "4"; //低柜一体机(厅堂自助)
				strBatch = "20";
			}else {
				strVersion = "1"; //eg:CardStore
			}
		}
		CSimpleStringA newFileName(GetEntityBase()->GetEntityName());
		newFileName = newFileName + "." + strVendor + "."
					+ strVersion + "." + strBatch + ".dll";

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

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

ErrorCodeEnum CFingerPrintFSM::GetMachineInfo(CSimpleString& machineVersion, CSimpleString& machineType)
{
	CSystemStaticInfo sysInfo;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	machineType = sysInfo.strMachineType;
	WORD majorVersion = sysInfo.MachineVersion.GetMajor();
	WORD minorVersion = sysInfo.MachineVersion.GetMinor();;
	machineVersion = CSimpleStringA::Format("%d.%d", majorVersion, minorVersion);

	Dbg("MachineType:%s, terminalNo: %s"
					, (const char*)machineType
					, (const char*)sysInfo.strTerminalID);

	return Error_Succeed;
}

bool CFingerPrintFSM::IsFileExist(CSimpleString fileName)
{
	std::ifstream bmpImage((const char*)fileName, std::ifstream::binary);
	
	return bmpImage.good();
}

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_pFingerPrint->Image2Feature(fileName, lpbFeature, lpbLength);
	if (errCode == Error_Succeed)
	{
		state = 1;
		DeleteBmp(TestImage);
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return Error_Succeed;
}

bool CFingerPrintFSM::IsFWBDevice()
{
	CSimpleStringA tmpDevSN("");
	bool isFWB = false;
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb device.");
		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 0x%x(%d).", errCode, 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)
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(500));
				CardSwiperService_GetDevInfo_Req req2 = {};
				CardSwiperService_GetDevInfo_Ans ans2 = {};
				errCode = pCardSwiperClient->GetDevInfo(req2, ans2, 3000);
				if (errCode != Error_Succeed)
				{
					Dbg("CardSwiper::GetDevInfo() again fail: 0x%x", 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(LPCTSTR 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", (const char*)strPath, (const char*)fileName);
	std::ifstream beDeletedFile((const char*)strObjPath, std::ifstream::binary);

	if (beDeletedFile)
	{
		if (remove((const char*)strObjPath) == 0)
		{
			Dbg("DeleteFile(%s) success.", (const char*)strObjPath);
			return Error_Succeed;
		}
		else {
			Dbg("DeleteFile(%s) failed LastError(%s).", (const char*)strObjPath, GetLastError());
			return Error_Unexpect;
		}
	}
	if (GetLastError() == ERROR_FILE_NOT_FOUND)
	{
		return Error_Succeed;
	}
	Dbg("DeleteFle(%s) Unexpect GetLastError(%s).", (LPCTSTR)strObjPath, GetLastError());
	return Error_Unexpect;
}