myvtm/Module/mod_HSPScanner/HSPScannerFSM.h

#ifndef _HSPSCANNER_FSM_H_
#define	_HSPSCANNER_FSM_H_

#pragma once

#include "SpFSM.h"
#include "HSPScannerClass.h"
#include "HSPScanner_server_g.h"
#include "DevFSMCommBase.hpp"
#include "HSPSCanner_UserErrorCode.h"

#if defined(_MSC_VER)
#include <xstring>
using namespace std;
#else
#include "DevErrorCode.h"
#endif //_MSC_VER

using namespace HSPScanner;

#define ISSUCCEEDED(hr) ((hr) == Error_Succeed)
#define FAILURED(hr) (!(ISSUCCEEDED(hr)))

#define SAFE_FREE_LIBRARY(hModule)	\
	do {							\
	if(hModule){					\
	FreeLibrary(hModule);		\
	hModule = NULL;				\
	}							\
	}while(0)




enum EvtType
{
	USER_EVT_STARTPREVIEW = (EVT_USER + 1),
	USER_EVT_STARTPREVIEW_FINISHED,
	USER_EVT_SETPROPERTYINVIEW_FINISHED,

	USER_EVT_STOPPREVIEW,
	USER_EVT_HIDEPREVIEW,
	USER_EVT_STOPPREVIEW_FINISHED,

	USER_EVT_SETWINPOS,
	USER_EVT_SETWINPOSFINISHED,
	
	USER_EVT_SCANIMAGE,
	USER_EVT_SCANIMAGE_EX,
	USER_EVT_SCANIMAGEFINISHED,
	
	USER_EVT_SHOWPROPERTY,
	USER_EVT_SHOWPROPERTY_FINISHED,

	USER_EVT_SETPROPERTY,
	USER_EVT_SETPROPERTY_FINISHED,

	USER_EVT_GETSTATUS,
	USER_EVT_GETINFO,

	USER_EVT_DISCONNECT,

	USER_EVT_RESET,
	USER_EVT_EXIT,
	USER_EVT_EXIT_FINISHED,

	USER_EVT_NOCFG,
	USER_EVT_GOTOHELL,
	USER_EVT_OPENSUCC,

	USER_EVT_QUIT
};

class StartPreviewEvent : public FSMEvent
{
public:
	StartPreviewEvent() : FSMEvent(USER_EVT_STARTPREVIEW){}
	~StartPreviewEvent(){}
	SpReqAnsContext<HSPScannerService_StartPreview_Req, HSPScannerService_StartPreview_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_StartPreview).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class StopPreviewEvent : public FSMEvent
{
public:
	StopPreviewEvent() : FSMEvent(USER_EVT_STOPPREVIEW){}
	~StopPreviewEvent(){}
	SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_CancelPreview).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class ScanImageEvent : public FSMEvent
{
public:
	ScanImageEvent() : FSMEvent(USER_EVT_SCANIMAGE){}
	~ScanImageEvent(){}
	SpReqAnsContext<HSPScannerService_ScanImage_Req, 
		HSPScannerService_ScanImage_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_ScanImage).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class ScanImageExEvent : public FSMEvent
{
public:
	ScanImageExEvent() : FSMEvent(USER_EVT_SCANIMAGE_EX){}
	~ScanImageExEvent(){}
	SpReqAnsContext<HSPScannerService_ScanImageEx_Req, 
		HSPScannerService_ScanImageEx_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_ScanImageEx).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class ShowPropertyEvent : public FSMEvent
{
public:
	ShowPropertyEvent() : FSMEvent(USER_EVT_SHOWPROPERTY){}
	~ShowPropertyEvent(){}
	SpReqAnsContext<HSPScannerService_ShowProperty_Req, 
		HSPScannerService_ShowProperty_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_ShowProperty).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class SetPropertyEvent : public FSMEvent
{
public:
	SetPropertyEvent() : FSMEvent(USER_EVT_SETPROPERTY){}
	~SetPropertyEvent(){}
	SpReqAnsContext<HSPScannerService_SetProperty_Req, 
		HSPScannerService_SetProperty_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_SetProperty).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class SetWinPosEvent : public FSMEvent
{
public:
	SetWinPosEvent() : FSMEvent(USER_EVT_SETWINPOS){}
	~SetWinPosEvent(){}
	SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
		HSPScannerService_SetWinPos_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_SetWinPos).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class GetDevStatusEvent : public FSMEvent
{
public:
	GetDevStatusEvent() : FSMEvent(USER_EVT_GETSTATUS){}
	~GetDevStatusEvent(){}
	SpReqAnsContext<HSPScannerService_GetDevStatus_Req, 
		HSPScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_GetDevStatus).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};

