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

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

	USER_EVT_STARTPREVIEW_JS,
	USER_EVT_STARTPREVIEW_JS_DONE,

	USER_EVT_CANCELPREVIEW_JS,
	USER_EVT_CANCELPREVIEW_JS_DONE,

	USER_EVT_SCANIMAGE_JS,
	USER_EVT_SCANIMAGE_JS_DONE,

	USER_EVT_SETPARAM_JS,

	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_GOTOHELL,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_INIT_FINISHED
};

namespace JS
{
	struct PreviewSettings
	{
		short rotate;
		short scan;
		short color;
		short pos;
		short pos_x;
		short pos_y;
		short pos_w;

		//0:do nothing,1:show, 2:hide
		short view;

		PreviewSettings(const HSPScannerService_SetParamJS_Req& rhs) :rotate(rhs.rotate), scan(rhs.scan), color(rhs.color), pos(rhs.pos)
			, pos_x(rhs.pos_x), pos_y(rhs.pos_y), pos_w(rhs.pos_w),view(0) {}

		PreviewSettings(const HSPScannerService_StartPreviewJS_Req& rhs) :rotate(rhs.rotate), scan(rhs.scan), color(rhs.color), pos(rhs.pos)
			, pos_x(rhs.pos_x), pos_y(rhs.pos_y), pos_w(rhs.pos_w),view(0) {}

		PreviewSettings(bool show) :rotate(0), scan(0), color(0), pos(0), pos_x(0), pos_y(0), pos_w(0), view(show ? 1 : 2) {}

