myvtm/Module/mod_ScannerSet/ScannerSetFSM.h

#ifndef _SCANNERSET_FSM_H_
#define	_SCANNERSET_FSM_H_

#pragma once

#include "SpFSM.h"
#include "ScannerSet_server_g.h"
#include "ScannerSet_msg_g.h"
using namespace ScannerSet;

#define SS_MAX_METHOD_COUNT 11

#include "HSPScanner_client_g.h"
#include "PortableScanner_client_g.h"
#include "MediaController_client_g.h"
using namespace HSPScanner;
using namespace PortableScanner;

#if defined(RVC_OS_WIN)
#include "CameraImpl.h"
#else
#include <mutex>
#endif //RVC_OS_WIN
#include "DeviceCrossHelper.h"
#include "EventCode.h"
#include "ScannerSet_UserErrorCode.h"
#include "CameraOccupySysVar.hpp"

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

#define DECLARE_ENTITY_CLIENT_ENTITY(tEntityName, tEntityBaseName) \
	class C##tEntityName##Client : public tEntityBaseName##_ClientBase \
	{ \
	public: \
		C##tEntityName##Client(CEntityBase *pEntity) \
		:tEntityBaseName##_ClientBase(pEntity) \
	{/*empty constructor*/ } \
	}

class CHSPSInnerClient : public HSPScannerService_ClientBase
{
public:
	CHSPSInnerClient(CEntityBase *pEntity)
		:HSPScannerService_ClientBase(pEntity)
	{

	}
};

class CPortableScannerClient : public PortableScannerService_ClientBase
{
public:
	CPortableScannerClient(CEntityBase *pEntity)
		:PortableScannerService_ClientBase(pEntity)
	{

	}
};

class CMediaCtrlClient : public MediaController::MediaService_ClientBase
{
public:
	CMediaCtrlClient(CEntityBase *pEntity)
		:MediaController::MediaService_ClientBase(pEntity)
	{

	}
};

template<typename TEntity>
struct AvailableEntityCheck {
	typedef TEntity Type;
	bool operator()(CEntityBase* base) {
		Type* pCheckClient = new Type(base);
		ErrorCodeEnum erroCode = pCheckClient->Connect();
		if(FAILURED(erroCode))
		{
			pCheckClient->SafeDelete();
			pCheckClient = NULL;
			return false;
		}
		pCheckClient->GetFunction()->CloseSession();
		pCheckClient = NULL;
		return true;
	}
};

struct ScannerDeviceInfo
{
	CSimpleStringA strDevName;
	CapTypeEnum devType;
	BOOL bIdle;
	int devIdx;
};

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

	USER_EVT_STOPPREVIEW,
	USER_EVT_STOPPREVIEW_FINISHED,

	USER_EVT_SETWINPOS,
	USER_EVT_SETWINPOS_FINISHED,
	
	USER_EVT_SCANIMAGE,
	USER_EVT_SCANIMAGEFINISHED,
	
	USER_EVT_SETPROPERTY,
	USER_EVT_SETPROPERTY_FINISHED,

	USER_EVT_SHOWPROPERTY,
	USER_EVT_SHOWPROPERTY_FINISHED,

	USER_EVT_GETSTATUS,
	USER_EVT_GETSTATUS_FINISHED,
	USER_EVT_GETINFO,
	USER_EVT_GETINFO_FINISHED,

	USER_EVT_CROSS_CALL,
	USER_EVT_CROSS_CALL_FINISHED,

	USER_EVT_CROSS_CALL_ONEWAY,
	USER_EVT_CROSS_CALL_ONEWAY_FINISHED,

	USER_EVT_DEV_INVALID,
	USER_EVT_DEV_RECOVER,

	USER_EVT_OPERATING,
	USER_EVT_RESET,
	USER_EVT_EXIT,
	USER_EVT_QUIT,

	//////////////////////////////////////////////////////////////////////////
	USER_EVT_ESTIMATE,
	USER_EVT_ESTIMATE_FINISHED,

	USER_EVT_CAMERA_INSERD,
	USER_EVT_CAMERA_REMOVED
};

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

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

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

