myvtm/Module/mod_CustMngrAuth/CustMngrAuthFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CustMngrAuth_UserErrorCode.h"
#include "CustMngrAuthFSM.h"
#include "CommEntityUtil.hpp"
#include "fileutil.h"

#include <fstream>
#include <map>
#ifdef RVC_OS_WIN

#include <iostream>
#include <iomanip>
#include <random>
#include <stdint.h> 
#include <sstream>

using namespace std;
#else
#include "fileutil.h"
#include <memory>
#include <thread>
#include <chrono>
#include <string>
#include <ctime>
#include <cstring>

using std::string;
#endif




#define IMAGE_NUM 3


class CCustMngrAuthEntity;



//Init
void CCustMngrAuthFSM::s0_on_entry()
{
	LOG_FUNCTION();
	FSMEvent* pEvt = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(pEvt);
}

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

unsigned int CCustMngrAuthFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s0 evt %d", pEvt->iEvt);

	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT:
		{
			InitTask* task = new InitTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
			return 0;
		}
		break;
	default:
		break;
	}
	return 0;
}
//Initializing
void CCustMngrAuthFSM::s1_on_entry()
{
	LOG_FUNCTION();
}
void CCustMngrAuthFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCustMngrAuthFSM::s1_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 evt %d", pEvt->iEvt);

	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT_FINISHED:
		pEvt->SetHandled();
		return pEvt->param1;
	default:
		break;
	}
	return 0;
}
//Idle
void CCustMngrAuthFSM::s2_on_entry()
{
	LOG_FUNCTION();
}
void CCustMngrAuthFSM::s2_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCustMngrAuthFSM::s2_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s2 evt(%d, %d)", pEvt->iEvt, pEvt->param1);

	switch (pEvt->iEvt)
	{
	case USER_EVT_AUTHORIZE_START:
		{
			pEvt->SetHandled();
			AuthorizeStartEvent* authorEvt = dynamic_cast<AuthorizeStartEvent*>(pEvt);
			if (authorEvt->ctx->Req.TimeLimit <= 0)
			{
				AuthorizeFinishedEvent* e = new AuthorizeFinishedEvent();
				e->ctx = authorEvt->ctx;
				e->param1 = Error_Param;
				this->PostEventFIFO(e);
				break;
			}
			//状态机流程会耗一些时间，这里要比前端传过来的时间小一些，及时返回给前端
			m_TimeLimit = (authorEvt->ctx->Req.TimeLimit - 3) * 1000; 

			m_bCancelAuthorize = false;

			//起指纹匹配线程
			MatchFingerPrintTask* matchTask = new MatchFingerPrintTask(this);
			matchTask->ctx = authorEvt->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(matchTask);
		}
		break;
	case USER_EVT_QUERYAUTHORINFO:
		{
			pEvt->SetHandled();
			QueryAuthorInfoEvent* queryEvt = dynamic_cast<QueryAuthorInfoEvent*>(pEvt);
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("QUERYAUTHORINFO, time:%d, wayOfKey:%d, wayOfFinger:%d",
			//		queryEvt->ctx->Req.TimeLimit, queryEvt->ctx->Req.WayofKey, queryEvt->ctx->Req.WayofFinger);
			if (queryEvt->ctx->Req.TimeLimit <= 0)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: receive timelimit lessequal than zero(%d).", queryEvt->ctx->Req.TimeLimit);
				QueryAuthorInfoFinishedEvent* e = new QueryAuthorInfoFinishedEvent();
				e->ctx = queryEvt->ctx;
				e->param1 = Error_Param;
				this->PostEventFIFO(e);
				break;
			}
			m_TimeLimit = (queryEvt->ctx->Req.TimeLimit - 3) * 1000;

			ErrorCodeEnum eErr;
			m_bCancelAuthorize = false;

			if (queryEvt->ctx->Req.WayofFinger == 1)
			{
				//起指纹匹配线程
				MatchFingerPrintTaskEx* mTask = new MatchFingerPrintTaskEx(this);
				mTask->ctx = queryEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(mTask);
			}
			if (queryEvt->ctx->Req.WayofKey == 1)
			{
				//打开USB
			}
		}
		break;
	case USER_EVT_COLLECTFINGERPRINT_START:
		{
			pEvt->SetHandled();
			CollectFingerPrintStartEvent* collectEvt = dynamic_cast<CollectFingerPrintStartEvent*>(pEvt);
			CollectFingerPrintTask* collectTask = new CollectFingerPrintTask(this);
			collectTask->ctx = collectEvt->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(collectTask);
		}
		break;
	case USER_EVT_COLLECTFINGERPRINTEX_START:
		{
			pEvt->SetHandled();
			CollectFingerPrintExStartEvent* collectEvt = dynamic_cast<CollectFingerPrintExStartEvent*>(pEvt);
			CollectFingerPrintExTask* collectExTask = new CollectFingerPrintExTask(this);
			collectExTask->ctx = collectEvt->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(collectExTask);
		}
		break;
	case USER_EVT_COLLECTFINGERPRINTINFO:
		{
			pEvt->SetHandled();
			CollectFingerPrintInfoEvent* collectEvt = dynamic_cast<CollectFingerPrintInfoEvent*>(pEvt);
			CollectFingerPrintInfoTask* collectExTask = new CollectFingerPrintInfoTask(this);
			collectExTask->ctx = collectEvt->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(collectExTask);
		}
		break;
	case USER_EVT_GENERATE_TEMPLATE:
		{
			pEvt->SetHandled();
			GenerateTemplateEvent* gtEvt = dynamic_cast<GenerateTemplateEvent*>(pEvt);
			GenerateTemplateTask* gtTask = new GenerateTemplateTask(this);
			gtTask->ctx = gtEvt->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(gtTask);
		}
		break;
	case USER_EVT_SAVEFINGERPRINT_START:
		{
			pEvt->SetHandled();
			SaveFingerPrintStartEvent* saveEvtfpe = dynamic_cast<SaveFingerPrintStartEvent*>(pEvt);
			SaveFingerPrintTask* saveTask = new SaveFingerPrintTask(this);
			saveTask->ctx = saveEvtfpe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(saveTask);
		}
		break;
	case USER_EVT_CHECKUKEY:
		{
			pEvt->SetHandled();
			//SwitchUSB(true);
		}
		break;
	default:
		break;
	}
	return 0;
}

