myvtm/Module/mod_FingerPrint/FingerPrintFSM.h

#ifndef FINGERPRINT_FSM_H
#define FINGERPRINT_FSM_H

#include "CommEntityUtil.hpp"
#include "DevFSMCommBase.hpp"
#include "FingerPrintClass.h"
#include "FingerPrint_UserErrorCode.h"

#include "DeviceBaseHelper.h"

#include "fileutil.h"
#include <ctime>



struct ScanParam
{
	CSimpleStringA m_DepPath;
	CSimpleStringA m_FullFilePath;
	CSimpleStringA m_BmpFileName;

	ULLINT m_TimeStart;
	ULLINT m_TimeEnd;
	ULLINT m_TimeLeft;

	LPBYTE m_Feature;
	LPBYTE m_Template;
	int m_FeatureLen;

	bool m_ScanSuc;
	bool m_GetTemplateSuc;
	bool m_NotFindImage;
	bool m_FeatureIsNull;
	bool m_bLenIsNotRight;
	bool m_bGetFingerPrintSuc;
	bool m_Quit;
};

enum OperateType
{
	RegisterType = 1,
	MatchType
};

enum EvtType
{
	USER_EVT_TEST = EVT_USER + 1,
	USER_EVT_GET_DEVINFO,
	USER_EVT_SCAN,
	USER_EVT_SCAN_FINISHED,
	USER_EVT_SCANEX,
	USER_EVT_SCANEX_FINISHED,
	USER_EVT_MATCH,
	USER_EVT_MATCH_FINISHED,
	USER_EVT_GETFINGER,
	USER_EVT_GETFINGER_FINISHED,
	USER_EVT_GENERATE_TEMPLATE,
	USER_EVT_GENERATE_TEMPLATE_FINISHED,
	USER_EVT_CANCEL_SCAN,
	USER_EVT_CANCEL_MATCH,
	USER_EVT_CANCEL_SCAN_FINISHED,
	USER_EVT_QUIT,
	USER_EVT_ERROR,
	USER_EVT_EXIT
};

enum BmpType
{
	BmpImage = 1,
	TestImage
};

#include "FingerPrint_server_g.h"
#include "FingerPrintClass.h"
using namespace FingerPrint;

class ScanEvent : public FSMEvent
{
public:
	ScanEvent() : FSMEvent(USER_EVT_SCAN){}
	virtual ~ScanEvent(){}
	SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ScanEvent unhandled.");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class ScanExEvent : public FSMEvent
{
public:
	ScanExEvent() : FSMEvent(USER_EVT_SCANEX) {}
	virtual ~ScanExEvent() {}
	SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ScanEx unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class GetFingerEvent : public FSMEvent
{
public:
	GetFingerEvent() : FSMEvent(USER_EVT_GETFINGER) {}
	virtual ~GetFingerEvent() {}
	SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			ctx->Answer(Error_InvalidState);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetFinger unhandled");
		}
	}
};

class GenerateTemplateEvent : public FSMEvent
{
public:
	GenerateTemplateEvent() : FSMEvent(USER_EVT_GENERATE_TEMPLATE) {}
	virtual ~GenerateTemplateEvent() {}
	SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			ctx->Answer(Error_InvalidState);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GenerateTemplate unhandled.");
		}
	}
};

class CancelRegisterEvent : public FSMEvent
{
public:
	CancelRegisterEvent() : FSMEvent(USER_EVT_CANCEL_SCAN){}
	virtual ~CancelRegisterEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Cancel scan not handled");
	}
};

class MatchEvent : public FSMEvent
{
public:
	MatchEvent() : FSMEvent(USER_EVT_MATCH){}
	virtual ~MatchEvent(){}
	SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			ctx->Answer(Error_InvalidState);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Match unhandled.");
		}
	}
};

class MatchFinishedEvent : public FSMEvent
{
public:
	MatchFinishedEvent() : FSMEvent(USER_EVT_MATCH_FINISHED){}
	~MatchFinishedEvent(){}
	SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Match finished unhandled.");
		}
	}
};