class OperatingEvent: public FSMEvent
{
public:
	OperatingEvent(int iEvt):FSMEvent(USER_EVT_OPERATING),m_bindEvt(iEvt) {}
	~OperatingEvent(){}
	int m_bindEvt;
};

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

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

class SetWinPosEvent : public FSMEvent
{
public:
	SetWinPosEvent() : FSMEvent(USER_EVT_SETWINPOS){}
	~SetWinPosEvent(){}
	SpReqAnsContext<ScannerService_SetWindowPos_Req, 
		ScannerService_SetWindowPos_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		if(m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("set winpos unhandle!");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_FSM_INVALID);
		}
	}
};

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

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

class CScannerFSM : public FSMImpl<CScannerFSM>, public IFSMStateHooker
{
public:
	CScannerFSM(void);
	~CScannerFSM(void);

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

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

	enum {s0, s1, s2, s3, s4};

	BEGIN_FSM_STATE(CScannerFSM)
		FSM_STATE_ENTRY(s0, "Idle", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "Estimate", s1_on_entry, s1_on_exit, s1_on_event) //no used now!!!
		FSM_STATE_ENTRY(s2, "Operating", 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, "Invalid", s4_on_entry, s4_on_exit, s4_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CScannerFSM, s0)


		FSM_RULE_ENTRY_ANY(s0, s4, USER_EVT_DEV_INVALID)
		FSM_RULE_ENTRY_ANY(s4, s0, USER_EVT_DEV_RECOVER)

		FSM_RULE_ENTRY_ANY(s0, s2, USER_EVT_OPERATING)
		/*S2 中所有处理结果都返回1，见 s2_on_event 实现*/
		FSM_RULE_ENTRY(s2, s0, USER_EVT_STARTPREVIEW_FINISHED, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_STOPPREVIEW_FINISHED, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_SCANIMAGEFINISHED, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_SETPROPERTY_FINISHED, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_SHOWPROPERTY_FINISHED, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_SETWINPOS_FINISHED, 1)

	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 OnStateTrans(int iSrcState, int iDstState);

	int StartPreview(SpReqAnsContext<ScannerService_StartPreview_Req,
		ScannerService_StartPreview_Ans>::Pointer ctx);

	int StopPreview(SpReqAnsContext<ScannerService_CancelPreview_Req,
		ScannerService_CancelPreview_Ans>::Pointer ctx);

	int ScanImage(SpReqAnsContext<ScannerService_ScanImage_Req,
		ScannerService_ScanImage_Ans>::Pointer ctx);

	int SetProperty(SpReqAnsContext<ScannerService_SetProperty_Req, 
		ScannerService_SetProperty_Ans>::Pointer ctx);

	int ShowLTProperty(SpReqAnsContext<ScannerService_ShowProperty_Req,
		ScannerService_ShowProperty_Ans>::Pointer ctx);

	int SetWinPos(SpReqAnsContext<ScannerService_SetWindowPos_Req,
		ScannerService_SetWindowPos_Ans>::Pointer ctx);

	int GetDevStatus(SpReqAnsContext<ScannerService_GetDevStatus_Req,
		ScannerService_GetDevStatus_Ans>::Pointer ctx);
	
	int GetDevInfo(SpReqAnsContext<ScannerService_GetDevInfo_Req,
		ScannerService_GetDevInfo_Ans>::Pointer ctx);

	int GetOnlineDevices(SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
		ScannerService_GetOnlineCameras_Ans>::Pointer ctx);

	ErrorCodeEnum DropOffPortScannerDevice(bool skipToCheck = true);

	void InitializeMehodQueue();
	void DestoryMethodQueue();

	ErrorCodeEnum OnDevExit();
	ErrorCodeEnum AttachCheck();
	ErrorCodeEnum AttachReleaseIfNecessary();

	bool IsWorking() {
		return (GetCurrState()->id == s2);
	}

	const char* GetChildEntityName() {
		if(m_bUsePortableScanner) {
			return "PortableScanner";
		} else {
			return "HSPSCanner";
		}
	}

