myvtm/Module/mod_DeviceControl/DeviceControlFSM.h

#ifndef _DEVICE_CONTROL_FSM_H
#define _DEVICE_CONTROL_FSM_H

#pragma once

#include "stdafx.h"
#include "SpFSM.h"

#include "DeviceControl_def_g.h"
#include "DeviceControl_server_g.h"
#include "DeviceControlClass.h"
#include "DevFSMCommBase.hpp"

#include "Interface.h"

#include "Gpio_client_g.h"

using namespace DeviceControl;
using namespace Gpio;

typedef int  (__stdcall *lpInitToken)(char* pszCertType,int& nTokenType,char* pszOldSuperPwd,char* pszUserName,char* pszUserIDType,\
	char* pszUserIDNo,char* pszTokenSn, int& nTokenSn,char* pszPKCS10,  int& nPKCS10,char* pszMsg,     int& nMsg);
typedef	int (__stdcall *lpGetUKeyID)(char *pUKeyID, int &nUKeyID);

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_USB,
	USER_EVT_USB_FINISHED,
	USER_EVT_GET_UKEYID,
	USER_EVT_GET_UKEYID_FINISHED,
	USER_EVT_INIT_TOKEN,
	USER_EVT_INIT_TOKEN_FINISHED,
	USER_EVT_QUERY_USB,
	USER_EVT_QUERY_USB_FINISHED,
	USER_EVT_WORKING_OP,

};
class USBEvent : public FSMEvent
{
public:
	USBEvent() : FSMEvent(USER_EVT_USB){}
	virtual ~USBEvent(){}
	SpReqAnsContext<DeviceControlService_USB_Req,DeviceControlService_USB_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class QueryUSBEvent : public FSMEvent
{
public:
	QueryUSBEvent() : FSMEvent(USER_EVT_QUERY_USB){}
	virtual ~QueryUSBEvent(){}
	SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req,DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class GetUkeyIDEvent : public FSMEvent
{
public:
	GetUkeyIDEvent() : FSMEvent(USER_EVT_GET_UKEYID){}
	virtual ~GetUkeyIDEvent(){}
	SpReqAnsContext<DeviceControlService_GetUkeyID_Req,DeviceControlService_GetUkeyID_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class InitTokenEvent : public FSMEvent
{
public:
	InitTokenEvent() : FSMEvent(USER_EVT_INIT_TOKEN){}
	virtual ~InitTokenEvent(){}
	SpReqAnsContext<DeviceControlService_InitToken_Req,DeviceControlService_InitToken_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class CDeviceControlFSM : public CCommDevFSM<CDeviceControlFSM, DeviceControlClass>
{
public:
	enum {s0,s1,s2,s3,s4};

	BEGIN_FSM_STATE(CDeviceControlFSM)
		FSM_STATE_ENTRY(s0,"Idle",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"USB",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Failed",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"GetUkeyID",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"InitToken",s4_on_entry,s4_on_exit,s4_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(CDeviceControlFSM, s0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_USB, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_QUERY_USB, 0)
		FSM_RULE_ENTRY(s0, s3, USER_EVT_GET_UKEYID, 0)
		FSM_RULE_ENTRY(s0, s4, USER_EVT_INIT_TOKEN, 0)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_USB_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_USB_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_QUERY_USB_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s2, USER_EVT_QUERY_USB_FINISHED, 1)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_GET_UKEYID_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_GET_UKEYID_FINISHED, 1)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_INIT_TOKEN_FINISHED, 0)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_INIT_TOKEN_FINISHED, 1)
		END_FSM_RULE()

		CDeviceControlFSM():m_testResult(Error_Succeed), m_hTokenDll(NULL),AQGetUKeyID(NULL),AQInitToken(NULL)
	,m_bWorkingOp(false), m_bFWB(false){};
	virtual ~CDeviceControlFSM() {};

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

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

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

	virtual void s2_on_entry() {}
	virtual void s2_on_exit() {}
	virtual unsigned int s2_on_event(FSMEvent* e) { return 0; }

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

	virtual void s4_on_entry() {}
	virtual void s4_on_exit() {}
	virtual unsigned int s4_on_event(FSMEvent* e);

	int UsbControl(SpReqAnsContext<DeviceControlService_USB_Req,DeviceControlService_USB_Ans>::Pointer ctx);
	int GetUkeyIDx(SpReqAnsContext<DeviceControlService_GetUkeyID_Req, DeviceControlService_GetUkeyID_Ans>::Pointer ctx);
	int InitTokenx(SpReqAnsContext<DeviceControlService_InitToken_Req, DeviceControlService_InitToken_Ans>::Pointer ctx);
	int QueryUSB(SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req,DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx);
	void WorkingOp();
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	ErrorCodeEnum InitializeTokenLib();

private:
	ErrorCodeEnum m_testResult;
	HMODULE m_hTokenDll;
	lpInitToken AQInitToken;
	lpGetUKeyID AQGetUKeyID;
	CSimpleStringA m_csMachineType;
	bool m_bWorkingOp, m_bFWB;
};

struct OpenTask : public ITaskSp
{
	CDeviceControlFSM* fsm;
	OpenTask(CDeviceControlFSM* f) : fsm(f) {}
	SpReqAnsContext<DeviceControlService_USB_Req,DeviceControlService_USB_Ans>::Pointer ctx;

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_USB_FINISHED);
		e->param1 = fsm->UsbControl(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct QueryUSBTask : public ITaskSp
{
	CDeviceControlFSM* fsm;
	QueryUSBTask(CDeviceControlFSM* f) : fsm(f) {}
	SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req,DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx;

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_QUERY_USB_FINISHED);
		e->param1 = fsm->QueryUSB(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct GetUkeyIDTask : public ITaskSp
{
	CDeviceControlFSM* fsm;
	GetUkeyIDTask(CDeviceControlFSM* f) : fsm(f) {}
	SpReqAnsContext<DeviceControlService_GetUkeyID_Req,DeviceControlService_GetUkeyID_Ans>::Pointer ctx;

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_GET_UKEYID_FINISHED);
		e->param1 = fsm->GetUkeyIDx(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct InitTokenTask : public ITaskSp
{
	CDeviceControlFSM* fsm;
	InitTokenTask(CDeviceControlFSM* f) : fsm(f) {}
	SpReqAnsContext<DeviceControlService_InitToken_Req,DeviceControlService_InitToken_Ans>::Pointer ctx;

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_INIT_TOKEN_FINISHED);
		e->param1 = fsm->InitTokenx(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct WorkingOpTask : public ITaskSp
{
	CDeviceControlFSM* fsm;
	WorkingOpTask(CDeviceControlFSM* f) : fsm(f) {}

	void Process()
	{
		fsm->WorkingOp();
	}
};
#endif //_DEVICE_CONTROL_FSM_H