void CCustMngrAuthFSM::s3_on_entry()
{
	LOG_FUNCTION();
	ScheduleTimer(1, m_TimeLimit);
}
void CCustMngrAuthFSM::s3_on_exit()
{
	LOG_FUNCTION();
	CancelTimer(1);
}
unsigned int CCustMngrAuthFSM::s3_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s3 evt %d, %d", pEvt->iEvt, pEvt->param1);

	switch (pEvt->iEvt)
	{
		case USER_EVT_HOLDON:
		{
			CancelTimer(1);
			HoldOnEvent* holdEvt = dynamic_cast<HoldOnEvent*>(pEvt);
			if (holdEvt->ctx == NULL)
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HoldOnEvent->ctx is NULL");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HoldOn with MoreTime: %d second", holdEvt->ctx->Req.MoreTime);
			int moreTime = holdEvt->ctx->Req.MoreTime * 1000;
			ScheduleTimer(1, (moreTime > 0) ? moreTime : m_TimeLimit);
			pEvt->SetHandled();
		}
		break;
	case EVT_TIMER:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Hit Timer");
			pEvt->SetHandled();
			m_bAuthorizeTimeout = true;
			m_bCancelAuthorize = true;
			CancelAuthorize();
		}
		break;
	case USER_EVT_AUTHORIZE_FINISHED:
		{
			pEvt->SetHandled();
			AuthorizeFinishedEvent* authorEvt = dynamic_cast<AuthorizeFinishedEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("authorize finished with param1 as %d", authorEvt->param1);
			if (authorEvt->param1 == 0)
			{
				 if (m_authCtx.eAuthByWhich == AuthByFngPrnt)
					{
						authorEvt->ctx->Ans.WayofAuth = AuthByFngPrnt;
						authorEvt->ctx->Ans.CustomerID = m_authCtx.CustomerID;
						authorEvt->ctx->Answer(Error_Succeed);
					}
			}
			else
			{
				authorEvt->ctx->Answer((ErrorCodeEnum)authorEvt->param1);
			}

			if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
			{
				m_bCancelAuthorize = true;
				m_pFingerPrint->GetFunction()->CloseSession();
				m_pFingerPrint = NULL;
			}
			
			m_authCtx.eAuthByWhich = AuthByNone;
			m_authCtx.CustomerID = "";
			m_authCtx.UkeyID = "";
			m_ctx = NULL;
		}
		break;
	case USER_EVT_QUERYAUTHORINFO_FINISHED:
		{
			pEvt->SetHandled();
			QueryAuthorInfoFinishedEvent* qafEvt = dynamic_cast<QueryAuthorInfoFinishedEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("authorize finished with param1 as %d", qafEvt->param1);
			if (qafEvt->param1 == 0)
			{
				 if (m_authCtx.eAuthByWhich == AuthByFngPrnt){
					qafEvt->ctx->Ans.WayofAuth = AuthByFngPrnt;
					qafEvt->ctx->Ans.Feature = m_authCtx.Feature;
					qafEvt->ctx->Ans.FingerImg = m_authCtx.FingerImg;
					qafEvt->ctx->Answer(Error_Succeed);
				}
			}
			else
			{
				qafEvt->ctx->Answer((ErrorCodeEnum)qafEvt->param1, qafEvt->param2);
			}

			if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
			{
				m_bCancelAuthorize = true;
				m_pFingerPrint->GetFunction()->CloseSession();
				m_pFingerPrint = NULL;
			}

			m_authCtx.eAuthByWhich = AuthByNone;
			m_authCtx.CustomerID = "";
			m_authCtx.UkeyID = "";
			m_authCtx.Feature = "";
			memset(&m_authCtx.FingerImg, 0, sizeof(m_authCtx.FingerImg));

			qaInfoCtx = NULL;
		}
		break;
	case USER_EVT_AUTHORIZE_CANCEL:
		{
			pEvt->SetHandled();
			m_bCancelAuthorize = true;
			CancelAuthorize();
		}
		break;
	case USER_EVT_QUERYAUTHORINFO_CANCEL:
		{
			pEvt->SetHandled();
			m_bCancelAuthorize = true;
			CancelCollect();
		}
		break;
	default:
		break;
	}
	return 0;
}
void CCustMngrAuthFSM::s4_on_entry()
{
	LOG_FUNCTION();
}
void CCustMngrAuthFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCustMngrAuthFSM::s4_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s4 evt %d, %d", pEvt->iEvt, pEvt->param1);

	switch (pEvt->iEvt)
	{
	case USER_EVT_COLLECTFINGERPRINT_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_COLLECTFINGERPRINTEX_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_COLLECTFINGERPRINTINFO_FINISHED:
		{
			pEvt->SetHandled();
			if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
			{
				m_pFingerPrint->GetFunction()->CloseSession();
				m_pFingerPrint = NULL;
			}
		}
		break;
	case USER_EVT_GENERATE_TEMPLATE_FINISHED:
		{
			pEvt->SetHandled();
			if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
			{
				m_pFingerPrint->GetFunction()->CloseSession();
				m_pFingerPrint = NULL;
			}
		}
		break;
	case USER_EVT_COLLECTFINGERPRINT_CANCEL:
		{
			pEvt->SetHandled();
			if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
				(*m_pFingerPrint)(EntityResource::getLink().upgradeLink())->CancelRegister();
		}
		break;
	case USER_EVT_SAVEFINGERPRINT_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_CHECKUKEY_FINISHED:
		{
			pEvt->SetHandled();
		}
		break;
	default:
		break;
	}
	return 0;
}

