myvtm/Module/mod_FingerPrint/FingerPrintFSM.h

#ifndef FINGERPRINT_FSM_H
#define FINGERPRINT_FSM_H

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

#include "CommEntityUtil.hpp"

using namespace std;


enum EvtType
{
	USER_EVT_TEST = EVT_USER + 1,
	USER_EVT_INIT,
	USER_EVT_INIT_FINISHED,
	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_MATCH_FINGERPRINT,
	USER_EVT_MATCH_FINGERPRINT_FINISHED,
	USER_EVT_CANCEL_SCAN,
	USER_EVT_CANCEL_MATCH,
	USER_EVT_CANCEL_SCAN_FINISHED,
	USER_EVT_QUIT,
	USER_EVT_ERROR,
	USER_EVT_EXIT,
	USER_EVT_FWB_OPEN_SUC,
	USER_EVT_FWB_OPEN_SUC_FINISHED,
};

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)//废弃的状态
		FSM_STATE_ENTRY(s4, "Init", s4_on_entry,s4_on_exit,s4_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CFingerPrintFSM, s4)
		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, s1, USER_EVT_SCANEX, 0)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_ERROR, 0)
		FSM_RULE_ENTRY(s0, s3, USER_EVT_MATCH, 0)
		FSM_RULE_ENTRY(s0, s4, USER_EVT_FWB_OPEN_SUC_FINISHED, 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(s2, s4, USER_EVT_FWB_OPEN_SUC_FINISHED, 0)
		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)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_INIT_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_INIT_FINISHED, 2)
	END_FSM_RULE()

	CFingerPrintFSM():m_bCancelRegister(false), m_bCancelMatch(false), m_bExit(false),
					  m_testResult(Error_Succeed), m_csDevSN(""), m_iInWhatPage(PageType_Init),
					  m_csMachineType(""), m_terminalNo(""), m_machineVersion("")
					{	
						HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x204); 
					}

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

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

	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_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 DeleteBmp(int type);
	ErrorCodeEnum DeleteFileIfExisted(const char* fileName);

	ErrorCodeEnum GetDevCatInfo(DevCategoryInfo& devInfo);
	ErrorCodeEnum GetDevState(int &state);

	int Initial();
	bool GetDevInitFlag() { return m_bOpened; }
	void SetInWhatPage(int bValue) { m_iInWhatPage = bValue; }

	DevStateEnum GetDevState(){
		return m_devState;
	}

	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;
	int m_iInWhatPage/*在哪个页面，区分首页，用户桌面，其他页*/;

	CSimpleStringA m_csDevSN, m_csMachineType, m_terminalNo, m_machineVersion;
};
//废弃
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);
	}
};
//有用
struct InitTask : public ITaskSp
{
	CFingerPrintFSM* fsm;
	InitTask(CFingerPrintFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_INIT_FINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};

#endif