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

static LPCTSTR MapCode2RTAString(DWORD dwValue)
{
	switch (dwValue) {
	case LOG_ERR_HSPS_DEVOPEN_FAILED:
		return "RTA2N01";
		break;
	case 0x21700002://跟灯事件有冲突
		return "RTA2N02";
		break;
	case LOG_ERR_HSPS_PREVIEW_FAILED: //跟灯事件有冲突
		return "RTA2N03";
		break;
	case LOG_EVT_HSPS_CANCEL_PREVIEW_FAILED:
		return "RTA2N04";
		break;
	case LOG_EVT_HSPS_SCANIMAGE_FAILED:
		return "RTA2N05";
		break;
	case LOG_EVT_HSPS_READ_IMAGEEX_FILE_FAILED:
		return "RTA2N06";
		break;
	case HSPScanner_UserErrorCode_SetParam_Position:
		return "RTA2N07";
		break;
	case 0x21700008:
		return "RTA2N08";
		break;
	case 0x21700009:
		return "RTA2N09";
		break;
	case 0x2170000A:
		return "RTA2N0A";
		break;
	case 0x2170000B:
		return "RTA2N0B";
		break;
	case 0x2170000C:
		return "RTA2N0C";
		break;
	case HSPScanner_UserErrorCode_READ_IMAGE_FILE_FAILED:
		return "RTA2N0D";
		break;
	case HSPScanner_UserErrorCode_LOAD_DLLFILE_NOTEIXT:
		return "RTA2N0E";
		break;
	case HSPScanner_UserErrorCode_LOAD_DLLFILE_FAILED:
		return "RTA2N0F";
		break;
	case HSPScanner_UserErrorCode_FSM_INVALID:
		return "RTA2N0G";
		break;
	case HSPScanner_UserErrorCode_DLLNAME_FAILED:
		return "RTA2N0H";
		break;
	case HSPScanner_UserErrorCode_DLLNAME_NOCFG:
		return "RTA2N0J";
		break;
	case HSPScanner_UserErrorCode_DEVICE_OFFLINE:
		return "RTA2N0K";
		break;
	case HSPScanner_UserErrorCode_IMAGE_CLEAR:
		return "RTA2N0L";
		break;
	case HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED:
		return "RTA2N0L";
		break;
	case HSPScanner_UserErrorCode_NOT_SUPPORT:
		return "RTA2N0M";
		break;
	case LOG_WARN_HSPS_RESIZE_IMAGE_FILE_FAILED:
		return "RTA2N0N";
		break;
	case HSPScanner_UserErrorCode_SetParam_Hide:
		return "RTA2N0Q";
		break;
	case LOG_WARN_HSPS_INVALID_OPERATION:
		return "RTA2N0V";
		break;
	case HSPScanner_UserErrorCode_SetParam_View:
		return "RTA2N0R";
		break;
		/*RTA2N0S*/
		/*RTA2N0T*/
	/** 新增  [Gifur@20241111]*/
	case HSPScanner_UserErrorCode_SetParam_Color:
		return "RTA2N0W";
		break;
	case HSPScanner_UserErrorCode_SetParam_Rotate:
		return "RTA2N0Y";
		break;
	case HSPScanner_UserErrorCode_SetParam_Scan:
		return "RTA2N0Z";
		break;
	case LOG_WARN_HSPS_OPENING_NOW:
		return "RTA2N11";
		break;
	case 0:
	default:
		return "SUC0000";
		break;
	}
}

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 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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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(MapCode2RTAString(LOG_WARN_HSPS_INVALID_OPERATION))("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, "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(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(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(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_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, sPreview, USER_EVT_EXIT_FINISHED, 2)
		FSM_RULE_ENTRY(sExit, sHidePreview, USER_EVT_EXIT_FINISHED, 3)
		FSM_RULE_ENTRY(sExit, sFault_Offline, USER_EVT_EXIT_FINISHED, 4)


		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)


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

		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_ANY(sPreview, sExit, EVT_MAINPAGE_DISPLAY)
		FSM_RULE_ENTRY_ANY(sHidePreview, sExit, EVT_MAINPAGE_DISPLAY)
		/** 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_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);

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

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

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;

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()
	{
		CSimpleStringA strNoUsed(true);
		GetCurImageName(strNoUsed);
		DelAndGetNewFileName(strNoUsed);
		GetCurImageName(strNoUsed, true);
		DelAndGetNewFileName(strNoUsed);
	}
};

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_