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"

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

#define FINGERPRINT_INIT_COUNT 3

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;
	case USER_EVT_EXIT:
		e->SetHandled();
		m_bExit = true;
		break;
	case USER_EVT_QUIT:
		e->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

ErrorCodeEnum CFingerPrintFSM::OnInit()
{
	CSystemStaticInfo sysInfo;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	WORD majorVersion = sysInfo.MachineVersion.GetMajor();
	WORD minorVersion = sysInfo.MachineVersion.GetMinor();
	CSimpleStringA machineVersion = CSimpleStringA::Format("%d.%d", majorVersion, minorVersion);
	m_terminalNo = sysInfo.strTerminalID;
	Dbg("MachineType:%s, terminalNo: %s", (const char*)m_csMachineType, (const char*)m_terminalNo);

	//TODO:device init
	int initCount = 0;
	ErrorCodeEnum err;
	m_pFingerPrint = NULL;
	bool bCreateDevCom = false;

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

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

	//判断是否是蓝牙多合一
	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;
	}

	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	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;
	}
	Dbg("Load library: %s", (const char*)dllName);
	m_hVendordDll = LoadLibrary(dllName);
	DWORD lastError = GetLastError();
	BOOL triedFlag = FALSE;
	if (m_hVendordDll == NULL)
	{
		//SetLastError(lastError);
		Dbg("load vendor dll failed first time: %d.", lastError);
		if(lastError == 126 && dllName.IsEndWith("FingerPrint.dll", true)) {
			Dbg("Not config the vendor at root.ini");
			CSimpleStringA strVendor(true);
			CSimpleStringA strVersion(true);
			CSimpleStringA strBatch(true);
			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(!m_csMachineType.Compare("RVC.Stand2S", true)) {
						strVersion = "7";
						//TODO: Support new or old edition machine.
					} else if(!m_csMachineType.Compare("RVC.PAD", true)) {
						if (isFWB){//蓝牙多合一
							GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", strVendor);
							strVersion = "8";
						}else{
							strVersion = "1";
						}
					} else if(!m_csMachineType.Compare("RVC.Desk2S", true)) {
						strVersion = "4";
						if(machineVersion.Compare("1.0", true)){//低柜一体机(贵宾理财2.0&非贵宾理财2.1)
							strBatch = "20";
						}
					} else if (!m_csMachineType.Compare("RVC.Desk1S", true) && !machineVersion.Compare("1.0", true)){//低柜一体机(厅堂自助)
						strVersion = "4";
						strBatch = "20";
					}else{//eg:CardStore
						strVersion = "1";
					}
				}
				CSimpleStringA newFileName(GetEntityBase()->GetEntityName());
				newFileName += ".";
				newFileName += strVendor;
				newFileName += ".";
				newFileName += strVersion;
				newFileName += ".";
				newFileName += strBatch;
				newFileName += ".dll";

				CSimpleStringA strDepPath;
				GetEntityBase()->GetFunction()->GetPath("Dep", strDepPath);
				if(strDepPath.IsNullOrEmpty()) {
					Dbg("Get Dep path failed!");
				} else {
					CSimpleStringA fullFilePath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strDepPath, (const char*)newFileName);
					triedFlag = TRUE;
					dllName = fullFilePath;
					Dbg("Load library again: %s", (LPCTSTR)dllName);
					m_hVendordDll = LoadLibrary(dllName);
					if(m_hVendordDll != NULL) {
						lastError = GetLastError();
					}
				}
			}
		}
	}
	if (m_hVendordDll == NULL)
	{
		Dbg("load vendor dll failed(%d).", lastError);
		if(lastError != 126 || (!dllName.IsEndWith("FingerPrint.dll", true) && !triedFlag)) {

			BOOL fExisted = TRUE;
			if(lastError == 126) {
				const auto dwRet = GetFileAttributesA((LPCTSTR)dllName);
				fExisted = ((dwRet != INVALID_FILE_ATTRIBUTES) 
					&& !(dwRet & FILE_ATTRIBUTE_DIRECTORY));
			}
			if(!fExisted) {
				LogWarn(Severity_High, Error_DevLoadFileFailed, LOG_ERR_FINGERPRINT_VENDOR_ADAPTER_NOT_EXIST,
					CSimpleStringA::Format("library file: %s is not existed!", (LPCTSTR)dllName));
			} else {
				LogError(Severity_High, Error_NotInit, LOG_ERR_FINGERPRINT_LOAD_ADAPTER_FAILED,
					CSimpleStringA::Format("Load library file: %s failed, GLE=%d", (LPCTSTR)dllName, lastError));
			}
			return Error_DevLoadFileFailed;
		}
		m_devInit = false;
		m_pFingerPrint = NULL;
		LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_LOADFILE_FAILED, 
			CSimpleStringA::Format("Load library file: %s failed, GLE=%d", (LPCTSTR)dllName, lastError));
		Dbg("Not config, Allow this condition happend.");
		return Error_Succeed;
	}
	if ((CreateDevComponent = (lpCreateDevCom)GetProcAddress(m_hVendordDll, "CreateDevComponent")) == NULL)
	{
		Dbg("Get CreateDevComponent failed(%d).", GetLastError());
		LogError(Severity_High, Error_NotInit, LOG_ERR_FINGERPRINT_CREATE_COMPONENT_FAILED, "Get CreateDevComponent failed.");
		return Error_DevLoadFileFailed;
	}
	if ((ReleaseDevComponent = (lpReleaseDevCom)GetProcAddress(m_hVendordDll, "ReleaseDevComponent")) == NULL)
	{
		Dbg("Get ReleaseDevComponent failed(%d).", GetLastError());
	}
	Dbg("Get function suc");
	bool bOpenFlag = false;
	do 
	{
		if (!bCreateDevCom)
		{
			if (CreateDevComponent((DeviceBaseClass *&)m_pFingerPrint) != Error_Succeed)
			{
				LOG_TRACE("Create FingerPrint module failed.");
				initCount++;
				m_pFingerPrint = NULL;
				if (initCount >= FINGERPRINT_INIT_COUNT)
					break;
				else
					continue;
			}
			bCreateDevCom = true;
			LOG_TRACE("Create Fingerprint module succeeded.");
		}
		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(isFWB){
			if(Error_Succeed != CheckCardSwiperStatus()){
				Dbg("this is FWB, device status is not normal now.%d", CheckCardSwiperStatus());
				ReleaseDevComponent((DeviceBaseClass *&)m_pFingerPrint);
				return Error_DevCommFailed;
			}
			else{
				Dbg("this is FWB, device status is normal now.");
			}
		}
		err = m_pFingerPrint->DevOpen(tmpPort, baudrate);
		DevErrorInfo devOpenErrInfo;
		if (err != Error_Succeed)
		{
			LOG_TRACE("Open device failed(%d).", err);
			m_pFingerPrint->GetLastErr(devOpenErrInfo);
			Dbg("FingerPrint open failed(%s).", devOpenErrInfo.szErrMsg);
			LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_OPEN_FAILED, "Fingerprint init(DevOpen) failed.");
			ReleaseDevComponent((DeviceBaseClass *&)m_pFingerPrint);
			return Error_DevCommFailed;
		}
	} while (m_pFingerPrint == NULL && bOpenFlag == false);
	ZeroMemory(m_devCatInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(m_devCatInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(m_devCatInfo.szVendor, MAX_DEV_VENDOR_LEN);
	err = m_pFingerPrint->GetDevCategory(m_devCatInfo);
	if (err == 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 (m_pFingerPrint != NULL)
		{
			m_devInit = true;
			return Error_Succeed;
		}
		else
		{
			return Error_NotInit;
		}
	}
	else
	{
		Dbg("Invoke vendor routine 'GetDevCategory' failed.");
		LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_GETDEVINFO_FAILED, "Get device info(GetDevCategory) failed.");
		m_pFingerPrint->DevClose();
		ReleaseDevComponent((DeviceBaseClass *&)m_pFingerPrint);
		return Error_DevCommFailed;
	}
}