class GetDevInfoEvent : public FSMEvent
{
public:
	GetDevInfoEvent() : FSMEvent(USER_EVT_GETINFO){}
	~GetDevInfoEvent(){}
	SpReqAnsContext<HSPScannerService_GetDevInfo_Req, 
		HSPScannerService_GetDevInfo_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(HSPScannerService_LogCode_GetDevInfo).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, HSPScanner_UserErrorCode_FSM_INVALID);
		}
	}
};


class CHSPScannerFSM : public CCommDevFSM<CHSPScannerFSM, CHSPSClass>, public IFSMStateHooker
{
public:
	CHSPScannerFSM(void);
	~CHSPScannerFSM(void);

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

	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);

	enum {s0, s1, s2, s3, s4, s5, s6, s7, s8};

	BEGIN_FSM_STATE(CHSPScannerFSM)
		FSM_STATE_ENTRY(s0, "Idle", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "Previewing", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Property", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Failed", s3_on_entry, s3_on_exit, s3_on_event)
		FSM_STATE_ENTRY(s4, "Picturing", s4_on_entry, s4_on_exit, s4_on_event)
		FSM_STATE_ENTRY(s5, "DeviceOff", s5_on_entry, s5_on_exit, s5_on_event)
		FSM_STATE_ENTRY(s6, "HidPreviewing", s6_on_entry, s6_on_exit, s6_on_event)
		FSM_STATE_ENTRY(s7, "Exit", s7_on_entry, s7_on_exit, s7_on_event)
		FSM_STATE_ENTRY(s8, "Idiot", s8_on_entry, s8_on_exit, s8_on_event)
	END_FSM_STATE()

	
	BEGIN_FSM_RULE(CHSPScannerFSM, s0)
		//2 reserved in s0 state.
		FSM_RULE_ENTRY(s0, s1, USER_EVT_STARTPREVIEW_FINISHED, 0)
		FSM_RULE_ENTRY(s0, s3, USER_EVT_STARTPREVIEW_FINISHED, 1)
		FSM_RULE_ENTRY(s0, s0, USER_EVT_STARTPREVIEW_FINISHED, 2)

		FSM_RULE_ENTRY(s3, s1, USER_EVT_STARTPREVIEW_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_RESET, 0)
		FSM_RULE_ENTRY(s3, s3, USER_EVT_RESET, 1)
		FSM_RULE_ENTRY(s3, s1, USER_EVT_RESET, 2)
		FSM_RULE_ENTRY_ANY(s3, s0, USER_EVT_OPENSUCC)

		FSM_RULE_ENTRY(s1, s2, USER_EVT_SHOWPROPERTY, 0)
		FSM_RULE_ENTRY_ANY(s2, s1, USER_EVT_SHOWPROPERTY_FINISHED)

		//3 reserved in s1 state.
		FSM_RULE_ENTRY(s1, s3, USER_EVT_STOPPREVIEW_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s3, USER_EVT_STOPPREVIEW_FINISHED, 4)

		// Try s6 state --Josephus at 10:10:05 2016/11/22
		//FSM_RULE_ENTRY(s1, s0, USER_EVT_STOPPREVIEW_FINISHED, 1) //隐藏
		FSM_RULE_ENTRY(s1, s6, USER_EVT_STOPPREVIEW_FINISHED, 1)

		FSM_RULE_ENTRY(s1, s0, USER_EVT_STOPPREVIEW_FINISHED, 2) //关闭预览
		FSM_RULE_ENTRY(s1, s1, USER_EVT_STOPPREVIEW_FINISHED, 3) //错误还不足够严重

		FSM_RULE_ENTRY(s1, s4, USER_EVT_SCANIMAGE, 0)
		FSM_RULE_ENTRY(s1, s4, USER_EVT_SCANIMAGE_EX, 0)

		//5 reserved in s4 state.
		FSM_RULE_ENTRY(s4, s1, USER_EVT_SCANIMAGEFINISHED, 1) //删除旧照片获取照片名称失败
		FSM_RULE_ENTRY(s4, s3, USER_EVT_SCANIMAGEFINISHED, 2) //拍摄返回失败
		FSM_RULE_ENTRY(s4, s1, USER_EVT_SCANIMAGEFINISHED, 3) //EX 分配资源失败
		FSM_RULE_ENTRY(s4, s3, USER_EVT_SCANIMAGEFINISHED, 4) //打开照片文件失败

		
		FSM_RULE_ENTRY(s4, s1, USER_EVT_SCANIMAGEFINISHED, 0) //成功拍摄
		// Try s6 state. --Josephus at 11:13:02 2016/11/22
		FSM_RULE_ENTRY(s4, s6, USER_EVT_SCANIMAGEFINISHED, 6) //成功拍摄且做了隐藏操作

		FSM_RULE_ENTRY(s4, s1, USER_EVT_SCANIMAGEFINISHED, 5)

		FSM_RULE_ENTRY_ANY(s3, s5, USER_EVT_DISCONNECT)
		FSM_RULE_ENTRY(s5, s0, EVT_TIMER, 1)
		FSM_RULE_ENTRY(s5, s1, EVT_TIMER, 2)

		FSM_RULE_ENTRY(s0, s5, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(s4, s5, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(s6, s5, USER_EVT_DISCONNECT, 0)

		FSM_RULE_ENTRY(s6, s1, USER_EVT_STARTPREVIEW_FINISHED, 0) //成功预览
		FSM_RULE_ENTRY(s6, s3, USER_EVT_STARTPREVIEW_FINISHED, 1) //预览失败
		FSM_RULE_ENTRY(s6, s6, USER_EVT_STARTPREVIEW_FINISHED, 2) // 错误还不足够严重
		FSM_RULE_ENTRY(s6, s0, USER_EVT_STOPPREVIEW_FINISHED, 2) //关闭预览
		FSM_RULE_ENTRY(s6, s3, USER_EVT_STOPPREVIEW_FINISHED, 0) //关闭预览失败
		FSM_RULE_ENTRY(s6, s6, USER_EVT_STOPPREVIEW_FINISHED, 3) //错误还不足够严重


		FSM_RULE_ENTRY_ANY(s1, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(s2, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(s6, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY(s7, s0, USER_EVT_EXIT_FINISHED, 0)
		FSM_RULE_ENTRY(s7, s3, USER_EVT_EXIT_FINISHED, 1)

		FSM_RULE_ENTRY_ANY(s0, s8, USER_EVT_NOCFG)
		FSM_RULE_ENTRY_ANY(s0, s3, USER_EVT_GOTOHELL)
		
	END_FSM_RULE()

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

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

	virtual void s5_on_entry();
	virtual void s5_on_exit();
	virtual unsigned int s5_on_event(FSMEvent* e);

	virtual void s6_on_entry();
	virtual void s6_on_exit();
	virtual unsigned int s6_on_event(FSMEvent* e);

	virtual void s7_on_entry();
	virtual void s7_on_exit();
	virtual unsigned int s7_on_event(FSMEvent* e);

	virtual void s8_on_entry() {
		m_eDevStatus = DEVICE_STATUS_NOCFG;
		SetLastUserCode(HSPScanner_UserErrorCode_DLLNAME_NOCFG);
	}
	virtual void s8_on_exit() {
		m_eDevStatus = DEVICE_STATUS_NORMAL;
	}
	virtual unsigned int s8_on_event(FSMEvent* e);

	virtual void OnStateTrans(int iSrcState, int iDstState);

	int StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
		HSPScannerService_StartPreview_Ans>::Pointer ctx);

	ErrorCodeEnum SetPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
		HSPScannerService_StartPreview_Ans>::Pointer ctx);

	int StopPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx);
	
	bool ResizeImage(const CSimpleStringA& fileName);
	
	int ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req,
		HSPScannerService_ScanImage_Ans>::Pointer ctx);

	int ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx);

	int ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req, 
		HSPScannerService_ShowProperty_Ans>::Pointer ctx);

	int SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer ctx);

	int SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req,
		HSPScannerService_SetWinPos_Ans>::Pointer ctx);

	int GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx);
	
	int GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx);

	ErrorCodeEnum OnDevExit();

	void SetLastUserCode(DWORD dwCode = 0) 
	{ 
		dwLastUserCode = dwCode; 
	}
	DWORD GetLastUserCode() const
	{
		return dwLastUserCode;
	}
	LPCTSTR MapCode2RTAString(DWORD dwValue = 0);