		bool IsAvailable() const {
			return (rotate != 0 || scan != 0 || color != 0 || pos != 0);
		}
		void SetDisplay(bool display) { if (display) view = 1; else view = 2; }
	};
}

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 {
		sIdle, sPreview, sProperty, sFault, sPicture, sFault_Offline, sHidePreview, sExit, sInit
	};

	BEGIN_FSM_STATE(CHSPScannerFSM)
		FSM_STATE_ENTRY(sIdle, "Idle", s0_Idle_on_entry, s0_Idle_on_exit, s0_Idle_on_event)
		FSM_STATE_ENTRY(sPreview, "Previewing", s1_Preview_on_entry, s1_Preview_on_exit, s1_Preview_on_event)
		FSM_STATE_ENTRY(sProperty, "Property", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(sFault, "Failed", s3_Failed_on_entry, s3_Failed_on_exit, s3_Failed_on_event)
		FSM_STATE_ENTRY(sPicture, "Picturing", s4_ScanImage_on_entry, s4_ScanImage_on_exit, s4_ScanImage_on_event)
		FSM_STATE_ENTRY(sFault_Offline, "DeviceOff", s5_DeviceOff_on_entry, s5_DeviceOff_on_exit, s5_DeviceOff_on_event)
		FSM_STATE_ENTRY(sHidePreview, "HidePreview", s6_HidePreview_on_entry, s6_HidePreview_on_exit, s6_HidePreview_on_event)
		FSM_STATE_ENTRY(sExit, "Exit", s7_Exit_on_entry, s7_Exit_on_exit, s7_Exit_on_event)
		FSM_STATE_ENTRY(sInit, "Init", s8_Init_on_entry, s8_Init_on_exit, s8_Init_on_event)
	END_FSM_STATE()

	
	BEGIN_FSM_RULE(CHSPScannerFSM, sIdle)
		//2 reserved in sIdle state.
		FSM_RULE_ENTRY(sIdle, sPreview, USER_EVT_STARTPREVIEW_FINISHED, 0) //成功预览
		FSM_RULE_ENTRY(sIdle, sFault, USER_EVT_STARTPREVIEW_FINISHED, 1) //预览失败
		FSM_RULE_ENTRY(sIdle, sIdle, USER_EVT_STARTPREVIEW_FINISHED, 2) // 错误还不足够严重，停留在当前状态

		FSM_RULE_ENTRY(sFault, sPreview, USER_EVT_STARTPREVIEW_FINISHED, 0)
		FSM_RULE_ENTRY(sFault, sIdle, USER_EVT_RESET, 0)
		//FSM_RULE_ENTRY(sFault, sFault, USER_EVT_RESET, 1)
		FSM_RULE_ENTRY(sFault, sPreview, USER_EVT_RESET, 2)

		FSM_RULE_ENTRY(sPreview, sProperty, USER_EVT_SHOWPROPERTY, 0)
		FSM_RULE_ENTRY_ANY(sProperty, sPreview, USER_EVT_SHOWPROPERTY_FINISHED)

		//3 reserved in sPreview state.
		FSM_RULE_ENTRY(sPreview, sFault, USER_EVT_STOPPREVIEW_FINISHED, 0)
		FSM_RULE_ENTRY(sPreview, sFault, USER_EVT_STOPPREVIEW_FINISHED, 4)

		FSM_RULE_ENTRY(sPreview, sHidePreview, USER_EVT_STOPPREVIEW_FINISHED, 1)

		FSM_RULE_ENTRY(sPreview, sIdle, USER_EVT_STOPPREVIEW_FINISHED, 2) //关闭预览
		FSM_RULE_ENTRY(sPreview, sPreview, USER_EVT_STOPPREVIEW_FINISHED, 3) //错误还不足够严重，停留在当前状态

		FSM_RULE_ENTRY(sPreview, sPicture, USER_EVT_SCANIMAGE, 0)
		FSM_RULE_ENTRY(sPreview, sPicture, USER_EVT_SCANIMAGE_EX, 0)

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

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

		FSM_RULE_ENTRY(sPicture, sPreview, USER_EVT_SCANIMAGEFINISHED, 5)

		FSM_RULE_ENTRY_ANY(sFault, sFault_Offline, USER_EVT_DISCONNECT)
		FSM_RULE_ENTRY(sFault_Offline, sIdle, EVT_TIMER, 1)
		FSM_RULE_ENTRY(sFault_Offline, sPreview, EVT_TIMER, 2)
		FSM_RULE_ENTRY(sFault_Offline, sHidePreview, EVT_TIMER, 3)

		FSM_RULE_ENTRY(sIdle, sFault_Offline, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(sPreview, sFault_Offline, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(sPicture, sFault_Offline, USER_EVT_DISCONNECT, 0)
		FSM_RULE_ENTRY(sHidePreview, sFault_Offline, USER_EVT_DISCONNECT, 0)

		FSM_RULE_ENTRY(sHidePreview, sPreview, USER_EVT_STARTPREVIEW_FINISHED, 0) //成功预览
		FSM_RULE_ENTRY(sHidePreview, sFault, USER_EVT_STARTPREVIEW_FINISHED, 1) //预览失败
		FSM_RULE_ENTRY(sHidePreview, sHidePreview, USER_EVT_STARTPREVIEW_FINISHED, 2) // 错误还不足够严重，停留在当前状态
		FSM_RULE_ENTRY(sHidePreview, sIdle, USER_EVT_STOPPREVIEW_FINISHED, 2) //关闭预览
		FSM_RULE_ENTRY(sHidePreview, sFault, USER_EVT_STOPPREVIEW_FINISHED, 0) //关闭预览失败
		FSM_RULE_ENTRY(sHidePreview, sHidePreview, USER_EVT_STOPPREVIEW_FINISHED, 3) //错误还不足够严重，停留在当前状态


		FSM_RULE_ENTRY(sPreview, sExit, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY_ANY(sProperty, sExit, USER_EVT_EXIT)
		FSM_RULE_ENTRY(sHidePreview, sExit, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(sExit, sIdle, USER_EVT_EXIT_FINISHED, 0)
		FSM_RULE_ENTRY(sExit, sFault, USER_EVT_EXIT_FINISHED, 1)
		FSM_RULE_ENTRY(sExit, sPreview, USER_EVT_EXIT_FINISHED, 2) //TODO: remove it  [Gifur@202565]
		FSM_RULE_ENTRY(sExit, sHidePreview, USER_EVT_EXIT_FINISHED, 3) //TODO: remove it  [Gifur@202565]
		FSM_RULE_ENTRY(sExit, sFault_Offline, USER_EVT_EXIT_FINISHED, 4) //TODO: remove it  [Gifur@202565]

		FSM_RULE_ENTRY_ANY(sIdle, sInit, USER_EVT_INIT)
		FSM_RULE_ENTRY_ANY(sIdle, sFault, USER_EVT_GOTOHELL)

		/** JS Compoent  [Gifur@20241114]*/
		FSM_RULE_ENTRY(sIdle, sPreview, USER_EVT_STARTPREVIEW_JS_DONE, 0)
		FSM_RULE_ENTRY(sIdle, sFault, USER_EVT_STARTPREVIEW_JS_DONE, 1) //预览失败
		FSM_RULE_ENTRY(sIdle, sIdle, USER_EVT_STARTPREVIEW_JS_DONE, 2) // 错误还不足够严重，停留在当前状态

		FSM_RULE_ENTRY(sHidePreview, sPreview, USER_EVT_STARTPREVIEW_JS, 1)

		FSM_RULE_ENTRY(sPreview, sIdle, USER_EVT_CANCELPREVIEW_JS_DONE, 1) //取消预览成功
		FSM_RULE_ENTRY(sPreview, sHidePreview, USER_EVT_CANCELPREVIEW_JS_DONE, 2) //隐藏成功
		FSM_RULE_ENTRY(sPreview, sFault, USER_EVT_CANCELPREVIEW_JS_DONE, 4)//TODO: remove it  [Gifur@202565]

		FSM_RULE_ENTRY(sHidePreview, sIdle, USER_EVT_CANCELPREVIEW_JS_DONE, 0)

		FSM_RULE_ENTRY(sPreview, sHidePreview, USER_EVT_SCANIMAGE_JS_DONE, 2)
		FSM_RULE_ENTRY(sPreview, sFault, USER_EVT_SCANIMAGE_JS_DONE, 4)

		FSM_RULE_ENTRY(sPreview, sExit, EVT_MAINPAGE_DISPLAY, 0)
		FSM_RULE_ENTRY(sHidePreview, sExit, EVT_MAINPAGE_DISPLAY, 0)
		/** JS Compoent Done [Gifur@20241114]*/

		FSM_RULE_ENTRY_ANY(sInit, sIdle, USER_EVT_INIT_FINISHED)
		FSM_RULE_ENTRY_ANY(sInit, sFault, USER_EVT_GOTOHELL)

	END_FSM_RULE()

	virtual void s0_Idle_on_entry();
	virtual void s0_Idle_on_exit();
	virtual unsigned int s0_Idle_on_event(FSMEvent* e);

	virtual void s1_Preview_on_entry();
	virtual void s1_Preview_on_exit();
	virtual unsigned int s1_Preview_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_Failed_on_entry();
	virtual void s3_Failed_on_exit();
	virtual unsigned int s3_Failed_on_event(FSMEvent* e);

	virtual void s4_ScanImage_on_entry();
	virtual void s4_ScanImage_on_exit();
	virtual unsigned int s4_ScanImage_on_event(FSMEvent* e);

	virtual void s5_DeviceOff_on_entry();
	virtual void s5_DeviceOff_on_exit();
	virtual unsigned int s5_DeviceOff_on_event(FSMEvent* e);

	virtual void s6_HidePreview_on_entry();
	virtual void s6_HidePreview_on_exit();
	virtual unsigned int s6_HidePreview_on_event(FSMEvent* e);

	virtual void s7_Exit_on_entry();
	virtual void s7_Exit_on_exit();
	virtual unsigned int s7_Exit_on_event(FSMEvent* e);

	virtual void s8_Init_on_entry();
	virtual void s8_Init_on_exit();
	virtual unsigned int s8_Init_on_event(FSMEvent* e);

	virtual void OnStateTrans(int iSrcState, int iDstState);

	/** JS Component  [Gifur@20241112]*/
	//0,succ;1 failed;
	int StartPreviewJS(SpReqAnsContext<HSPScannerService_StartPreviewJS_Req,
		HSPScannerService_StartPreviewJS_Ans>::Pointer ctx);
	//0,succ;1 failed;
	int CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req,
		HSPScannerService_CancelPreviewJS_Ans>::Pointer ctx);
	//0,succ;1 failed;
	int ScanImageJS(SpReqAnsContext<HSPScannerService_ScanImageJS_Req,
		HSPScannerService_ScanImageJS_Ans>::Pointer ctx);
	//0,succ;1 failed;
	int SetParam(SpReqAnsContext<HSPScannerService_SetParamJS_Req,
		HSPScannerService_SetParamJS_Ans>::Pointer ctx);
	/** JS Component Done  [Gifur@20241112]*/

	//0,succ;1 failed
	int StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
		HSPScannerService_StartPreview_Ans>::Pointer ctx);
	//1隐藏成功；4：隐藏失败；2：取消预览成功；0：取消预览失败
	int StopPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx);
	
	bool ResizeImage(const CSimpleStringA& fileName, int kbSize, long& originSize, CSimpleStringA& retMsg);
	
	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;
	}

	int SetPreviewParam(int colorType, int rotateType, int scanType, bool abortIfFault = false);

	ErrorCodeEnum TryToOpenDevice();
	LPCTSTR MapCode2RTAString(DWORD dwValue);


	int Initial();
protected:
	
	ErrorCodeEnum SetPreviewProperty(const JS::PreviewSettings& val, const char* logCode = "");

	void ToSwithLight(bool turnOn = true);
private:
	ErrorCodeEnum m_ecSelfTest;
	int m_nFatalTimes;
	int m_nSrcState;
	int m_nRecX, m_nRecY, m_nRecW;

	EvtType m_desiredAction;
	DWORD dwLastUserCode;
	DWORD m_dwMaxImageSize;
	bool m_lightOn;
	bool m_dupFlag4ExitCancel;
	ULONGLONG m_ullTS4Disconnect;
private:

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

	ErrorCodeEnum GetDevStatusFromAdapter(HspsDevStatus& status, bool fromBusiness = false);

	//  --Josephus at 16:33:57 20161214
	// to replace when JS
	// 0: disconnected;
	// 1: connected;
	// -1: invalid;
	int IsDevConnected()
	{
		if(!m_hDevHelper || !m_bOpened) return -1;
		HspsDevStatus status = {0};
		if(GetDevStatusFromAdapter(status) == Error_Succeed)
			return (status.isConnected == 0) ? 0 : 1;
		return -1;
	}
	
	void InitialMaxResizeValue();

	void ClearPictureFileSure(int nMask = 3)
	{
		if (!!(nMask & 1)) {
			CSimpleStringA strNoUsed(true);
			GetCurImageName(strNoUsed);
			DelAndGetNewFileName(strNoUsed);
		}
		if (!!(nMask & 2)) {
			CSimpleStringA strNoUsed(true);
			GetCurImageName(strNoUsed, true);
			DelAndGetNewFileName(strNoUsed);
		}
	}
};