	void OnChildEntityStateChange(const EntityStateEnum& oldState, const EntityStateEnum& curState);

private:

	CSimpleStringA m_csMachineType;
	CSimpleStringA m_csSite;
	bool m_bPadMachine;
	bool m_bStand2SMachine;
	bool m_bDesk2SMachine;
	bool m_bUsePortableScanner;

	CHSPSInnerClient* m_pHSPSClient;
	CPortableScannerClient* m_pPortableClient;
	CMediaCtrlClient* m_pMediaControlClient;

	ErrorCodeEnum m_ecSelfTest;
	DWORD m_dwErroCode;
	int m_nFatalTimes;
	int m_nSrcState;
	CSimpleStringA m_strTerminalNo;

	int m_iEvt;

	HRESULT m_hrCoInited;

#if defined(RVC_OS_WIN)
    CAMERA_BUCKET m_cameralist;
	CRITICAL_SECTION cs_devEvt;
#else
    std::mutex mMtx;
#endif //RVC_OS_WIN
	

	static const int FIX_CAMERA_COUNTS = 3;
	ScannerDeviceInfo m_fixedCamera[FIX_CAMERA_COUNTS];

	CSimpleStringA m_strEwsRecordName;
	bool m_bEwsNameRefreshed;

	LIST_ENTRY ContextListHead;
	TC_ENTITY_INTERFACE_QUEUE m_methods[SS_MAX_METHOD_COUNT];

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

	void OnDeviceInsert();
	void OnDeviceRemoved();
	void PSEntityPostCameraError(LPCTSTR lpcszCameraName);

public:

	bool IsHSPSConnectSessionOK();
	bool IsPortableConnectSessionOK();

	ErrorCodeEnum CheckHSPSConnectStatus();
	ErrorCodeEnum ConnectToHSPScanner();
	void FreeHSPScannerClient()
	{
		if(m_pHSPSClient)
		{
			m_pHSPSClient->GetFunction()->CloseSession();
			m_pHSPSClient = NULL;
		}
	}
	ErrorCodeEnum GetHSPSInfo();

	ErrorCodeEnum CheckPortableConnectStatus();
	ErrorCodeEnum ConnectToPortableScanner();
	void FreePortableScannerClient()
	{
		if(m_pPortableClient) {
			m_pPortableClient->GetFunction()->CloseSession();
			m_pPortableClient = NULL;
		}
	}

	bool IsNoralEntityState(const EntityStateEnum& state) {
		if(state == EntityState_Idle || state == EntityState_Busy 
			|| state == EntityState_Pause
			|| state == EntityState_UnLoading) {
				return true;
		}
		return false;

	}

	ErrorCodeEnum GetPortableScannerInfo() {
		EntityStateEnum state = EntityState_NoStart;
		ErrorCodeEnum rc = GetEntityCurState(state, "PortableScanner");
		LogWarn(Severity_Low,Error_Debug,LOG_ERR_SCANNERSET_PORTABLESCANNER_STATE,
			CSimpleStringA::Format("PortableScanner entity state: %d(%u)", state, rc));
		if(rc == Error_Succeed && IsNoralEntityState(state)) {
				//let it empty.	
		} else if(IsPortScanHoldEnvCameraFromSysVar()){
			HandleCamereAccessPriviledge(false, CAMTYPE_ENV, m_fixedCamera[CAMTYPE_ENV-1].strDevName);
			ClearPortScanHoldLimitedDevice(CAMTYPE_MAX);
		}
		return rc;
	}

	ErrorCodeEnum IsPortScanHoldDevice(ScannerDeviceInfo* pInfo, int& curState);
	ErrorCodeEnum IsPortScanHoldDevice(bool& hasHolden, int& DevID, CSimpleStringA& strDevName, bool& bBusy);
	bool IsPortScanHoldLimitedDevice(CapTypeEnum& devType);
	bool IsPortScanHoldEnvCameraFromSysVar()
	{
		CapTypeEnum devType(CAMTYPE_UNKNOWN);
		return (IsPortScanHoldLimitedDevice(devType) && devType == CAMTYPE_ENV);
	}
	void ClearPortScanHoldLimitedDevice(const CapTypeEnum& devType, const char* lpcszDevName = NULL);
	