private:
	int m_version, m_batch;

	ErrorCodeEnum m_ecSelfTest;
	DWORD m_dwErroCode;
	BOOL m_bOperating;
	int m_nTickTimes;
	int m_nFatalTimes;
	int m_nSrcState;

	int m_nRecX, m_nRecY, m_nRecW;

	DevStateEnum m_eDevStatus;
	EvtType m_desiredAction;
	CSimpleStringA m_csMachineType;
	DevCategoryInfo m_devCat;
	CSimpleStringA m_csDevNo;

	DWORD dwLastUserCode;
	DWORD m_dwMaxImageSize;

public:

	DWORD GetCustLastErrorCode() { return m_dwErroCode; }
	void SetCustLastErrorCode(DWORD dwVal = 0) { m_dwErroCode = dwVal; }

	ErrorCodeEnum TryToOpenDevice();

private:
	BOOL GetCurImageName(CSimpleStringA& csImagName, bool bExt = false);
	BOOL DelAndGetNewFileName(CSimpleStringA& csfileName, bool bInBusiness = false);
	ErrorCodeEnum DeleteFileIfExisted(LPCTSTR fileName);
	//  --Josephus at 16:33:57 20161214
	// 0: disconnected;
	// 1: connected;
	// -1: invalid;
	int IsDevConnected()
	{
		if(!m_hDevHelper || !m_bOpened) return -1;
		HspsDevStatus status = {0};
		if(m_hDevHelper->GetDevStatus(status) == Error_Succeed)
		{
			if(status.isConnected == 0)
				return 0;
			else
				return 1;
		}
		return -1;
	}
	
	void InitialMaxResizeValue();
};