ErrorCodeEnum CFingerPrintFSM::OnExit()
{
	ErrorCodeEnum err;
	CSimpleStringA tmpDevSN("");
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb device.");
		return Error_Succeed;
	}
	else
	{
		Dbg("This is normal device.");
		if (m_pFingerPrint != NULL)
		{
			err = m_pFingerPrint->DevClose();
			if(err != Error_Succeed)
				LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_CLOSEDEV_FAILED, "Close device (DevClose) failed.");
			LOG_TRACE("OnExit hr(%d)", err);
		}
		if (m_pFingerPrint)
		{
			ReleaseDevComponent((DeviceBaseClass *&)m_pFingerPrint);
			m_pFingerPrint = NULL;
			m_devInit = false;
		}
		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();
	if(!m_devInit) {
		ctx->Answer(Error_NotInit);  //maybe no vendor adapter
		return 0;
	}
	if (m_bCancelRegister) //no cancel button anymore while register
	{
		ctx->Answer(Error_Cancel);
		m_bCancelRegister = false;
		return 0;
	}
	DWORD elapsed = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwEnd = GetTickCount();
	ErrorCodeEnum eErr;
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	LPBYTE lpbTemplate = new BYTE[MAX_FEATURE_LEN];
	memset(lpbFeature, 0, sizeof(lpbFeature));
	int lpbLength = MAX_FEATURE_LEN;
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");

	if (ctx->Req.times == 1)
	{
		Dbg("Before scan fingerprint, clear bmp file");
		DeleteBmp(BmpImage);
		Dbg("Before scan fingerprint, finish doing clear job.");
		m_strPath1 = "";
		m_strPath2 = "";
		m_strPath3 = "";
	}
	CSimpleStringA strPath;
	eErr = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	if(eErr != Error_Succeed)
	{
		delete[] lpbFeature;
		lpbFeature = NULL;
		delete[] lpbTemplate;
		lpbTemplate = NULL;
		Dbg("Get path failed");
		LogError(Severity_High, Error_DevLoadFileFailed, LOG_ERR_FINGERPRINT_GET_DEP_PATH_FAILED_REGISTER, "Get dep path failed while register.");
		ctx->Answer(Error_Param);
		return 0;
	}

	CSimpleStringA fileName, strPath1, strPath2, strPath3;
	switch(ctx->Req.times)
	{
	case 1:
		fileName = "finger1.bmp";
		m_strPath1 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strPath, (const char*)fileName);
		break;
	case 2:
		fileName = "finger2.bmp";
		m_strPath2 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strPath, (const char*)fileName);
		break;
	case 3:
		fileName = "finger3.bmp";
		m_strPath3 = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strPath, (const char*)fileName);
		break;
	default:
		fileName = "finger.bmp";
		break;
	}
	strPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strPath, (const char*)fileName);
	
	Dbg("get imageName success: %s", strPath);
	
	bool bScanSuccess = false;
	m_bCancelRegister = false;
	bool bGetTemplateSuc = true;
	bool bNotFindImage = false;
	bool bFeatureIsNull = false;
	bool bExit = false;
	while(elapsed < FINGERPRINT_SCAN_TIMEOUT && !m_bCancelRegister && !bScanSuccess)
	{
		if (m_bExit)
		{
			Dbg("Exit");
			bExit = true;
			break;
		}
		Sleep(FINGERPRINT_SCAN_INTERNAL);
		eErr = m_pFingerPrint->Image2Feature(fileName, lpbFeature, lpbLength);
		if (eErr == Error_Succeed){
			Dbg("Invoke routine 'Image2Feature' success.'");
			WIN32_FIND_DATA findData;
			Sleep(200);//save image may be delayed some time, not must happen
			if (FindFirstFileA((LPCTSTR)strPath, &findData) != INVALID_HANDLE_VALUE && lpbFeature != NULL && lpbLength > 0){
				Dbg("fingerprint feature length is %d", lpbLength);
				ctx->Ans.imageName = fileName;
				if (ctx->Req.times == 3){
					//第三次需要合成模板
					Dbg("m_strPath1 = %s", m_strPath1.GetData());
					Dbg("m_strPath2 = %s", m_strPath2.GetData());
					Dbg("m_strPath3 = %s", m_strPath3.GetData());

					eErr = m_pFingerPrint->Image2Template(m_strPath1, m_strPath2, m_strPath3, lpbTemplate, lpbLength);

					if (eErr == Error_Succeed){
						Dbg("Invoke routine 'Image2Template' success");
						if (lpbTemplate != NULL && lpbLength > 0){
							Dbg("template length is %d", lpbLength);
							ctx->Ans.feature = (LPCTSTR)lpbTemplate;
						}else{
							Dbg("template is NULL");
							bGetTemplateSuc = false;
							break; 
						}
					}else{
						bGetTemplateSuc = false;
						DevErrorInfo devErrorInfo;
						m_pFingerPrint->GetLastErr(devErrorInfo);
						Dbg("Invoke routine 'Image2Template' failed which returned 0x%x(%s)", eErr, devErrorInfo.szErrMsg);
						break;
					}
				}
				bScanSuccess = true;
				break;
			}else if(FindFirstFileA((LPCTSTR)strPath, &findData) == INVALID_HANDLE_VALUE){
				Dbg("Cannot find the fingerprint image %s", fileName);
				bNotFindImage = true;
				break;
			}else{
				Dbg("Fingerprint feature is NULL.");
				bFeatureIsNull = true;
				break;
			}
		}else{
			DevErrorInfo devErrInfo;
			m_pFingerPrint->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned 0x%x(%s) while register.", eErr, devErrInfo.szErrMsg);
		}
		dwEnd = GetTickCount();
		elapsed = dwEnd - dwStart;
	}
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, "FingerPrint warning on");
	m_bExit = false;
	if (bScanSuccess)
		ctx->Answer(Error_Succeed);
	else if(elapsed >= FINGERPRINT_SCAN_TIMEOUT)
		ctx->Answer(Error_TimeOut);
	else if(m_bCancelRegister)
		ctx->Answer(Error_Cancel);
	else{
		if(bNotFindImage){
			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(bFeatureIsNull){
			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 && !bGetTemplateSuc){
				LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_GETTEMPLATE_FAILED, "Not generate template correctly.");
				ctx->Answer(Error_Unexpect, LOG_ERR_FINGERPRINT_GETTEMPLATE_FAILED);
			}
			if(bExit){
				LogWarn(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_REGISTER_FAILED, "Exit to homepage when register.");
				ctx->Answer(Error_Unexpect);
			}
		}
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	delete[] lpbTemplate;
	lpbTemplate = NULL;
	return 0;
}

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){
				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: 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);
	WIN32_FIND_DATA findData;
	if (FindFirstFileA((LPCTSTR)strObjPath, &findData) != INVALID_HANDLE_VALUE)
	{
		if(DeleteFileA((LPCTSTR)strObjPath) != 0)
		{
			Dbg("DeleteFile(%s) success.", (LPCTSTR)strObjPath);
			return Error_Succeed;
		}
		else
		{
			Dbg("DeleteFile(%s) failed LastError(%s).", (LPCTSTR)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;
}

ErrorCodeEnum CFingerPrintFSM::Match(SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (ctx->Req.templateNum <= 0)
	{
		return Error_Param;
	}
	if(!m_devInit) {
		return Error_NotInit;
	}

	Dbg("Before scan fingerprint, clear bmp file");
	DeleteBmp(BmpImage);
	Dbg("Before scan fingerprint, finish doing clear job.");

	DWORD elapsed = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwEnd = GetTickCount();
	ErrorCodeEnum eErr;
	DevErrorInfo devErrInfo;
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	memset(lpbFeature, 0, sizeof(lpbFeature));
	int lpbLength = MAX_FEATURE_LEN;
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");

	CSimpleStringA strPath;
	eErr = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	if (eErr != Error_Succeed)
	{
		LogError(Severity_High, Error_DevLoadFileFailed, LOG_ERR_FINGERPRINT_GET_DEP_PATH_FAILED_MATCH, "get dep path failed while match.");
		Dbg("Get dep path failed");
		delete[] lpbFeature;
		lpbFeature = NULL;
		return Error_Param;
	}
	CSimpleStringA fileName = "finger.bmp";
	strPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", (const char*)strPath, (const char*)fileName);
	Dbg("get imageName success: %s", strPath);
	bool bScanSuccess = false;
	bool bNotFindImage = false;
	bool bFeatureIsNull = false;
	bool bExit = false;
	m_bCancelMatch = false;
	while(elapsed < FINGERPRINT_MATCH_TIMEOUT && !m_bCancelMatch && !bScanSuccess)
	{
		if (m_bExit)
		{
			Dbg("Exit");
			bExit = true;
			break;
		}
		Sleep(FINGERPRINT_SCAN_INTERNAL);
		eErr = m_pFingerPrint->Image2Feature(fileName, lpbFeature, lpbLength);
		if (eErr == Error_Succeed)
		{
			Dbg("Invoke routine 'Image2Feature' success.");
			Sleep(200);//save image may be delayed some time, not must happen
			WIN32_FIND_DATA findData;

			if (FindFirstFileA((LPCTSTR)strPath, &findData) != INVALID_HANDLE_VALUE && lpbFeature != NULL && lpbLength > 0)
			{
				Dbg("fingerprint feature length is %d", lpbLength);
				bScanSuccess = true;
				break;
			}
			else if (FindFirstFileA((LPCTSTR)strPath, &findData) == INVALID_HANDLE_VALUE)
			{
				Dbg("Cannot find the fingerprint image finger.bmp");
				bNotFindImage = true;
				break;
			}
			else
			{
				Dbg("Fingerprint feature is NULL.");
				bFeatureIsNull = true;
				break;
			}
		}
		else
		{
			lpbLength = MAX_FEATURE_LEN;
			m_pFingerPrint->GetLastErr(devErrInfo);
			Dbg("Invoke routine 'Image2Feature' failed which returned 0x%x(%s)", eErr, devErrInfo.szErrMsg);
		}
		dwEnd = GetTickCount();
		elapsed = dwEnd - dwStart;
	}
	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, "FingerPrint warning off");
	m_bExit = false;

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

	ErrorCodeEnum retErr;
	if (bScanSuccess)
	{
		int templateNum = ctx->Req.templateNum;
		Dbg("templateNum=%d", 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];
			//Dbg("lpbTemplate[%d], length = %d, %s", i, ctx->Req.templateLen[i], lpbTemplates[i]);
		}
		SYSTEMTIME urlStartTime, urlEndTime;
		GetLocalTime(&urlStartTime);
		DWORD starTime, endTime;
		starTime = GetTickCount();

		eErr = m_pFingerPrint->Match(lpbTemplates, lpbTemplateLen, templateNum, lpbFeature, lpbLength);

		endTime = GetTickCount();
		GetLocalTime(&urlEndTime);
		Dbg("MatchTime:%dms", endTime - starTime);
		auto urlDuration = getDuration(urlStartTime, urlEndTime);
		LogWarn(Severity_High, Error_Debug, LOG_ERR_FINGERPRINT_MATCH_TIME,
			generateAlarmJson("FingerPrint", formatTime(urlStartTime).c_str(), urlDuration).GetData());

		if (eErr == 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];
			}
			retErr = Error_Succeed;
		}
		else
		{
			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 0x%x(%s)", eErr, devErrInfo.szErrMsg);
			retErr = 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 (elapsed >= FINGERPRINT_MATCH_TIMEOUT)
	{
		Dbg("Match timeout(Invoke vendor failed or not press finger)");
		retErr = Error_TimeOut;
	}
		
	else if (m_bCancelMatch)
	{
		retErr = Error_Cancel;
	}
	else
	{
		if(bNotFindImage)
			LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_NO_IMAGE_IN_DEP_MATCH, "not find fingerprint image in dep while match.");
		else if(bFeatureIsNull)
			LogError(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_GETFEATURE_FAILED_MATCH, "fingerprint feature is null while match.");
		else if(bExit)
			LogWarn(Severity_High, Error_Hardware, LOG_ERR_FINGERPRINT_MATCH_FAILED, "Exit to homepage when match.");
		retErr = Error_Unexpect;
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return retErr;
}