class GetFingerFinishedEvent : public FSMEvent
{
public:
	GetFingerFinishedEvent() : FSMEvent(USER_EVT_GETFINGER_FINISHED) {}
	~GetFingerFinishedEvent() {}
	SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetFingerFinished unhandled.");
		}
	}
};

class CancelMatchEvent : public FSMEvent
{
public:
	CancelMatchEvent() : FSMEvent(USER_EVT_CANCEL_MATCH){}
	virtual ~CancelMatchEvent(){}
	virtual void OnUnhandled()
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Cancel match not handled");
	}
};

class GetDevInfoEvent : public FSMEvent
{
public:
	GetDevInfoEvent() : FSMEvent(USER_EVT_GET_DEVINFO){}
	virtual ~GetDevInfoEvent(){}
	SpReqAnsContext<FingerPrintService_GetDevInfo_Req, FingerPrintService_GetDevInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if(ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};

class CFingerPrintFSM : public CCommDevFSM<CFingerPrintFSM, FingerPrintClass>
{
public:
	enum {s0, s1, s2, s3, s4};

	BEGIN_FSM_STATE(CFingerPrintFSM)
		FSM_STATE_ENTRY(s0, "Normal", s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1, "Scan", s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2, "Fail", s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3, "Match", s3_on_entry,s3_on_exit,s3_on_event)//废弃的状态
	END_FSM_STATE()

	BEGIN_FSM_RULE(CFingerPrintFSM, s0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_SCAN, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_SCANEX, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_GETFINGER, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_GENERATE_TEMPLATE, 0)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_ERROR, 0)
		FSM_RULE_ENTRY(s0, s3, USER_EVT_MATCH, 0)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_SCAN_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_SCAN_FINISHED, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_SCANEX_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_SCANEX_FINISHED, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_GETFINGER_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_GETFINGER_FINISHED, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_GENERATE_TEMPLATE_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_GENERATE_TEMPLATE_FINISHED, 2)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_MATCH_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s2, USER_EVT_MATCH_FINISHED, 2)
	END_FSM_RULE()

	CFingerPrintFSM(): m_bCancelRegister(false), m_bCancelMatch(false), m_bExit(false),
					   m_testResult(Error_Succeed), m_csDevSN(""), m_devInit(false)
	{
		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x204);
		m_FirstStart = TRUE;
		ZeroMemory(&m_adapterInfo, sizeof(m_adapterInfo));
	};

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* e);

	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* e);

	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* e);

	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* e);

	int GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx);
	int GenerateTemplate(SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx);
	void CollectProcess(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer& ctx);
	void ProcessAfterCollect(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer& ctx);

	void DeleteBmp(int type);
	ErrorCodeEnum DeleteFileIfExisted(const char* fileName);

	int GetImageAndFeature(SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer ctx);//废弃
	int GetImageAndFeatureEx(SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer ctx);//废弃
	ErrorCodeEnum Match(SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx);//废弃
	ErrorCodeEnum GetDevCatInfo(DevCategoryInfo& devInfo);//废弃
	ErrorCodeEnum GetDevState(int &state);//废弃


	ErrorCodeEnum DoDevOpen(CSmartPointer<IConfigInfo> spConfig);
	ErrorCodeEnum DoGetDevInfo();
	ErrorCodeEnum QueryRootConfigObj(CSmartPointer<IConfigInfo> &spConfig);
	ErrorCodeEnum InitCommParam(ScanParam* initParam, int type, int scanTime, int templateNum = -1);
	ErrorCodeEnum ExtractVendorLib(CSimpleStringA& strLibFullPath);