	ErrorCodeEnum TryBindPSDevice(int nDevID, LPCTSTR lpcszDevName);
	ErrorCodeEnum BindPSDevice(int nDevID, LPCTSTR lpcszDevName);
	int GetAdvancedScannerDevice(ScannerDeviceInfo* pDevInfo);
	int GetAdvancedScannerDeviceEx(ScannerDeviceInfo* pDevInfo, 
		const CAutoArray<CSimpleStringA>& caForbitDeviceNames);

	void SendBroadcastAbout();
	void WaitPortableReleaseCamera(int nCameraType, DWORD dwTimeoutMilSec = 3000);

	ErrorCodeEnum ConnectToMediaController();
	void FreeMediaControllerClient()
	{
		if(m_pMediaControlClient) {
			m_pMediaControlClient->GetFunction()->CloseSession();
			m_pMediaControlClient = NULL;
		}
	}
	ErrorCodeEnum GetMediaControllerInfo(EntityStateEnum& curState) {
		EntityStateEnum state = EntityState_NoStart;
		ErrorCodeEnum rc = GetEntityCurState(state, "MediaController");
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("MediaController entity state: %d(%u)", state, rc);
		curState = state;
		return rc;
	}

	ErrorCodeEnum AccessCamerePriviledge(bool fWinOver, int nCameraType);
	ErrorCodeEnum HandleCamereAccessPriviledge(bool fWinOver, int nCameraType, const char* lpcszDevName);

	UINT UnitTest();
	void AfterInit();

private:

	ErrorCodeEnum GetEntityCurState(EntityStateEnum& state, LPCTSTR lpcszEntityName) 
	{
		CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
		CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege =
			pFunc.ConvertCase<IEntityFunctionPrivilege>();
		CEntityRunInfo info = {0};
		ErrorCodeEnum ecInfo = pFunc->GetEntityRunInfo(lpcszEntityName, info);
		if(ISSUCCEEDED(ecInfo)) {
			state = info.eState;
		}
		return ecInfo;
	}

	bool IsSuitableEntityAvailable() 
	{
		if((m_bStand2SMachine && ISSUCCEEDED(ConnectToHSPScanner()))
			|| ( (m_bUsePortableScanner) && ISSUCCEEDED(ConnectToPortableScanner()))) {
				return true;
		}
		return false;
	}

	void ReleaseSuitableEntity() 
	{
		if(m_bStand2SMachine) {
			FreeHSPScannerClient();
		}else if(m_bUsePortableScanner) {
			FreePortableScannerClient();
		}
		return;
	}

	ErrorCodeEnum LoadConfigAboutCamera();
	CapTypeEnum GetRVCCameraType(LPCTSTR lpcszDevName);
	/**
	*	Determine that whether the camera named by %strDeviceID% is HSPS-Type
	*   bUpstairOne is TRUE if the camera is pluggable by USB whereas is FALSE if fixed
	*/
	bool IsPortableScannerDetected(LPCTSTR strDeviceID, BOOL& bUpstairOne);
	int GetCurrentCameraList(CAutoArray<ScannerDeviceInfo>& devInforLists, bool bUpdatedRecord = false);

#if defined(RVC_OS_WIN)
    void RefreshCameraBusyState(CAutoArray<ScannerDeviceInfo>& devInforLists, const CAMERA_BUCKET& buckets, int bucketSize);
#endif //RVC_OS_WIN

	ErrorCodeEnum _BindPSDevice(int nDevID, LPCTSTR lpcszDevName, bool bForce = false);

	bool FindEwsCameraName(CSimpleStringA& strRetrievedName, const CSimpleStringA& strRootName);
	bool IsEwsCamera(LPCTSTR lpcszDevfriendlyName);