struct StartPreviewTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_StartPreview_Req, HSPScannerService_StartPreview_Ans>::Pointer m_ctx;
	StartPreviewTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_STARTPREVIEW_FINISHED);
		pEvt->param1 = m_fsm->StartPreview(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_StartPreview_Req, 
		HSPScannerService_StartPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};


struct SetPropertyInPreviewTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_StartPreview_Req, HSPScannerService_StartPreview_Ans>::Pointer m_ctx;
	SetPropertyInPreviewTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SETPROPERTYINVIEW_FINISHED);
		ErrorCodeEnum eRet = m_fsm->SetPreview(m_ctx);
		m_ctx->Answer(eRet);
		if(ISSUCCEEDED(eRet))
			pEvt->param1 = 0;
		else
			pEvt->param1 = 1;
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_StartPreview_Req, 
		HSPScannerService_StartPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};


struct StopPreviewTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer m_ctx;
	StopPreviewTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_STOPPREVIEW_FINISHED);
		pEvt->param1 = m_fsm->StopPreview(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ScanImageTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_ScanImage_Req, 
		HSPScannerService_ScanImage_Ans>::Pointer m_ctx;
	ScanImageTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SCANIMAGEFINISHED);
		pEvt->param1 = m_fsm->ScanImage(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_ScanImage_Req, 
		HSPScannerService_ScanImage_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ScanImageExTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_ScanImageEx_Req, 
		HSPScannerService_ScanImageEx_Ans>::Pointer m_ctx;
	ScanImageExTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SCANIMAGEFINISHED);
		pEvt->param1 = m_fsm->ScanImageEx(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_ScanImageEx_Req, 
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ShowPropertyTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_ShowProperty_Req, 
		HSPScannerService_ShowProperty_Ans>::Pointer m_ctx;
	ShowPropertyTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SHOWPROPERTY_FINISHED);
		pEvt->param1 = m_fsm->ShowProperty(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_ShowProperty_Req, 
		HSPScannerService_ShowProperty_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct SetPropertyTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_SetProperty_Req, 
		HSPScannerService_SetProperty_Ans>::Pointer m_ctx;
	SetPropertyTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		m_fsm->SetProperty(m_ctx);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_SetProperty_Req, 
		HSPScannerService_SetProperty_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct SetWinPosTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
		HSPScannerService_SetWinPos_Ans>::Pointer m_ctx;
	SetWinPosTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		m_fsm->SetWinPos(m_ctx);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
		HSPScannerService_SetWinPos_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct GetDevStatusTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_GetDevStatus_Req, 
		HSPScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	GetDevStatusTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		m_fsm->GetDevStatus(m_ctx);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_GetDevStatus_Req, 
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct GetDevInfoTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	SpReqAnsContext<HSPScannerService_GetDevInfo_Req, 
		HSPScannerService_GetDevInfo_Ans>::Pointer m_ctx;
	GetDevInfoTask(CHSPScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		m_fsm->GetDevInfo(m_ctx);
		return;
	}
	void SetContext(
		SpReqAnsContext<HSPScannerService_GetDevInfo_Req, 
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct OpenDeviceTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	OpenDeviceTask(CHSPScannerFSM* fsm) : m_fsm(fsm) {}
	void Process()
	{
		if (!m_fsm->m_bOpened) {
				if (Error_Succeed == m_fsm->TryToOpenDevice()) {
					m_fsm->PostEventFIFO(new FSMEvent(USER_EVT_OPENSUCC));
				}
		}
	}
};

#endif //_HSPSCANNER_FSM_H_