void CCustMngrAuthFSM::s5_on_entry()
{
	LOG_FUNCTION();
}

void CCustMngrAuthFSM::s5_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CCustMngrAuthFSM::s5_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s5 evt %d, %d", pEvt->iEvt, pEvt->param1);
	return 0;
}


#pragma region entity init

ErrorCodeEnum CCustMngrAuthFSM::OnInit()
{
	LOG_FUNCTION();
	m_authCtx.eAuthByWhich = AuthByNone;

	CSystemStaticInfo staticInfo;
	m_pEntity->GetFunction()->GetSystemStaticInfo(staticInfo);
	m_TerminalID = staticInfo.strTerminalID;
	m_csMachineType = staticInfo.strMachineType;
	m_FingerSection = "FingerInfo";
	CSimpleStringA machineVersion = CSimpleStringA::Format("%d.%d", staticInfo.MachineVersion.GetMajor(), staticInfo.MachineVersion.GetMinor());
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CustMngrAuth m_csMachineType:%s, machineVersion:%s, TerminalNo:%s",
			m_csMachineType.GetData(), machineVersion.GetData(), m_TerminalID.GetData());

	return Error_Succeed;
}

ErrorCodeEnum CCustMngrAuthFSM::OnExit()
{
	LOG_FUNCTION();
	FSMImpl<CCustMngrAuthFSM>::OnExit();
	return Error_Succeed;
}