	template <class TReq, class TAns>
	PVOID inline TransferCtx(CSmartPointer<SpReqAnsContext<TReq, TAns> > ctx)
	{
		return (PVOID)ctx.GetRawPointer();
		//return reinterpret_cast<PVOID>(ctx.GetRawPointer());
	}

	bool ShouldUsePortableScanner() const {
		return (m_bPadMachine || m_bDesk2SMachine);
	}
};

struct StartPreviewTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_StartPreview_Req, ScannerService_StartPreview_Ans>::Pointer m_ctx;
	StartPreviewTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_STARTPREVIEW_FINISHED);
		auto rc = m_fsm->AttachCheck();
		if(ISSUCCEEDED(rc)) {
			pEvt->param1 = m_fsm->StartPreview(m_ctx);
		}else {
			m_ctx->Answer(rc, LOG_WARN_ATTACH_FAILED);
			pEvt->param1 = 10;
		}
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_StartPreview_Req, 
		ScannerService_StartPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct StopPreviewTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_CancelPreview_Req,
		ScannerService_CancelPreview_Ans>::Pointer m_ctx;
	StopPreviewTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_STOPPREVIEW_FINISHED);
		const bool bOnlyHide = m_ctx->Req.reserved1 == 0 ? false : true;
		pEvt->param1 = m_fsm->StopPreview(m_ctx);
		if(!bOnlyHide) {
			m_fsm->AttachReleaseIfNecessary();
		}
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_CancelPreview_Req,
		ScannerService_CancelPreview_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

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

struct SetPropertyTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_SetProperty_Req, 
		ScannerService_SetProperty_Ans>::Pointer m_ctx;
	SetPropertyTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SETPROPERTY_FINISHED);
		pEvt->param1 = m_fsm->SetProperty(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_SetProperty_Req, 
		ScannerService_SetProperty_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

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


struct PendingTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_SetWindowPos_Req, 
		ScannerService_SetWindowPos_Ans>::Pointer m_ctx;
	PendingTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		LOG_FUNCTION();
		WaitingFSMForIdle();
		SetWinPosEvent* pEvent = new SetWinPosEvent();
		pEvent->m_ctx = m_ctx;
		m_fsm->PostEventFIFO(pEvent);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_SetWindowPos_Req, 
		ScannerService_SetWindowPos_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}

private:

	void WaitingFSMForIdle() 
	{
		static const int waitTimes = 30;
		static const int waitEachTimeout = 300;
		int waitCurrTimes = 0;

		while(m_fsm->IsWorking() && (++waitCurrTimes <= waitTimes)) {
			Sleep(waitEachTimeout);
		}

		if(waitCurrTimes > waitTimes) {
			LogWarn(Severity_Low, Error_TimeOut, 
				LOG_EVT_SCANNERSET_HSPSCNT_TASK_TIMEOUT, "Waiting FSM to Idle timeout!");
		}
	}
};

struct SetWinPosTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_SetWindowPos_Req, 
		ScannerService_SetWindowPos_Ans>::Pointer m_ctx;
	SetWinPosTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_SETWINPOS_FINISHED);
		pEvt->param1 = m_fsm->SetWinPos(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_SetWindowPos_Req, 
		ScannerService_SetWindowPos_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct GetDevStatusTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_GetDevStatus_Req, 
		ScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	GetDevStatusTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_GETSTATUS_FINISHED);
		m_fsm->GetDevStatus(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_GetDevStatus_Req, 
		ScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

struct GetDevInfoTask : public ITaskSp
{
	CScannerFSM* m_fsm;
	SpReqAnsContext<ScannerService_GetDevInfo_Req, 
		ScannerService_GetDevInfo_Ans>::Pointer m_ctx;
	GetDevInfoTask(CScannerFSM* fsm): m_fsm(fsm){}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_GETINFO_FINISHED);
		m_fsm->GetDevInfo(m_ctx);
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
	void SetContext(
		SpReqAnsContext<ScannerService_GetDevInfo_Req, 
		ScannerService_GetDevInfo_Ans>::Pointer ctx)
	{
		m_ctx = ctx;
		return;
	}
};

#endif //_SCANNERSET_FSM_H_