myvtm/Module/mod_PortableScanner/PortableScannerFSM.h

#ifndef _PORTABLESCANNER_FSM_H__
#define	_PORTABLESCANNER_FSM_H__

#pragma once

#define SHIELD_APDATER_INTERFACE  1

#include "SpFSM.h"
#ifndef SHIELD_APDATER_INTERFACE
#include "HSPScannerClass.h"
#else 
enum DevStateEnum
{
	DEVICE_STATUS_NOT_READY,	//uninit
	DEVICE_STATUS_NORMAL,		//normal
	DEVICE_STATUS_MAINTAINCE,	//need to maintaince
	//ex:paper tray is empty,retain bin is full
	DEVICE_STATUS_FAULT,		//cannot work
	DEVICE_STATUS_CONNECTING,	//device connecting
	DEVICE_STATUS_NOCFG,		//the vtm has no such device
	DEVICE_STATUS_NOTHOLD       //Not hold the device.
};
#endif

#include "PortableScanner_server_g.h"
//#include "DocScannerCap.h"

using namespace PortableScanner;

class CDocScannerCap;

/*

enum CapTypeEnum {
CAMTYPE_UNKNOWN = 0,
CAMTYPE_ENV,
CAMTYPE_OPT,
CAMTYPE_EWS,
CAMTYPE_HSPS,
CAMTYPE_CIRCIE,
CAMTYPE_MAX
};

*/

#ifndef SHIELD_APDATER_INTERFACE

typedef ErrorCodeEnum ( *LpCreateDevCom)(DeviceBaseClass *&baseObj);
typedef ErrorCodeEnum ( *LpReleaseDevCom)(DeviceBaseClass *&pBaseObj);

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

#endif

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

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_NO_CONTAINS_DEVICE,
	USER_EVT_BIND_DEVICE,
	USER_EVT_BIND_DEVICE_FINISHED,
	USER_EVT_DROP_OFF_DEVICE,

	USER_EVT_ERROR_IN_PREVIEW,

	USER_EVT_QUIT
};