class StartPreviewEvent : public FSMEvent
{
public:
	StartPreviewEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_STARTPREVIEW) {}
	~StartPreviewEvent() {}
	SpReqAnsContext<HSPScannerService_StartPreview_Req, HSPScannerService_StartPreview_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_StartPreview).setAPI("StartPreviewEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class StopPreviewEvent : public FSMEvent
{
public:
	StopPreviewEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_STOPPREVIEW) {}
	~StopPreviewEvent() {}
	SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_CancelPreview).setAPI("StopPreviewEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class ScanImageEvent : public FSMEvent
{
public:
	ScanImageEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SCANIMAGE) {}
	~ScanImageEvent() {}
	SpReqAnsContext<HSPScannerService_ScanImage_Req,
		HSPScannerService_ScanImage_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ScanImage).setAPI("ScanImageEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class ScanImageExEvent : public FSMEvent
{
public:
	ScanImageExEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SCANIMAGE_EX) {}
	~ScanImageExEvent() {}
	SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ScanImageEx).setAPI("ScanImageExEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class ShowPropertyEvent : public FSMEvent
{
public:
	ShowPropertyEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SHOWPROPERTY) {}
	~ShowPropertyEvent() {}
	SpReqAnsContext<HSPScannerService_ShowProperty_Req,
		HSPScannerService_ShowProperty_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ShowProperty).setAPI("ShowPropertyEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class SetPropertyEvent : public FSMEvent
{
public:
	SetPropertyEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SETPROPERTY) {}
	~SetPropertyEvent() {}
	SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_SetProperty).setAPI("SetPropertyEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class SetWinPosEvent : public FSMEvent
{
public:
	SetWinPosEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SETWINPOS) {}
	~SetWinPosEvent() {}
	SpReqAnsContext<HSPScannerService_SetWinPos_Req,
		HSPScannerService_SetWinPos_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_SetWinPos).setAPI("SetWinPosEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

class GetDevStatusEvent : public FSMEvent
{
public:
	GetDevStatusEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_GETSTATUS) {}
	~GetDevStatusEvent() {}
	SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_GetDevStatus).setAPI("GetDevStatusEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};


/** No use now  [Gifur@2025318]*/
class GetDevInfoEvent : public FSMEvent
{
public:
	GetDevInfoEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_GETINFO) {}
	~GetDevInfoEvent() {}
	SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer m_ctx;
	CHSPScannerFSM* m_fsm;
	virtual void OnUnhandled()
	{
		if (m_ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_GetDevInfo).setAPI("GetDevInfoEvent")
				.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

/** JS Component  [Gifur@20241112]*/
namespace JS {

	class StartPreviewEvent : public FSMEvent
	{
	public:
		StartPreviewEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_STARTPREVIEW_JS) {}
		~StartPreviewEvent() {}
		SpReqAnsContext<HSPScannerService_StartPreviewJS_Req, HSPScannerService_StartPreviewJS_Ans>::Pointer m_ctx;
		CHSPScannerFSM* m_fsm;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_StartPreviewJS).setAPI("StartPreviewEventJS")
					.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("StartPreviewEvent::Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

	class CancelPreviewEvent : public FSMEvent
	{
	public:
		CancelPreviewEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_CANCELPREVIEW_JS) {}
		~CancelPreviewEvent() {}
		SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req, HSPScannerService_CancelPreviewJS_Ans>::Pointer m_ctx;
		CHSPScannerFSM* m_fsm;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_CancelPreviewJS).setAPI("CancelPreviewJSEvent")
					.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("CancelPreviewEvent::Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

	class ScanImageEvent : public FSMEvent
	{
	public:
		ScanImageEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SCANIMAGE_JS) {}
		~ScanImageEvent() {}
		SpReqAnsContext<HSPScannerService_ScanImageJS_Req, HSPScannerService_ScanImageJS_Ans>::Pointer m_ctx;
		CHSPScannerFSM* m_fsm;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ScanImageJS).setAPI("ScanImageJSEvent")
					.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("ScanImageEvent::Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

	class SetParamEvent : public FSMEvent
	{
	public:
		SetParamEvent(CHSPScannerFSM* val): m_fsm(val), FSMEvent(USER_EVT_SETPARAM_JS) {}
		~SetParamEvent() {}
		SpReqAnsContext<HSPScannerService_SetParamJS_Req, HSPScannerService_SetParamJS_Ans>::Pointer m_ctx;
		CHSPScannerFSM* m_fsm;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_SetParamJS).setAPI("SetParamJSEvent")
					.setResultCode(m_fsm->MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("SetParamEvent::Error_InvalidState in [%s] State", m_fsm->GetCurrStateName());
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};
}
/** JS Component Done  [Gifur@20241112]*/

struct InitTask : public ITaskSp
{
	CHSPScannerFSM* fsm;
	InitTask(CHSPScannerFSM* f) : fsm(f) {}

	void Process()
	{
		const int ret = fsm->Initial();
		if (ret == 0) {
			FSMEvent* e = new FSMEvent(USER_EVT_INIT_FINISHED);
			fsm->PostEventFIFO(e);
		}
		else {
			FSMEvent* e = new FSMEvent(USER_EVT_GOTOHELL);
			fsm->PostEventFIFO(e);
		}
	}
};

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;
		const int retCode = m_fsm->SetPreviewParam(m_ctx->Req.colorType, m_ctx->Req.rotateType, m_ctx->Req.scanType);
		if (retCode == 0)
		{
			eRet = Error_Succeed;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("SetPreviewParam return some wrong:0x%X", retCode);
			eRet = Error_DevCommFailed;
		}
		if (ISSUCCEEDED(eRet)) {
			pEvt->param1 = 0;
			m_ctx->Answer(eRet);
		}
		else {
			m_ctx->Answer(eRet, m_fsm->GetLastUserCode());
			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 ExitClearTask : public ITaskSp
{
	CHSPScannerFSM* m_fsm;
	ExitClearTask(CHSPScannerFSM* fsm) : m_fsm(fsm) {}
	void Process()
	{
		FSMEvent* pEvt = new FSMEvent(USER_EVT_EXIT_FINISHED);
		if (ISSUCCEEDED(m_fsm->OnDevExit())) {
			pEvt->param1 = 0;
		}
		else {
			pEvt->param1 = 1;
		}
		m_fsm->PostEventFIFO(pEvt);
		return;
	}
};

/** JS Compoent  [Gifur@20241112]*/
namespace JS {

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

	struct CancelPreviewTask : public ITaskSp
	{
		CHSPScannerFSM* m_fsm;
		SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req, HSPScannerService_CancelPreviewJS_Ans>::Pointer m_ctx;
		CancelPreviewTask(CHSPScannerFSM* fsm) : m_fsm(fsm) {}
		void Process()
		{
			FSMEvent* pEvt = new FSMEvent(USER_EVT_CANCELPREVIEW_JS_DONE);
			pEvt->param1 = m_fsm->CancelPreview(m_ctx);
			pEvt->param2 = m_ctx->Req.hide ? 1 : 0;
			m_fsm->PostEventFIFO(pEvt);
			return;
		}
		void SetContext(
			SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req,
			HSPScannerService_CancelPreviewJS_Ans>::Pointer ctx)
		{
			m_ctx = ctx;
			return;
		}
	};

	struct ScanImageTask : public ITaskSp
	{
		CHSPScannerFSM* m_fsm;
		SpReqAnsContext<HSPScannerService_ScanImageJS_Req, HSPScannerService_ScanImageJS_Ans>::Pointer m_ctx;
		ScanImageTask(CHSPScannerFSM* fsm) : m_fsm(fsm) {}
		void Process()
		{
			FSMEvent* pEvt = new FSMEvent(USER_EVT_SCANIMAGE_JS_DONE);
			////0,succ;1 failed;
			pEvt->param1 = m_fsm->ScanImageJS(m_ctx);
			///1 说明隐藏,0说明关闭
			pEvt->param2 = m_ctx->Req.hide ? 1 : 0;
			m_fsm->PostEventFIFO(pEvt);
			return;
		}
		void SetContext(
			SpReqAnsContext<HSPScannerService_ScanImageJS_Req,
			HSPScannerService_ScanImageJS_Ans>::Pointer ctx)
		{
			m_ctx = ctx;
			return;
		}
	};

	struct SetParamTask : public ITaskSp
	{
		CHSPScannerFSM* m_fsm;
		SpReqAnsContext<HSPScannerService_SetParamJS_Req, HSPScannerService_SetParamJS_Ans>::Pointer m_ctx;
		SetParamTask(CHSPScannerFSM* fsm) : m_fsm(fsm) {}
		void Process()
		{
			m_fsm->SetParam(m_ctx);
			return;
		}
		void SetContext(
			SpReqAnsContext<HSPScannerService_SetParamJS_Req,
			HSPScannerService_SetParamJS_Ans>::Pointer ctx)
		{
			m_ctx = ctx;
			return;
		}
	};
}

#endif //_HSPSCANNER_FSM_H_