ErrorCodeEnum CFingerPrintFSM::GetDevCatInfo(DevCategoryInfo& devInfo)
{
	Dbg("DevCatgoryInfo len:%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), strlen(m_devCatInfo.szVendor));
	strncpy_s(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN >strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN);
	strncpy_s(devInfo.szType, m_devCatInfo.szType, (MAX_DEV_TYPE_LEN >strlen(m_devCatInfo.szType)) ? strlen(m_devCatInfo.szType) : MAX_DEV_TYPE_LEN);
	strncpy_s(devInfo.szVendor, m_devCatInfo.szVendor, (MAX_DEV_VENDOR_LEN >strlen(m_devCatInfo.szVendor)) ? strlen(m_devCatInfo.szVendor) : MAX_DEV_VENDOR_LEN);
	return Error_Succeed;
}

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

int CFingerPrintFSM::getDuration(SYSTEMTIME time1, SYSTEMTIME time2)
{
	ULARGE_INTEGER fTime1;/*FILETIME*/
	ULARGE_INTEGER fTime2;/*FILETIME*/


	SystemTimeToFileTime(&time1, (FILETIME*)&fTime1);
	SystemTimeToFileTime(&time2, (FILETIME*)&fTime2);

	unsigned __int64 dft = fTime2.QuadPart - fTime1.QuadPart;
	return dft / 10000;
}

std::string CFingerPrintFSM::formatTime(SYSTEMTIME time)
{
	char tBuf[1024] = "";
	sprintf(tBuf, "%04u-%02u-%02u %02u:%02u:%02u:%03u", time.wYear, time.wMonth, time.wDay, time.wHour, time.wMinute, time.wSecond, time.wMilliseconds);
	return tBuf;
}

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