class BindDeviceEvent : public FSMEvent
{
public:
	BindDeviceEvent() : FSMEvent(USER_EVT_BIND_DEVICE){}
	~BindDeviceEvent(){}
	SpReqAnsContext<PortableScannerService_BindCameraDevice_Req, 
		PortableScannerService_BindCameraDevice_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class StartPreviewEvent : public FSMEvent
{
public:
	StartPreviewEvent() : FSMEvent(USER_EVT_STARTPREVIEW){}
	~StartPreviewEvent(){}
	SpReqAnsContext<PortableScannerService_StartPreview_Req, 
		PortableScannerService_StartPreview_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class StopPreviewEvent : public FSMEvent
{
public:
	StopPreviewEvent() : FSMEvent(USER_EVT_STOPPREVIEW){}
	~StopPreviewEvent(){}
	SpReqAnsContext<PortableScannerService_CancelPreview_Req,
		PortableScannerService_CancelPreview_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class ScanImageEvent : public FSMEvent
{
public:
	ScanImageEvent() : FSMEvent(USER_EVT_SCANIMAGE){}
	~ScanImageEvent(){}
	SpReqAnsContext<PortableScannerService_ScanImage_Req, 
		PortableScannerService_ScanImage_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class ScanImageExEvent : public FSMEvent
{
public:
	ScanImageExEvent() : FSMEvent(USER_EVT_SCANIMAGE_EX){}
	~ScanImageExEvent(){}
	SpReqAnsContext<PortableScannerService_ScanImageEx_Req, 
		PortableScannerService_ScanImageEx_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class ShowPropertyEvent : public FSMEvent
{
public:
	ShowPropertyEvent() : FSMEvent(USER_EVT_SHOWPROPERTY){}
	~ShowPropertyEvent(){}
	SpReqAnsContext<PortableScannerService_ShowProperty_Req, 
		PortableScannerService_ShowProperty_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class SetPropertyEvent : public FSMEvent
{
public:
	SetPropertyEvent() : FSMEvent(USER_EVT_SETPROPERTY){}
	~SetPropertyEvent(){}
	SpReqAnsContext<PortableScannerService_SetProperty_Req, 
		PortableScannerService_SetProperty_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class SetWinPosEvent : public FSMEvent
{
public:
	SetWinPosEvent() : FSMEvent(USER_EVT_SETWINPOS){}
	~SetWinPosEvent(){}
	SpReqAnsContext<PortableScannerService_SetWinPos_Req, 
		PortableScannerService_SetWinPos_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class GetDevStatusEvent : public FSMEvent
{
public:
	GetDevStatusEvent() : FSMEvent(USER_EVT_GETSTATUS){}
	~GetDevStatusEvent(){}
	SpReqAnsContext<PortableScannerService_GetDevStatus_Req, 
		PortableScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class GetDevInfoEvent : public FSMEvent
{
public:
	GetDevInfoEvent() : FSMEvent(USER_EVT_GETINFO){}
	~GetDevInfoEvent(){}
	SpReqAnsContext<PortableScannerService_GetDevInfo_Req, 
		PortableScannerService_GetDevInfo_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};



class CPortableScannerFSM : public FSMImpl<CPortableScannerFSM>, public IFSMStateHooker
{
public:
	CPortableScannerFSM(void);
	~CPortableScannerFSM(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(CPortableScannerFSM)
		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(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, "NotHold", 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(CPortableScannerFSM, 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(s0, s5, USER_EVT_DROP_OFF_DEVICE, 1)

		FSM_RULE_ENTRY(s0, s5, USER_EVT_BIND_DEVICE_FINISHED, 0)
		FSM_RULE_ENTRY(s0, s0, USER_EVT_BIND_DEVICE_FINISHED, 1)
		FSM_RULE_ENTRY(s0, s6, USER_EVT_BIND_DEVICE_FINISHED, 4)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_BIND_DEVICE_FINISHED, 6)


		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(s3, s5, USER_EVT_DROP_OFF_DEVICE, 1)
		FSM_RULE_ENTRY(s3, s5, USER_EVT_BIND_DEVICE_FINISHED, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_BIND_DEVICE_FINISHED, 1)
		FSM_RULE_ENTRY(s3, s6, USER_EVT_BIND_DEVICE_FINISHED, 4)
		FSM_RULE_ENTRY(s3, s1, USER_EVT_BIND_DEVICE_FINISHED, 6)

		FSM_RULE_ENTRY(s3, s5, USER_EVT_RESET, 0)
		FSM_RULE_ENTRY(s3, s0, USER_EVT_RESET, 1)
		FSM_RULE_ENTRY(s3, s6, USER_EVT_RESET, 4)
		FSM_RULE_ENTRY(s3, s1, USER_EVT_RESET, 6)

		//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)
		FSM_RULE_ENTRY(s1, s3, USER_EVT_ERROR_IN_PREVIEW, 0)
		// 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)

		FSM_RULE_ENTRY(s1, s5, USER_EVT_DROP_OFF_DEVICE, 1)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_BIND_DEVICE_FINISHED, 0)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_BIND_DEVICE_FINISHED, 1)
		FSM_RULE_ENTRY(s1, s6, USER_EVT_BIND_DEVICE_FINISHED, 4)
		FSM_RULE_ENTRY(s1, s1, USER_EVT_BIND_DEVICE_FINISHED, 6)

		//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(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(s6, s5, USER_EVT_DROP_OFF_DEVICE, 1)
		FSM_RULE_ENTRY(s6, s5, USER_EVT_BIND_DEVICE_FINISHED, 0)
		FSM_RULE_ENTRY(s6, s0, USER_EVT_BIND_DEVICE_FINISHED, 1)
		FSM_RULE_ENTRY(s6, s6, USER_EVT_BIND_DEVICE_FINISHED, 4)
		FSM_RULE_ENTRY(s6, s1, USER_EVT_BIND_DEVICE_FINISHED, 6)

		FSM_RULE_ENTRY_ANY(s0, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(s1, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(s3, s7, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(s4, 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, s5, USER_EVT_EXIT_FINISHED, 1)
		FSM_RULE_ENTRY(s7, s3, USER_EVT_EXIT_FINISHED, 2)

		FSM_RULE_ENTRY_ANY(s0, s5, USER_EVT_NO_CONTAINS_DEVICE)
		FSM_RULE_ENTRY(s5, s5, USER_EVT_BIND_DEVICE_FINISHED, 0)
		FSM_RULE_ENTRY(s5, s0, USER_EVT_BIND_DEVICE_FINISHED, 1)
		FSM_RULE_ENTRY(s5, s6, USER_EVT_BIND_DEVICE_FINISHED, 4)
		FSM_RULE_ENTRY(s5, s1, USER_EVT_BIND_DEVICE_FINISHED, 6)

	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() {
		Dbg("Enter Idiot status");
		m_eDevStatus = DEVICE_STATUS_NOCFG;
	}
	virtual void s8_on_exit() {
		Dbg("Leave Idiot status");
		m_eDevStatus = DEVICE_STATUS_NORMAL;
	}
	virtual unsigned int s8_on_event(FSMEvent* e);

	virtual void OnStateTrans(int iSrcState, int iDstState);

	int BindDevice(SpReqAnsContext<PortableScannerService_BindCameraDevice_Req,
		PortableScannerService_BindCameraDevice_Ans>::Pointer ctx);

	int StartPreview(SpReqAnsContext<PortableScannerService_StartPreview_Req,
		PortableScannerService_StartPreview_Ans>::Pointer ctx);

	ErrorCodeEnum SetPreview(SpReqAnsContext<PortableScannerService_StartPreview_Req,
		PortableScannerService_StartPreview_Ans>::Pointer ctx);

	int StopPreview(SpReqAnsContext<PortableScannerService_CancelPreview_Req,
		PortableScannerService_CancelPreview_Ans>::Pointer ctx);

	int ScanImage(SpReqAnsContext<PortableScannerService_ScanImage_Req,
		PortableScannerService_ScanImage_Ans>::Pointer ctx);

	int ScanImageEx(SpReqAnsContext<PortableScannerService_ScanImageEx_Req,
		PortableScannerService_ScanImageEx_Ans>::Pointer ctx);

	int ShowProperty(SpReqAnsContext<PortableScannerService_ShowProperty_Req, 
		PortableScannerService_ShowProperty_Ans>::Pointer ctx);

	int SetProperty(SpReqAnsContext<PortableScannerService_SetProperty_Req,
		PortableScannerService_SetProperty_Ans>::Pointer ctx);

	int SetWinPos(SpReqAnsContext<PortableScannerService_SetWinPos_Req,
		PortableScannerService_SetWinPos_Ans>::Pointer ctx);

	int GetDevStatus(SpReqAnsContext<PortableScannerService_GetDevStatus_Req,
		PortableScannerService_GetDevStatus_Ans>::Pointer ctx);
	
	int GetDevInfo(SpReqAnsContext<PortableScannerService_GetDevInfo_Req,
		PortableScannerService_GetDevInfo_Ans>::Pointer ctx);

	int OnDevExit();

	ErrorCodeEnum UnitTest();

	struct StuHSPSParam {
		ULONG resolutionX;
		ULONG resolutionY;
		UINT framePerSec;
	};

	ErrorCodeEnum GetHSPSParams(const CSimpleStringA& strSection, StuHSPSParam& param);

private:

#ifndef SHIELD_APDATER_INTERFACE
	int m_version, m_batch;
	HMODULE m_hVendorDll;
	LpCreateDevCom CreateDevComponent;
	LpReleaseDevCom ReleaseDevComponent;
	CHSPSClass* m_pHSPS;
#endif

	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;
	CSimpleStringA m_cameraName;

	CSimpleStringA m_csDllName;
	DevStateEnum m_eDevStatus;
	EvtType m_desiredAction;

	CDocScannerCap* m_pCapture;
	CapTypeEnum m_capCurrentType;

	DWORD m_dwEntDevelID;

public:

#ifndef SHIELD_APDATER_INTERFACE
	ErrorCodeEnum FetchVendorDllName(CSimpleStringA& csDllPath);
	ErrorCodeEnum LoadDllAndGetAddress(const char* szDllName);
	void GetAndDbgDevError();
#endif

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

private:
	BOOL GetCurImageName(CSimpleStringA& csImagName, bool bExt = false);
	BOOL DelAndGetNewFileName(CSimpleStringA& csfileName);
	ErrorCodeEnum DeleteFileIfExisted(LPCTSTR fileName);

	void RetrieveROIFromRunTime();

	void GetPortableResRatio(LPCTSTR lpcszDevName, StuHSPSParam& param);
	BOOL RetrieveVendorName(LPCTSTR lpcszDevName, CSimpleStringA& strVendorName);

	DWORD CombineEventCodeWithDevelID(DWORD dwEventCode) const
	{
		return (DWORD)((m_dwEntDevelID << 20) + dwEventCode);
	}

	DWORD CombineEventCodeWithDevID(DWORD dwDevID, DWORD dwEventCode) const
	{
		return (DWORD)((dwDevID << 16) + dwEventCode);
	}

	DWORD GetPortableDevID(LPCTSTR lpcszDevName);
	void FireLogEventMsg(DWORD dwUserPlainCode, LPCTSTR lpcszMessage);
};

struct BindDeviceTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_BindCameraDevice_Req, PortableScannerService_BindCameraDevice_Ans>::Pointer m_ctx;
	BindDeviceTask(CPortableScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_BIND_DEVICE_FINISHED);
		pEvt->param1 = m_fsm->BindDevice(m_ctx);
		pEvt->param2 = 0;
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<PortableScannerService_BindCameraDevice_Req,
		PortableScannerService_BindCameraDevice_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct StartPreviewTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_StartPreview_Req, PortableScannerService_StartPreview_Ans>::Pointer m_ctx;
	StartPreviewTask(CPortableScannerFSM* 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<PortableScannerService_StartPreview_Req, 
		PortableScannerService_StartPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};


struct SetPropertyInPreviewTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_StartPreview_Req, PortableScannerService_StartPreview_Ans>::Pointer m_ctx;
	SetPropertyInPreviewTask(CPortableScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SETPROPERTYINVIEW_FINISHED);
		ErrorCodeEnum eRet = m_fsm->SetPreview(m_ctx);
		Dbg("SetPreview returned: %d, testCode: %d.", eRet, m_ctx->Ans.reserved1);
		m_ctx->Answer(eRet);
		if(ISSUCCEEDED(eRet))
			pEvt->param1 = 0;
		else
			pEvt->param1 = 1;
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<PortableScannerService_StartPreview_Req, 
		PortableScannerService_StartPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};


struct StopPreviewTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_CancelPreview_Req,
		PortableScannerService_CancelPreview_Ans>::Pointer m_ctx;
	StopPreviewTask(CPortableScannerFSM* 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<PortableScannerService_CancelPreview_Req,
		PortableScannerService_CancelPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ScanImageTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_ScanImage_Req, 
		PortableScannerService_ScanImage_Ans>::Pointer m_ctx;
	ScanImageTask(CPortableScannerFSM* 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<PortableScannerService_ScanImage_Req, 
		PortableScannerService_ScanImage_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ScanImageExTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_ScanImageEx_Req, 
		PortableScannerService_ScanImageEx_Ans>::Pointer m_ctx;
	ScanImageExTask(CPortableScannerFSM* 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<PortableScannerService_ScanImageEx_Req, 
		PortableScannerService_ScanImageEx_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct ShowPropertyTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_ShowProperty_Req, 
		PortableScannerService_ShowProperty_Ans>::Pointer m_ctx;
	ShowPropertyTask(CPortableScannerFSM* 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<PortableScannerService_ShowProperty_Req, 
		PortableScannerService_ShowProperty_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

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

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

struct GetDevStatusTask : public ITaskSp
{
	CPortableScannerFSM* m_fsm;
	SpReqAnsContext<PortableScannerService_GetDevStatus_Req, 
		PortableScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	GetDevStatusTask(CPortableScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		m_fsm->GetDevStatus(m_ctx);
		if(m_ctx->Ans.connected == 0 && m_fsm->GetCurrState()->id != CPortableScannerFSM::s5) {
			Dbg("Detect that not have device attached and not stay in NotHold situation");
			m_fsm->PostEventFIFO(new FSMEvent(USER_EVT_NO_CONTAINS_DEVICE));
		}
		return;
	}
	void SetContext(
		SpReqAnsContext<PortableScannerService_GetDevStatus_Req, 
		PortableScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

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

#endif //_PORTABLESCANNER_FSM_H__