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_NOCFG,
	USER_EVT_GOTOHELL,
	USER_EVT_OPENSUCC,

	USER_EVT_QUIT
};


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 IsWorth() const {
			return (rotate != 0 || scan != 0 || color != 0 || pos != 0);
		}
		void SetDisplay(bool display) { if (display) view = 1; else view = 2; }
	};
}

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).setLogCode(HSPScannerService_LogCode_StartPreview).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_CancelPreview).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_ScanImage).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_ScanImageEx).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_ShowProperty).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_SetProperty).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_SetWinPos).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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).setLogCode(HSPScannerService_LogCode_GetDevStatus).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};


/** No use now  [Gifur@2025318]*/
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).setLogCode(HSPScannerService_LogCode_GetDevInfo).setResultCode("RTA2N0V")("Error_InvalidState");
			m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
		}
	}
};

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

	class StartPreviewEvent : public FSMEvent
	{
	public:
		StartPreviewEvent() : FSMEvent(USER_EVT_STARTPREVIEW_JS) {}
		~StartPreviewEvent() {}
		SpReqAnsContext<HSPScannerService_StartPreviewJS_Req, HSPScannerService_StartPreviewJS_Ans>::Pointer m_ctx;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_StartPreviewJS).setResultCode("RTA2N0V")("StartPreviewEvent::Error_InvalidState");
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

	class CancelPreviewEvent : public FSMEvent
	{
	public:
		CancelPreviewEvent() : FSMEvent(USER_EVT_CANCELPREVIEW_JS) {}
		~CancelPreviewEvent() {}
		SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req, HSPScannerService_CancelPreviewJS_Ans>::Pointer m_ctx;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_CancelPreviewJS).setResultCode("RTA2N0V")("CancelPreviewEvent::Error_InvalidState");
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

	class ScanImageEvent : public FSMEvent
	{
	public:
		ScanImageEvent() : FSMEvent(USER_EVT_SCANIMAGE_JS) {}
		~ScanImageEvent() {}
		SpReqAnsContext<HSPScannerService_ScanImageJS_Req, HSPScannerService_ScanImageJS_Ans>::Pointer m_ctx;
		virtual void OnUnhandled()
		{
			if (m_ctx != NULL)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ScanImageJS).setResultCode("RTA2N0V")("ScanImageEvent::Error_InvalidState");
				m_ctx->Answer(Error_InvalidState, LOG_WARN_HSPS_INVALID_OPERATION);
			}
		}
	};

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

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, sFault_NotConfig};

	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, "HidPreviewing", s6_HidPreviewing_on_entry, s6_HidPreviewing_on_exit, s6_HidPreviewing_on_event)
		FSM_STATE_ENTRY(sExit, "Exit", s7_Exit_on_entry, s7_Exit_on_exit, s7_Exit_on_event)
		FSM_STATE_ENTRY(sFault_NotConfig, "NotConfig", s8_NotConfig_on_entry, s8_NotConfig_on_exit, s8_NotConfig_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_ANY(sFault, sIdle, USER_EVT_OPENSUCC)

		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)

		// Try sHidePreview state --Josephus at 10:10:05 2016/11/22
		//FSM_RULE_ENTRY(sPreview, sIdle, USER_EVT_STOPPREVIEW_FINISHED, 1) //隐藏
		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(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_ANY(sPreview, sExit, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(sProperty, sExit, USER_EVT_EXIT)
		FSM_RULE_ENTRY_ANY(sHidePreview, sExit, USER_EVT_EXIT)
		FSM_RULE_ENTRY(sExit, sIdle, USER_EVT_EXIT_FINISHED, 0)
		FSM_RULE_ENTRY(sExit, sFault, USER_EVT_EXIT_FINISHED, 1)

		FSM_RULE_ENTRY_ANY(sIdle, sFault_NotConfig, USER_EVT_NOCFG)
		FSM_RULE_ENTRY_ANY(sIdle, sFault, USER_EVT_GOTOHELL)

		/*
			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,
		
		*/

		/** JS Compoent  [Gifur@20241114]*/
		FSM_RULE_ENTRY(sIdle, sPreview, USER_EVT_STARTPREVIEW_JS_DONE, 0)
		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(sHidePreview, sIdle, USER_EVT_CANCELPREVIEW_JS_DONE, 0)

		FSM_RULE_ENTRY(sPreview, sHidePreview, USER_EVT_SCANIMAGE_JS_DONE, 2)
		/** JS Compoent Done [Gifur@20241114]*/

		
	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_HidPreviewing_on_entry();
	virtual void s6_HidPreviewing_on_exit();
	virtual unsigned int s6_HidPreviewing_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);

	//NotConfig
	virtual void s8_NotConfig_on_entry();
	virtual void s8_NotConfig_on_exit();
	virtual unsigned int s8_NotConfig_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]*/

	int StartPreview(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 kbSize);
	
	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);

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

	ErrorCodeEnum TryToOpenDevice();

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

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;

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

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

/** 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);
			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_