int CCustMngrAuthFSM::Initial()
{
	ErrorCodeEnum errCode = OpenRunInfoFile();
	if (errCode != Error_Succeed) {
		return 1;
	}
	return 0;
}

ErrorCodeEnum CCustMngrAuthFSM::OpenRunInfoFile()
{
	ErrorCodeEnum errCode;
	errCode = GetEntityBase()->GetFunction()->GetPath("RunInfo", m_RunInfoPath);
	if (errCode != Error_Succeed)
	{
		LogWarn(Severity_High, Error_DevLoadFileFailed, LOG_ERR_CUSTMNGRAUTH_GET_RUNINFO_PATH_FAILED_Init, "get runinfo path failed while init");
		errCode =  Error_Unexpect;
	}	
	return errCode;
}

#pragma endregion

#pragma region Registe process

ErrorCodeEnum CCustMngrAuthFSM::CollectFingerPrintInfo(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintInfo_Req, CustMngrAuthService_CollectFingerPrintInfo_Ans>::Pointer ctx, DWORD& dwUserErrCode)
{
	LOG_FUNCTION();

	if (ctx == NULL || !(ctx->Req.FingerId > 0 && ctx->Req.FingerId < 10))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CollectFingerPrintInfo, Invalid inParam, FingerId:%d", ctx->Req.FingerId);
		return Error_Param;
	}
	CSimpleStringA tmpParam = CSimpleStringA::Format("web invoke CollectFingerPrintInfo with inParam FingerId:%d", ctx->Req.FingerId);
	LogWarn(Severity_Low, Error_Unexpect, LOG_ERR_CUSTMNGRAUTH_INVOKE_CollectFingerPrintInfo, "web invoke CollectFingerPrintInfo");

	ErrorCodeEnum errCode;
	m_pFingerPrint = new FingerPrintService_ClientBase(m_pEntity);
	errCode = m_pFingerPrint->Connect();
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("CollectFingerPrintInfo, connect to FingerPrint entity failed. %s", SpStrError(errCode));
		m_pFingerPrint->SafeDelete();
		m_pFingerPrint = NULL;
		return Error_Hardware;	//TODO::give one other errCode
	}

	FingerPrintService_GetFingerPrint_Req GetFingerReq;
	FingerPrintService_GetFingerPrint_Ans GetFingerAns;
	GetFingerReq.times = ctx->Req.FingerId;

	if (m_pFingerPrint == NULL || m_pFingerPrint->QuerySessionClosed())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("m_pFingerPrint is NULL or connection closed.");
		return Error_Hardware;
	}

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_pFingerPrint->GetFingerPrint(GetFingerReq, GetFingerAns, 30000, dwUserErrCode);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("CollectFingerPrintInfo invoke GetFingerPrint return %s", SpStrError(errCode));

	if (errCode == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("CollectFingerPrintInfo invoke GetFingerPrint return %s, reserved1[0]:%d", SpStrError(errCode), GetFingerAns.reserved1[0]);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("reserved1[0]:%d", GetFingerAns.reserved1[0]);
		switch (GetFingerAns.reserved1[0])
		{
		case 1:
			errCode = Error_Succeed;
			break;
		case 2:
			errCode = Error_TimeOut;
			break;
		case 3:
			errCode = Error_Cancel;
			break;
		default:
			errCode = Error_Unexpect;
			break;
		}

		if (errCode == Error_Succeed)
		{
			ctx->Ans.feature = GetFingerAns.feature;

			CBlob data;
			CSimpleStringA depPath(true);
			m_pEntity->GetFunction()->GetPath("Dep", depPath);
			CSimpleStringA imgFullPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", depPath.GetData(), GetFingerAns.imageName.GetData());

			UpdateAndWarnFileFindInDepBak(imgFullPath, GetFingerAns.imageName, LOG_ERR_CUSTMNGRAUTH_FindFile_in_DepBak);

			ErrorCodeEnum imgErrCode = GetImgBlob(data, imgFullPath);
			if (imgErrCode != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Failed to load image(%s)", imgFullPath.GetData());
				return Error_Unexpect;
			}
			ctx->Ans.fingerImg = data;
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CollectFingerPrintInfo return success.");
		}
	}
	else {
		if (errCode == Error_NotInit)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FingerPrintEntity not ready or failed.");
			return Error_DevNotAvailable;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("CollectFingerPrintInfo invoke GetFingerPrint return %s", SpStrError(errCode));
			errCode = Error_Unexpect;
		}
	}

	return errCode;
}