//	CSimpleString GenerateAlarmJson(CSimpleString entityName, int cost);

	bool GetDevInitFlag() { return m_devInit; }
	bool IsFWBDevice(CSimpleString& vendorName);//废弃 蓝牙多合一判断
	ErrorCodeEnum InitParamBeforeScan(ScanParam *initParam, int scanTime);//废弃 GetImageAndFeature和GetImageAndFeatureEx引用
	void ScanProcess(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer &ctx);//废弃 GetImageAndFeature引用
	void ScanProcessEx(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer& ctx);//废弃 GetImageAndFeatureEx引用
	void ProcessAfterScan(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer& ctx);//废弃 GetImageAndFeature引用
	void ProcessAfterScanEx(ScanParam* pScanParam, SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer& ctx);//废弃 GetImageAndFeatureEx引用
	ErrorCodeEnum InitParamBeforeMatch(ScanParam* initParam, int templateNum);//废弃 Match引用
	void ScanBeforeMatch(ScanParam* initParam);//废弃 Match引用
	ErrorCodeEnum MatchProcess(ScanParam* initParam, SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer& ctx);//废弃 Match引用
	
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);

private:
	ErrorCodeEnum m_testResult;
	DevCategoryInfo m_devCatInfo;
	DevStateEnum m_devState;
	
	bool m_bCancelRegister;
	bool m_bCancelMatch;
	bool m_bExit;

	CSimpleStringA m_csDevSN;//蓝牙多合一设备sn
	bool m_devInit;//和DevFSMCommBase 里面的m_bOpened变量一致
	CSimpleStringA m_BmpFileFullPath1;//废弃
	CSimpleStringA m_BmpFileFullPath2;//废弃
	CSimpleStringA m_BmpFileFullPath3;//废弃
	
};
//废弃
struct ScanTask : public ITaskSp   
{
	CFingerPrintFSM* fsm;
	SpReqAnsContext<FingerPrintService_GetImageAndFeature_Req, FingerPrintService_GetImageAndFeature_Ans>::Pointer ctx;
	ScanTask(CFingerPrintFSM* f) : fsm(f){}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e = new FSMEvent(USER_EVT_SCAN_FINISHED);
		e->param1 = fsm->GetImageAndFeature(ctx);
		fsm->PostEventFIFO(e);
	}
};
//废弃
struct ScanExTask : public ITaskSp   
{
	CFingerPrintFSM* fsm;
	SpReqAnsContext<FingerPrintService_GetImageAndFeatureEx_Req, FingerPrintService_GetImageAndFeatureEx_Ans>::Pointer ctx;
	ScanExTask(CFingerPrintFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e = new FSMEvent(USER_EVT_SCANEX_FINISHED);
		e->param1 = fsm->GetImageAndFeatureEx(ctx);
		fsm->PostEventFIFO(e);
	}
};
//有用
struct GetFingerTask : public ITaskSp   
{
	CFingerPrintFSM* fsm;
	SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx;
	GetFingerTask(CFingerPrintFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e = new FSMEvent(USER_EVT_GETFINGER_FINISHED);
		e->param1 = fsm->GetFingerPrint(ctx);
		fsm->PostEventFIFO(e);
	}
};
//有用
struct GenerateTemplateTask : public ITaskSp
{
	CFingerPrintFSM* fsm;
	SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx;
	GenerateTemplateTask(CFingerPrintFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e = new FSMEvent(USER_EVT_GENERATE_TEMPLATE_FINISHED);
		e->param1 = fsm->GenerateTemplate(ctx);
		fsm->PostEventFIFO(e);
	}
};
//废弃
struct MatchTask : public ITaskSp
{
	CFingerPrintFSM* fsm;
	SpReqAnsContext<FingerPrintService_Match_Req, FingerPrintService_Match_Ans>::Pointer ctx;
	MatchTask(CFingerPrintFSM* f) : fsm(f){}
	void Process()
	{
		LOG_FUNCTION();
		MatchFinishedEvent* e = new MatchFinishedEvent();
		e->param1 = fsm->Match(ctx);
		e->ctx = ctx;
		fsm->PostEventFIFO(e);
	}
};

#endif