ErrorCodeEnum CCustMngrAuthFSM::GenerateTemplate(SpReqAnsContext<CustMngrAuthService_GenerateTemplate_Req, CustMngrAuthService_GenerateTemplate_Ans>::Pointer ctx, DWORD& dwUserErrCode)
{
	LOG_FUNCTION();
	LogWarn(Severity_Low, Error_Unexpect, LOG_ERR_CUSTMNGRAUTH_INVOKE_GenerateTemplate, "web invoke GenerateTemplate");

	int fingerNum = ctx->Req.FingerIDList.GetCount();
	if (fingerNum != IMAGE_NUM)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GenerateTemplate, Invalid inParam, fingerNum:%d", fingerNum);
		return Error_Param;
	}

	ErrorCodeEnum errCode;
	m_pFingerPrint = new FingerPrintService_ClientBase(m_pEntity);
	errCode = m_pFingerPrint->Connect();
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("GenerateTemplate, connect to fingerprint entity failed while GenerateTemplate: %s", SpStrError(errCode));
		m_pFingerPrint->SafeDelete();
		m_pFingerPrint = NULL;
		return Error_DevNotAvailable;	//TODO::give one other errCode
	}

	FingerPrintService_GenerateTemplate_Req generateReq;
	FingerPrintService_GenerateTemplate_Ans generateAns;
	generateReq.FingerIDList.Init(IMAGE_NUM);
	for (int i = 0; i < generateReq.FingerIDList.GetCount(); ++i)
	{
		generateReq.FingerIDList[i] = ctx->Req.FingerIDList[i];
	}

	if (m_pFingerPrint == NULL || m_pFingerPrint->QuerySessionClosed())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("m_pFingerPrint is NULL or connection closed.");
		return Error_DevNotAvailable;
	}

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = (*m_pFingerPrint)(EntityResource::getLink().upgradeLink())->GenerateTemplate(generateReq, generateAns, 20000, dwUserErrCode);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("GenerateTemplate invoke GenerateTemplate return %s", SpStrError(errCode));

	if (errCode == Error_NotInit)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FingerPrint Entity not ready or failed.");
		return Error_DevNotAvailable;
	}

	if (errCode == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("invoke fingerprint GenerateTemplate return %s", SpStrError(errCode));
		ctx->Ans.templateFeature = generateAns.templateFeature;
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GenerateTemplate return success.");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("invoke fingerprint GenerateTemplate return %s", SpStrError(errCode));
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Invoke GenerateTemplate returned %d", errCode);
		errCode = Error_Unexpect;
	}

	return errCode;
}

void CCustMngrAuthFSM::BroadcastPressFinger(int times, bool bPressFinger)
{
	if (bPressFinger) {
		PressFinger pfEvt;//
		pfEvt.FingerNo = 1;//maybe no use,control by @zhuyi
		pfEvt.Times = times;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(PressFinger), SP_MSG_SIG_OF(PressFinger), pfEvt);
	}
	else {
		LiftFinger lfEvt;
		lfEvt.FingerNo = 1;
		lfEvt.Times = times;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(LiftFinger), SP_MSG_SIG_OF(LiftFinger), lfEvt);
	}
}

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



#pragma endregion



#pragma region authorize process

ErrorCodeEnum CCustMngrAuthFSM::MatchFingerPrintEx(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx, bool& bStopAuthorize, DWORD& dwUserErrCode)
{
	LOG_FUNCTION();
	LogWarn(Severity_Low, Error_Unexpect, LOG_ERR_CUSTMNGRAUTH_INVOKE_MATCHEx, "web invoke MatchFingerPrintEx");

	ErrorCodeEnum errCode;
	m_pFingerPrint = new FingerPrintService_ClientBase(m_pEntity);
	errCode = m_pFingerPrint->Connect();
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ERROR: connect to fingerprint entity failed while match %s", SpStrError(errCode));
		m_pFingerPrint->SafeDelete();
		m_pFingerPrint = NULL;
		return Error_Hardware;	//TODO::give one other errCode
	}

	FingerPrintService_GetFingerPrint_Req GetFingerReq;
	FingerPrintService_GetFingerPrint_Ans GetFingerAns;
	GetFingerReq.times = 10;

	if (m_pFingerPrint == NULL || m_pFingerPrint->QuerySessionClosed())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("m_pFingerPrint is NULL or connection closed.");
		return Error_DevNotAvailable;
	}

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = (*m_pFingerPrint)(EntityResource::getLink().upgradeLink())->GetFingerPrint(GetFingerReq, GetFingerAns, 30000, dwUserErrCode);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("MatchFingerPrintEx invoke GetFingerPrint return %s", SpStrError(errCode));

	if (errCode == Error_DevNotAvailable) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("FingerPrintEntity DevOpen failed");
		return errCode;
	}

	if (errCode == Error_NotInit)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("FingerPrintEntity not ready or failed.");
		return Error_DevNotAvailable;
	}

	if (errCode == Error_Cancel)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("FingerPrintEntity is canceled while match before");
		return Error_Cancel;
	}

	if (errCode == Error_TimeOut)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("FingerPrintEntity invoke GetFingerPrint time out 30s");
		return Error_TimeOut;
	}

	bStopAuthorize = true;
	if (m_bCancelAuthorize || (errCode == Error_Succeed && GetFingerAns.reserved1[0] == 3)){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetFingerPrint is canceled while match, m_bAuthorizeTimeout:%d", m_bAuthorizeTimeout);
		m_bCancelAuthorize = false;
		if (m_bAuthorizeTimeout) {
			m_bAuthorizeTimeout = false;
			return Error_TimeOut;
		}
		return Error_Cancel;
	}

	if (errCode == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("MatchFingerPrintEx invoke GetFingerPrint return %s,reserved1[0]:%d", SpStrError(errCode), GetFingerAns.reserved1[0]);
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("reserved1[0]:%d", GetFingerAns.reserved1[0]);
		switch (GetFingerAns.reserved1[0])
		{
		case 1:
			errCode = Error_Succeed;
			break;
		case 2:
			errCode = Error_TimeOut;
			break;
		case 3:
			errCode = Error_Cancel;
			break;
		default:
			errCode = Error_Unexpect;
			break;
		}

		if (errCode == Error_Succeed)
		{
			m_authCtx.eAuthByWhich = AuthByFngPrnt;
			ctx->Ans.Feature = GetFingerAns.feature;

			CBlob data;
			CSimpleStringA depPath(true);
			m_pEntity->GetFunction()->GetPath("Dep", depPath);
			CSimpleStringA imgFullPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", depPath.GetData(), GetFingerAns.imageName.GetData());
			UpdateAndWarnFileFindInDepBak(imgFullPath, GetFingerAns.imageName, LOG_ERR_CUSTMNGRAUTH_FindFile_in_DepBak);

			ErrorCodeEnum imgErrCode = GetImgBlob(data, imgFullPath);
			if (imgErrCode != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Failed to load image(%s)", imgFullPath.GetData());
				return Error_Unexpect;
			}
			ctx->Ans.FingerImg = data;
			m_authCtx.Feature = ctx->Ans.Feature;
			m_authCtx.FingerImg = ctx->Ans.FingerImg;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setBeginTime(l_beginTime).setEndTime(l_endTime)("MatchFingerPrintEx invoke GetFingerPrint return %s", SpStrError(errCode));
		errCode = Error_Unexpect;
	}

	DeleteBmp(BmpImage);
	return errCode;
}

void CCustMngrAuthFSM::DeleteBmp(int type)
{
	if ((type & BmpImage) == BmpImage)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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");
	}
}

//TODO: CrossPlaform  [Gifur@2025728]
ErrorCodeEnum CCustMngrAuthFSM::DeleteFileIfExisted(const char* fileName)
{
#ifdef RVC_OS_WIN
	if (strlen(fileName) == 0 || strchr(fileName, (int)'*') != NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Invalid or empty filename(%s)", fileName);
		return Error_Param;
	}
	CSimpleStringA strPath, strObjPath;
	ErrorCodeEnum errCode = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	strObjPath = strPath + "\\" + fileName;

	UpdateAndWarnFileFindInDepBak(strObjPath, fileName, LOG_ERR_CUSTMNGRAUTH_FindFile_in_DepBak);
	//TODO: CrossPlaform  [Gifur@2025728]
	WIN32_FIND_DATA findData;
	if (FindFirstFileA((LPCTSTR)strObjPath, &findData) != INVALID_HANDLE_VALUE)
	{
		if (DeleteFileA((LPCTSTR)strObjPath) != 0)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFile(%s) failed LastError(%s).", strObjPath.GetData(), GetLastError());
			return Error_Unexpect;
		}
	}
	if (GetLastError() == ERROR_FILE_NOT_FOUND)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", fileName);
		return Error_Succeed;
	}
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFle(%s) Unexpect GetLastError(%s).", strObjPath.GetData(), GetLastError());
	return Error_Unexpect;
#else
	if (strlen(fileName) == 0 || strchr(fileName, (int)'*') != NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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);

	UpdateAndWarnFileFindInDepBak(strObjPath, fileName, LOG_ERR_CUSTMNGRAUTH_FindFile_in_DepBak);

	if (ExistsFileA(strObjPath))
	{
		if (RemoveFileA(strObjPath))
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFile(%s) failed LastError(%s).", strObjPath.GetData(), GetLastError());
			return Error_Unexpect;
		}
	}
	else {
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", fileName);
		return Error_Succeed;
	}
#endif	
}

void CCustMngrAuthFSM::UpdateAndWarnFileFindInDepBak(CSimpleStringA& newDepPath, const char* filename, DWORD userCode)
{
	CSimpleStringA strOldPath;
	if (!ExistsFileA(newDepPath.GetData()))
	{
		ErrorCodeEnum eErrOld = m_pEntity->GetFunction()->GetPath("DepBak", strOldPath);
		if (eErrOld != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get [DepBak] Path failed！ errcode:%s.", SpStrError(eErrOld));
		}
		strOldPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strOldPath.GetData(), filename);

		if (ExistsFileA(strOldPath.GetData())) //在旧Dep路径下找到文件时告警
		{
			newDepPath = strOldPath;
			//CSimpleStringA warnMsg = CSimpleStringA::Format("Find %s in OLD dep path!", strOldPath.GetData());
			//LogWarn(Severity_Middle, Error_Unexpect, userCode, warnMsg.GetData());
		}
	}
}

void CCustMngrAuthFSM::BroadcastGetFinger(int status)
{
	GetFinger evt;
	evt.Status = status;
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(GetFinger), SP_MSG_SIG_OF(GetFinger), evt);
}





#pragma endregion

#pragma region invoked function

void CCustMngrAuthFSM::CancelAuthorize()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invoke m_pFingerPrint->CancelMatch()");
	if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
		(*m_pFingerPrint)(EntityResource::getLink().upgradeLink())->CancelMatch();
}

void CCustMngrAuthFSM::CancelCollect()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invoke m_pFingerPrint->CancelRegister()");
	if (m_pFingerPrint != NULL && !m_pFingerPrint->QuerySessionClosed())
		(*m_pFingerPrint)(EntityResource::getLink().upgradeLink())->CancelRegister();
}



#pragma endregion