myvtm/Module/mod_HSPScanner/HSPScannerFSM.cpp

#include "stdafx.h"
#include "HSPScannerFSM.h"
#include "EventCode.h"
#include "CommDevEntityErrorCode.h"
#include "RVCComm.h"
#include "publicFunExport.h"
#include "fileutil.h"
#include <math.h>

#ifndef _WIN32
#include <winpr/sysinfo.h>
#include "opencv.hpp"
#else
#include <opencv2/opencv.hpp>
#endif //NOT _WIN32
#include "HSPSCanner_LogCode.h"

#define RESET_TIMER_ID 1
#define CHECK_CONNECT_TIMER_ID 2
const int MILLISECOND_TO_RESET = 30 * 1000;
const int MILLISECOND_TO_CHECK_CONNECT = 15 * 1000;

const int MAX_PATH_SIZE = 256;
const int MAX_IMAGEDATA_BUFSIZE = 1 * 1024 * 1024;
const int MAX_IMAGEDATA_SUFFIX = 1024;
const int MAX_ERROR_TIMES = 2;

#define TEMP_WIDTH 1280

#define T_STRINGY(var) case var: return #var; break;

const char* EvtTypeToString(int nEvtType)
{
	switch (nEvtType)
	{
		T_STRINGY(USER_EVT_STARTPREVIEW)
		T_STRINGY(USER_EVT_STARTPREVIEW_FINISHED)
		T_STRINGY(USER_EVT_SETPROPERTYINVIEW_FINISHED)

		T_STRINGY(USER_EVT_STARTPREVIEW_JS)
		T_STRINGY(USER_EVT_STARTPREVIEW_JS_DONE)

		T_STRINGY(USER_EVT_CANCELPREVIEW_JS)
		T_STRINGY(USER_EVT_CANCELPREVIEW_JS_DONE)

		T_STRINGY(USER_EVT_SCANIMAGE_JS)
		T_STRINGY(USER_EVT_SCANIMAGE_JS_DONE)

		T_STRINGY(USER_EVT_SETPARAM_JS)

		T_STRINGY(USER_EVT_STOPPREVIEW)
		T_STRINGY(USER_EVT_HIDEPREVIEW)
		T_STRINGY(USER_EVT_STOPPREVIEW_FINISHED)

		T_STRINGY(USER_EVT_SETWINPOS)
		T_STRINGY(USER_EVT_SETWINPOSFINISHED)

		T_STRINGY(USER_EVT_SCANIMAGE)
		T_STRINGY(USER_EVT_SCANIMAGE_EX)
		T_STRINGY(USER_EVT_SCANIMAGEFINISHED)

		T_STRINGY(USER_EVT_SHOWPROPERTY)
		T_STRINGY(USER_EVT_SHOWPROPERTY_FINISHED)

		T_STRINGY(USER_EVT_SETPROPERTY)
		T_STRINGY(USER_EVT_SETPROPERTY_FINISHED)

		T_STRINGY(USER_EVT_GETSTATUS)
		T_STRINGY(USER_EVT_GETINFO)

		T_STRINGY(USER_EVT_DISCONNECT)

		T_STRINGY(USER_EVT_RESET)
		T_STRINGY(USER_EVT_EXIT)
		T_STRINGY(USER_EVT_EXIT_FINISHED)

		T_STRINGY(USER_EVT_GOTOHELL)
		T_STRINGY(USER_EVT_QUIT)
		T_STRINGY(USER_EVT_INIT)
		T_STRINGY(USER_EVT_INIT_FINISHED)

		T_STRINGY(EVT_INTERNAL)
		T_STRINGY(EVT_TIMER)
		T_STRINGY(EVT_MAINPAGE_DISPLAY)
		T_STRINGY(EVT_USER)
	default:
		return "Unknown EventType";
		break;
	}
}

const char* ParamValToString(int nParamVal)
{
	switch (nParamVal)
	{
		T_STRINGY(HSPS_BOOLVAL_FALSE)
			T_STRINGY(HSPS_BOOLVAL_TRUE)
			T_STRINGY(HSPS_COLOR_FULL)
			T_STRINGY(HSPS_COLOR_GREY)
			T_STRINGY(HSPS_ROTATE_NOANGLE)
			T_STRINGY(HSPS_ROTATE_LEFT)
			T_STRINGY(HSPS_ROTATE_MIRROR)
			T_STRINGY(HSPS_ROTATE_RIGHT)
			T_STRINGY(HSPS_SCAN_FULL)
			T_STRINGY(HSPS_SCAN_A4)
			T_STRINGY(HSPS_SCAN_IDCARD)
			T_STRINGY(HSPS_VIEW_HIDE)
			T_STRINGY(HSPS_VIEW_SHOW)
	default:
		return "Unknown ParamVal";
	}
}
#undef  T_STRINGY

ParamTypeValue Param_Color_Map[4] = { HSPS_COLOR_FULL, HSPS_COLOR_FULL , HSPS_COLOR_GREY , HSPS_COLOR_FULL };
ParamTypeValue Param_Rotate_Map[5] = { HSPS_ROTATE_NOANGLE, HSPS_ROTATE_NOANGLE , HSPS_ROTATE_LEFT , HSPS_ROTATE_MIRROR,HSPS_ROTATE_RIGHT };
ParamTypeValue Param_Scan_Map[4] = { HSPS_SCAN_FULL, HSPS_SCAN_FULL , HSPS_SCAN_A4 , HSPS_SCAN_IDCARD };
ParamTypeValue Param_View_Map[3] = { HSPS_VIEW_SHOW, HSPS_VIEW_SHOW , HSPS_VIEW_HIDE };


CSimpleStringA CombineJsonContext(const char* szMessage)
{
	CSimpleStringA result(true);
	if (szMessage == NULL || strlen(szMessage) == 0) {
		return result;
	}
	result = CSimpleStringA::Format("{\"addition\": \"%s\"}", szMessage);
	return  result;
}

CSimpleStringA CombineJsonContext4SetPreview(bool bOpen, const char* szMessage = NULL)
{
	CSimpleStringA result(true);
	if (szMessage == NULL || strlen(szMessage) == 0) {
		if (bOpen) {
			result = CSimpleStringA::Format("{\"PreviewSwitch\": \"ON\"}");
		}
		else {
			result = CSimpleStringA::Format("{\"PreviewSwitch\": \"OFF\"}");
		}
	}
	else {
		if (bOpen) {
			result = CSimpleStringA::Format("{\"addition\": \"%s\", \"PreviewSwitch\": \"ON\"}", szMessage);
		}
		else {
			result = CSimpleStringA::Format("{\"addition\": \"%s\", \"PreviewSwitch\": \"OFF\"}", szMessage);
		}
	}
	return  result;
}


CHSPScannerFSM::CHSPScannerFSM(void)
	:
	m_ecSelfTest(Error_Succeed),
	m_nFatalTimes(0),
	m_nSrcState(sIdle),
	m_desiredAction(USER_EVT_QUIT),
	dwLastUserCode(0),
	m_dwMaxImageSize(500), m_lightOn(false), m_dupFlag4ExitCancel(false)
{
	HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x217);
}

CHSPScannerFSM::~CHSPScannerFSM(void)
{

}

ErrorCodeEnum CHSPScannerFSM::OnInit()
{
	ErrorCodeEnum erroCode = Error_Succeed;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Source Code complied at: %s %s", __DATE__, __TIME__);
	SetDevInitFlag(false);
	AddStateHooker(this);
	InitialMaxResizeValue();
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();
	CSimpleStringA strNoUse(true);
	auto result = pEntity->ExtractVendorLibFullPath(strNoUse);
	if (FAILURED(result)) {
		//1255270002	2025-04-08 08:00:52.922	HSPScaner is not cofig now.
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Fetch Vendor dllName failed %s(%s).", (LPCTSTR)strNoUse, SpStrError(result));
		SetDevInitingFlag(false);
		SetDevInitFlag(false);
		SetLastUserCode(LOG_ERR_HSPS_DEVOPEN_FAILED);
		PostEventLIFO(new FSMEvent(USER_EVT_GOTOHELL));
	}
	else {
		FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
		PostEventLIFO(new FSMEvent(USER_EVT_INIT));
	}
	return Error_Succeed;
}

ErrorCodeEnum CHSPScannerFSM::OnExit()
{
	if (m_hDevHelper) {
		ErrorCodeEnum errCode = Error_Succeed;
		m_hDevHelper.TearDown();
		return errCode;
	}
	return Error_Succeed;
}

void CHSPScannerFSM::s0_Idle_on_entry()
{
	m_nFatalTimes = 0;
	m_ecSelfTest = Error_Succeed;
}

void CHSPScannerFSM::s0_Idle_on_exit()
{
}

unsigned int CHSPScannerFSM::s0_Idle_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s0_Idle_on_event: %s, %d.", EvtTypeToString(e->iEvt), e->param1);
	unsigned int uRet = 0;
	switch (e->iEvt)
	{
	/** JS Component  [Gifur@20241113]*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewTask* pTask = new JS::StartPreviewTask(this);
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	case USER_EVT_STARTPREVIEW_JS_DONE:
	{
		uRet = e->param1;
		e->SetHandled();
		/** 相对于常规调用，JS版本不兜底  [Gifur@2025324]*/
		if (uRet == 1/* && ++m_nFatalTimes <= MAX_ERROR_TIMES*/)
		{
			uRet = 2;
		}
		else if (uRet == 0)
		{
			m_nFatalTimes = 0;
		}

		if (uRet == 2 && IsDevConnected() == 0)
		{
			PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
		}
		else if (uRet == 1) {
			m_desiredAction = USER_EVT_STARTPREVIEW;
		}
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		//空闲状态收到取消预览的请求，直接返回成功
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		if (!pEvt->m_ctx->Req.hide) {
			pEvt->m_ctx->Answer(Error_Succeed);
			e->SetHandled();
		}
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamTask* pTask = new JS::SetParamTask(this);
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	/** JS Component Done [Gifur@20241113]*/
	case USER_EVT_STARTPREVIEW:
		{
			StartPreviewTask* pTask = new StartPreviewTask(this);
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		break;
	case USER_EVT_STARTPREVIEW_FINISHED:
		{
			uRet = e->param1;
			e->SetHandled();
			if(uRet == 1 && ++m_nFatalTimes <= MAX_ERROR_TIMES)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hold on, wait next time (%d/%d).", m_nFatalTimes, MAX_ERROR_TIMES);
				uRet = 2;
			}
			else if(uRet == 0)
			{
				m_nFatalTimes = 0;
			}

			if(uRet == 2 && IsDevConnected() == 0)
			{
				PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			}
			else if(uRet == 1) {
				m_desiredAction = USER_EVT_STARTPREVIEW;
			}
		}
		break;
	/** 根据日志查看在空闲状态偶尔会收到取消预览的请求，兼容处理之（参照JS改造） [Gifur@2025613]*/
	case USER_EVT_STOPPREVIEW:
		{
			StopPreviewTask* pTask = new StopPreviewTask(this);
			StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
			pEvt->m_ctx->Answer(Error_Succeed);
		}
		e->SetHandled();
		break;
		// Add after ST !!! --Josephus at 12:37:15 2016129
	case USER_EVT_SETWINPOS:
		{
			SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
			if(pEvt->m_ctx->Req.type == 2)
			{//在s0状态，仅能用于设置位置和窗体大小
				SetWinPosTask* pTask = new SetWinPosTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SETPROPERTY:
		{
			SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
			SetProperty(pEvt->m_ctx);
			e->SetHandled();
		}
		break;
	case USER_EVT_DISCONNECT:
		{
			//jump auto.
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_INIT:
		e->SetHandled();
		break;
	case EVT_MAINPAGE_DISPLAY:
	case USER_EVT_EXIT:
	{
		ClearPictureFileSure();
		e->SetHandled();
	}
	break;
	case USER_EVT_GOTOHELL:
		e->SetHandled();
		break;
	default:
		break;
	}
	return uRet;
}

void CHSPScannerFSM::s1_Preview_on_entry()
{
	m_dupFlag4ExitCancel = false;
}

void CHSPScannerFSM::s1_Preview_on_exit()
{
	m_dupFlag4ExitCancel = false;
}

unsigned int CHSPScannerFSM::s1_Preview_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s1_Preview_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch (e->iEvt)
	{
	/** JS Component  [Gifur@20241113]*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		if (JS::PreviewSettings(pEvt->m_ctx->Req).IsAvailable()) {
			ErrorCodeEnum erroCode = SetPreviewProperty(JS::PreviewSettings(pEvt->m_ctx->Req), HSPScannerService_LogCode_StartPreviewJS);
			if (FAILURED(erroCode)) {
				pEvt->m_ctx->Answer(Error_Unexpect, GetLastUserCode());
			}
			else {
				pEvt->m_ctx->Answer(Error_Succeed);
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Require to preview when in previewing!!");
			pEvt->m_ctx->Answer(Error_Succeed);
		}
		e->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		JS::CancelPreviewTask* pTask = new JS::CancelPreviewTask(this);
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		if (!pEvt->m_ctx->Req.hide) {
			m_dupFlag4ExitCancel = true;
		}
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS_DONE:
	{
		m_dupFlag4ExitCancel = false;
		if (e->param1 == 0) {//取消预览成功
			if (e->param2 == 1) uRet = 2; //仅仅是隐藏
			else {
				uRet = 1; 
			}
			m_nFatalTimes = 0;
		}
		else {
			uRet = 3;
			if (e->param2 == 1) { m_desiredAction = USER_EVT_HIDEPREVIEW; }
			else {
				m_desiredAction = USER_EVT_STOPPREVIEW;
			}
			if (IsDevConnected() == 0) {
				PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			}
		}
		e->SetHandled();
	}
	break;
	case USER_EVT_SCANIMAGE_JS:
	{
		JS::ScanImageTask* pTask = new JS::ScanImageTask(this);
		JS::ScanImageEvent* pEvt = dynamic_cast<JS::ScanImageEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	case USER_EVT_SCANIMAGE_JS_DONE:
	{
		if (e->param1 == 0) { //拍照成功
			if (e->param2 == 1) uRet = 2; //拍照后要求隐藏
			else uRet = 1; //拍照后没有其他动作
			m_nFatalTimes = 0;
		}
		else {
			uRet = 3;
			if (e->param2 == 1) m_desiredAction = USER_EVT_HIDEPREVIEW; else m_desiredAction = USER_EVT_STARTPREVIEW;
		}
		e->SetHandled();
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamTask* pTask = new JS::SetParamTask(this);
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	/** JS Component Done [Gifur@20241113]*/
	case USER_EVT_STARTPREVIEW:
		{
			// Maybe Just SetProperty [Josephus in 15:44:43 2016/11/19]
			SetPropertyInPreviewTask* pTask = new SetPropertyInPreviewTask(this);
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		break;
	case USER_EVT_SETPROPERTYINVIEW_FINISHED:
		{
			
		}
		e->SetHandled();
		break;
	case USER_EVT_STOPPREVIEW:
		{
			StopPreviewTask* pTask = new StopPreviewTask(this);
			StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			if (!pEvt->m_ctx->Req.bOnlyHide) {
				m_dupFlag4ExitCancel = true;
			}
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			m_dupFlag4ExitCancel = false;
			uRet = e->param1;
			if((uRet == 0 || uRet == 4) && ++m_nFatalTimes <= MAX_ERROR_TIMES)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hold on, wait next time (%d/%d).", m_nFatalTimes, MAX_ERROR_TIMES);
				uRet = 3;
			}
			else if(uRet != 0)
			{
				m_nFatalTimes = 0;
			}

			if(uRet == 3 && IsDevConnected() == 0)
			{
				PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			}
			//fault
			else if(uRet == 0) {
				m_desiredAction = USER_EVT_STOPPREVIEW;
			}
			else if(uRet == 4) {
				m_desiredAction = USER_EVT_HIDEPREVIEW;
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_SCANIMAGE:
		{
			ScanImageTask* pTask = new ScanImageTask(this);
			ScanImageEvent* pEvt = dynamic_cast<ScanImageEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SCANIMAGE_EX:
		{
			ScanImageExTask* pTask = new ScanImageExTask(this);
			ScanImageExEvent* pEvt = dynamic_cast<ScanImageExEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;

	case USER_EVT_SETPROPERTY:
		{
			SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
			SetProperty(pEvt->m_ctx);
		}
		e->SetHandled();
		break;
	case USER_EVT_SHOWPROPERTY:
		{
			ShowPropertyTask* pTask = new ShowPropertyTask(this);
			ShowPropertyEvent* pEvt = dynamic_cast<ShowPropertyEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SETWINPOS:
		{
			SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
			SetWinPosTask* pTask = new SetWinPosTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_DISCONNECT:
		{
			//jump auto.
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case EVT_MAINPAGE_DISPLAY:
	case USER_EVT_EXIT:
		{
			e->SetHandled();
			if (m_dupFlag4ExitCancel) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s::recv %s while CancelPreviewing", __FUNCTION__, EvtTypeToString(e->iEvt));
				uRet = 1;
			}
		}
		break;
	}

	return uRet;
}

void CHSPScannerFSM::s2_on_entry()
{
	LOG_FUNCTION();
}

void CHSPScannerFSM::s2_on_exit()
{

}

unsigned int CHSPScannerFSM::s2_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s2_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_SHOWPROPERTY_FINISHED:
		{

		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

void CHSPScannerFSM::s3_Failed_on_entry()
{
	if (GetDevInitFlag()) {
		SetLastUserCode(HSPScanner_UserErrorCode_FSM_INVALID);
		const int nStatus = IsDevConnected();
		if (nStatus == 0) {
			PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter s3_Failed by Disconnected");
		}
		else if (nStatus == 1) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter s3_Failed by Others' reason");
			ScheduleTimer(RESET_TIMER_ID, MILLISECOND_TO_RESET / 6);
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter s3_Failed by Device open failed");
		SetDevState(DEVICE_STATUS_FAULT);
	}
}

void CHSPScannerFSM::s3_Failed_on_exit()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Leave s3_Failed");
	SetDevState(DEVICE_STATUS_NORMAL);
	m_ecSelfTest = Error_Succeed;
	m_nFatalTimes = 0;
	m_desiredAction = USER_EVT_QUIT;
	CancelTimer(RESET_TIMER_ID);
}

unsigned int CHSPScannerFSM::s3_Failed_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s3_Failed_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	/** JS Component  [Gifur@20241112]*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		if (GetDevInitFlag()) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreviewJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("高拍仪模块出现异常");
		}
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		e->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		if (GetDevInitFlag()) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreviewJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("高拍仪模块出现异常");
		}
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		e->SetHandled();
	}
	break;
	case USER_EVT_SCANIMAGE_JS:
	{
		JS::ScanImageEvent* pEvt = dynamic_cast<JS::ScanImageEvent*>(e);
		if (GetDevInitFlag()) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImageJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("高拍仪模块出现异常");
		}
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		e->SetHandled();
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		if (GetDevInitFlag()) {
			JS::SetParamTask* pTask = new JS::SetParamTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		else {
			pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
			e->SetHandled();
		}
	}
	break;
	/** JS Compoent Done  [Gifur@20241112]*/
	case USER_EVT_STARTPREVIEW:
		{
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			if (!GetDevInitFlag()) {
				pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
			} else {
				StartPreviewTask* pTask = new StartPreviewTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
			e->SetHandled();
		}
		break;
	case USER_EVT_STARTPREVIEW_FINISHED:
		{
			uRet = e->param1;
			e->SetHandled();
		}
		break;
	case USER_EVT_STOPPREVIEW:
		{
			if(GetDevInitFlag())
			{
				CancelTimer(RESET_TIMER_ID);
				StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
				HspsDevStatus status = {0};
				ErrorCodeEnum erroCode = GetDevStatusFromAdapter(status);
				if (status.inPreview == 1) {
					StopPreviewTask* pTask = new StopPreviewTask(this);
					pTask->SetContext(pEvt->m_ctx);
					GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
				} else if (status.inShow == 1) {
					const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
					erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
					const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
					if (ISSUCCEEDED(erroCode)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_HIDE");
					} else {
						//RTA2N0Q
						SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_CancelPreview, CombineJsonContext("HSPS_VIEW_HIDE"));
						SetLastUserCode(GetAlarmDEC());
					}
					pEvt->m_ctx->Answer(erroCode);
					FSMEvent* timerEvent = new FSMEvent(EVT_TIMER);
					timerEvent->param1 = RESET_TIMER_ID;
					PostEventFIFO(timerEvent);
				}
			} else {
				StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
				pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
			} 
		}
		e->SetHandled();
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			uRet = e->param1;
			if(uRet == 0) {
				m_desiredAction = USER_EVT_STOPPREVIEW;
			}
			else if(uRet == 4) {
				m_desiredAction = USER_EVT_HIDEPREVIEW;
			}

			FSMEvent* timerEvent = new FSMEvent(EVT_TIMER);
			timerEvent->param1 = RESET_TIMER_ID;
			PostEventFIFO(timerEvent);
		}
		e->SetHandled();
		break;
	case USER_EVT_RESET:
		{
			if (GetDevInitFlag()) {
				ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
				ErrorCodeEnum erroCode = m_hDevHelper->Reset();
				ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
				if (FAILURED(erroCode)) {
					//RTA2N0B
					SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_Reset, "DevAdapter::Reset", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_Reset);
					SetDevState(DEVICE_STATUS_FAULT);
					uRet = 1;
				} else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Reset").setCostTime(ullEnd - ullStart)("Reset succ.");
					ullStart = SP::Module::Comm::RVCGetTickCount();
					ErrorCodeEnum eXYW = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
					ullEnd = SP::Module::Comm::RVCGetTickCount();
					if (FAILURED(eXYW)) {
						//RTA2N07
						SetErrorAndLog(eXYW, MEC_DEVAPI_HSPSCANNER_SetViewPos, "DevAdapter::SetViewPos", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_Reset);
						SetDevState(DEVICE_STATUS_FAULT);
						uRet = 1;
						e->SetHandled();
						break;
					} else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetViewPos").setCostTime(ullEnd - ullStart)("x:%d, y:%d, w:%d", m_nRecX, m_nRecY, m_nRecW);
					}
					HspsDevStatus status = {0};
					erroCode = GetDevStatusFromAdapter(status);
					if (ISSUCCEEDED(erroCode) && status.inPreview == 1 && status.inShow == 1) {
						if (m_desiredAction == USER_EVT_STOPPREVIEW) {
							do 
							{
								ullStart = SP::Module::Comm::RVCGetTickCount();
								erroCode = m_hDevHelper->SetPreview(0);
								ullEnd = SP::Module::Comm::RVCGetTickCount();
								if (erroCode == Error_Succeed) {
									DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setLogCode(CustomLogCode_CancelPreview_Default).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(false));
								} else {
									//RTA2N04
									SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close, "DevAdapter::SetPreview", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_CancelPreview_Default, CombineJsonContext4SetPreview(false));
								}
							} while (false);
							do 
							{
								HspsDevStatus retryStatus = { 0 };
								GetDevStatusFromAdapter(retryStatus);
								if (retryStatus.inPreview == 1) {
									ullStart = SP::Module::Comm::RVCGetTickCount();
									erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
									ullEnd = SP::Module::Comm::RVCGetTickCount();
									if (erroCode == Error_Succeed) {
										DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_MODEL_VIEW, HSPS_VIEW_HIDE");
									}
									else {
										//RTA2N0Q
										SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_Reset, CombineJsonContext("HSPS_VIEW_HIDE"));
									}
								}
							} while (false);

						} else if (m_desiredAction == USER_EVT_HIDEPREVIEW) {
							do 
							{
								ullStart = SP::Module::Comm::RVCGetTickCount();
								erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
								ullEnd = SP::Module::Comm::RVCGetTickCount();
								if (erroCode == Error_Succeed) {
									DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_HIDE");
								} else {
									//RTA2N0Q
									SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_Reset, CombineJsonContext("HSPS_VIEW_HIDE"));
								}
							} while (false);
						}
						else {
							DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setLogCode(CustomLogCode_Reset)("Recover routine done");
							uRet = 2;
						}
					}
					if (FAILURED(erroCode)) {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Recover failed under desiration of %s", EvtTypeToString(m_desiredAction));
						SetDevState(DEVICE_STATUS_FAULT);
						uRet = 1;
						e->SetHandled();
						break;
					}
				}
			}
		}
		e->SetHandled();
		break;
	case EVT_TIMER:
		{
			if (e->param1 == RESET_TIMER_ID) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Current Dev State:%d", GetDevState());
				FSMEvent* pEvt = new FSMEvent(USER_EVT_RESET);
				PostEventFIFO(pEvt);
				ScheduleTimer(RESET_TIMER_ID, MILLISECOND_TO_RESET);
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_DISCONNECT:
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			if (!GetDevInitFlag()) {
				pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
			} else {
				GetDevStatusTask* pTask = new GetDevStatusTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			if (!GetDevInitFlag()) {
				pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
				e->SetHandled();
			}
			else {
				GetDevInfoTask* pTask = new GetDevInfoTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_SETWINPOS:
	{
		SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
        if (!GetDevInitFlag()) {
            pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
			e->SetHandled();
		}
		else {
			SetWinPosTask* pTask = new SetWinPosTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
	}
    break;
	}
	return uRet;
}

void CHSPScannerFSM::s4_ScanImage_on_entry()
{
}

void CHSPScannerFSM::s4_ScanImage_on_exit()
{

}

unsigned int CHSPScannerFSM::s4_ScanImage_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s4_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
		/** JS Component   [Gifur@20241114]*/
		//拍照应该是一瞬间的事情，这个状态很快会结束，JS改造不支持此状态
		/** JS Component Done  [Gifur@20241114]*/
	case USER_EVT_SCANIMAGEFINISHED:
		{
			uRet = e->param1;
			if(uRet == 2 && ++m_nFatalTimes < MAX_ERROR_TIMES)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hold on, wait next time (%d/%d).", m_nFatalTimes, MAX_ERROR_TIMES);
				uRet = 5;
			}
			else if(uRet == 0)
			{
				m_nFatalTimes = 0;
			}

			if(uRet == 5 && IsDevConnected() == 0)
			{
				PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			}
			else if(uRet == 2 || uRet == 4)
			{
				m_desiredAction = USER_EVT_SCANIMAGE;
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_DISCONNECT:
		{
			//jump auto.
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
	break;
	}
	return uRet;
}

void CHSPScannerFSM::s5_DeviceOff_on_entry()
{
	SetDevState(DEVICE_STATUS_CONNECTING);
	SetLastUserCode(HSPScanner_UserErrorCode_DEVICE_OFFLINE);
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(MapCode2RTAString(GetLastUserCode()))("高拍仪断开连接！");
	m_ullTS4Disconnect = SP::Module::Comm::RVCGetTickCount();
	ScheduleTimer(CHECK_CONNECT_TIMER_ID, MILLISECOND_TO_CHECK_CONNECT);
}

void CHSPScannerFSM::s5_DeviceOff_on_exit()
{
	SetLastUserCode();
	SetDevState(DEVICE_STATUS_NORMAL);
	CancelTimer(CHECK_CONNECT_TIMER_ID);
}

unsigned int CHSPScannerFSM::s5_DeviceOff_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s5_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
		/** JS Component  [Gifur@20241112]*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreviewJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("[USER_EVT_STARTPREVIEW_JS] 高拍仪断开连接");
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		pEvt->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreviewJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("[USER_EVT_CANCELPREVIEW_JS] 高拍仪断开连接");
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		pEvt->SetHandled();
	}
	break;
	case USER_EVT_SCANIMAGE_JS:
	{
		JS::ScanImageEvent* pEvt = dynamic_cast<JS::ScanImageEvent*>(e);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImageJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("[USER_EVT_SCANIMAGE_JS] 高拍仪断开连接");
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		pEvt->SetHandled();
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetParamJS).setResultCode(MapCode2RTAString(GetLastUserCode()))("[USER_EVT_SETPARAM_JS] 高拍仪断开连接");
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		pEvt->SetHandled();
	}
	break;
	/** JS Compoent Done  [Gifur@20241112]*/
	case EVT_TIMER:
	{
		if (e->param1 == CHECK_CONNECT_TIMER_ID) {
			HspsDevStatus status = { 0 };
			const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
			ErrorCodeEnum eResult = m_hDevHelper->GetDevStatus(status);
			const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (ISSUCCEEDED(eResult)) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(ullEnd - ullStart)("{\"connected\": %d, \"previewing\": %d, \"showing\": %d}", status.isConnected, status.inPreview, status.inShow);
				if (status.isConnected == 0) {
					ScheduleTimer(CHECK_CONNECT_TIMER_ID, MILLISECOND_TO_CHECK_CONNECT);
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setCostTime(SP::Module::Comm::RVCGetTickCount() - m_ullTS4Disconnect)("高拍仪恢复连接");
					if (status.inShow == 1 && status.inPreview == 1) {
						//回到预览状态
						uRet = 2;
					}
					else if (status.inShow == 0 && status.inPreview == 1) {
						uRet = 3;
					}
					else {
						uRet = 1;
					}
				}
			} else {
				//RTA2N09
				SetErrorAndLog(eResult, MEC_DEVAPI_HSPSCANNER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, ullEnd - ullStart);
			}
			e->SetHandled();
		}
	}
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
	break;
    case USER_EVT_SETWINPOS:
    {
        SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
		pEvt->m_ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
    }
	e->SetHandled();
    break;
	}
	return uRet;
}

void CHSPScannerFSM::s6_HidePreview_on_entry()
{
	m_dupFlag4ExitCancel = false;
}

void CHSPScannerFSM::s6_HidePreview_on_exit()
{
	m_dupFlag4ExitCancel = false;
}

unsigned int CHSPScannerFSM::s6_HidePreview_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s6_HidePreview_on_event: %s, %d.", EvtTypeToString(e->iEvt), e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	/*JS Component*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		HspsDevStatus status = { 0 };
		GetDevStatusFromAdapter(status);
		JS::PreviewSettings settings(pEvt->m_ctx->Req);
		settings.SetDisplay(true);
		ErrorCodeEnum erroCode = SetPreviewProperty(settings, HSPScannerService_LogCode_StartPreviewJS);
		if (FAILURED(erroCode)) {
			pEvt->m_ctx->Answer(Error_Unexpect, GetLastUserCode());
			uRet = 0;
		}
		else {
			ToSwithLight();
			pEvt->m_ctx->Answer(Error_Succeed);
			uRet = 1;
		}
		e->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		if (pEvt->m_ctx->Req.hide) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreviewJS)("current state is already hide preview");
			pEvt->m_ctx->Answer(Error_Succeed);
		}
		else {
			m_dupFlag4ExitCancel = true;
			JS::CancelPreviewTask* pTask = new JS::CancelPreviewTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
	}
	break;
	case USER_EVT_STARTPREVIEW_JS_DONE:
	{
		uRet = e->param1;
		e->SetHandled();
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS_DONE:
	{
		m_dupFlag4ExitCancel = false;
		uRet = e->param1;
		e->SetHandled();
	}
	break;
	case USER_EVT_SCANIMAGE_JS:
	{
		JS::ScanImageTask* pTask = new JS::ScanImageTask(this);
		JS::ScanImageEvent* pEvt = dynamic_cast<JS::ScanImageEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamTask* pTask = new JS::SetParamTask(this);
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		pTask->SetContext(pEvt->m_ctx);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		e->SetHandled();
	}
	break;
	/*JS Component Done*/
	case USER_EVT_STARTPREVIEW:
		{
			StartPreviewTask* pTask = new StartPreviewTask(this);
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		break;
	case USER_EVT_STARTPREVIEW_FINISHED:
	{
		uRet = e->param1;
		e->SetHandled();
		if (uRet == 1 && ++m_nFatalTimes < MAX_ERROR_TIMES) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hold on, wait next time (%d/%d).", m_nFatalTimes, MAX_ERROR_TIMES);
			uRet = 2;
		} else if (uRet == 0) {
			m_nFatalTimes = 0;
		}

		if (uRet == 2 && IsDevConnected() == 0) {
			PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
		} else if (uRet == 1) {
			m_desiredAction = USER_EVT_STARTPREVIEW;
		}
	}
		break;
	case USER_EVT_SETPROPERTY:
		{
			SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
			SetProperty(pEvt->m_ctx);
			e->SetHandled();
		}
		break;
	case USER_EVT_STOPPREVIEW:
		{
			StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
			if(!pEvt->m_ctx->Req.bOnlyHide)
			{//业务在s6状态仅能进行彻底取消预览的操作
				m_dupFlag4ExitCancel = true;
				StopPreviewTask* pTask = new StopPreviewTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			m_dupFlag4ExitCancel = false;
			uRet = e->param1;
			if (uRet == 0 && ++m_nFatalTimes < MAX_ERROR_TIMES) {
				uRet = 3;
			} else if (uRet != 0) {
				m_nFatalTimes = 0;
			}

			if (uRet == 3 && IsDevConnected() == 0) {
				PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_SETWINPOS:
		{
			SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
			if(pEvt->m_ctx->Req.type == 2)
			{//在s6状态，不允许进行显示和隐藏操作，业务必须通过XXXPreview来进行显示隐藏操作
				SetWinPosTask* pTask = new SetWinPosTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_DISCONNECT:
		{
			//jump auto.
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case EVT_MAINPAGE_DISPLAY:
	case USER_EVT_EXIT:
		{
			e->SetHandled();
			if (m_dupFlag4ExitCancel) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s::recv %s while CancelPreviewing", __FUNCTION__, EvtTypeToString(e->iEvt));
				uRet = 1;
			}
		}
		break;
	}

	return uRet;
}

void CHSPScannerFSM::s7_Exit_on_entry()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Enter s7_Exit");
	ExitClearTask* pTask = new ExitClearTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
}

void CHSPScannerFSM::s7_Exit_on_exit()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Leave s7_Exit");
}

//TODO:   [Gifur@20241114]
unsigned int CHSPScannerFSM::s7_Exit_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s7_Exit_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_EXIT_FINISHED:
		{
			uRet = e->param1;
			if (uRet == 1) {
				HspsDevStatus status = { 0 };
				if (ISSUCCEEDED(GetDevStatusFromAdapter(status))) {
					if (status.inPreview) {
						if (status.inShow)
							uRet = 2;
						else uRet = 3;
					} else if (!status.isConnected) {
						uRet = 4;
					}
					else {
						uRet = 0;
					}
				}
			}
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	default:
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s::UnHandle event ! %s", __FUNCTION__, EvtTypeToString(e->iEvt));
			break;
		}
	}
	return uRet;
}

void CHSPScannerFSM::s8_Init_on_entry()
{
	SetLastUserCode(LOG_WARN_HSPS_OPENING_NOW);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(new InitTask(this));
}

void CHSPScannerFSM::s8_Init_on_exit()
{

}

unsigned int CHSPScannerFSM::s8_Init_on_event(FSMEvent* e)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s8_Init_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch (e->iEvt) {
		/** JS Component  [Gifur@20241112]*/
	case USER_EVT_STARTPREVIEW_JS:
	{
		JS::StartPreviewEvent* pEvt = dynamic_cast<JS::StartPreviewEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_CANCELPREVIEW_JS:
	{
		JS::CancelPreviewEvent* pEvt = dynamic_cast<JS::CancelPreviewEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SCANIMAGE_JS:
	{
		JS::ScanImageEvent* pEvt = dynamic_cast<JS::ScanImageEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SETPARAM_JS:
	{
		JS::SetParamEvent* pEvt = dynamic_cast<JS::SetParamEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	/** JS Compoent Done  [Gifur@20241112]*/
	case USER_EVT_STARTPREVIEW:
	{
		StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_STOPPREVIEW:
	{
		StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SCANIMAGE:
	{
		ScanImageEvent* pEvt = dynamic_cast<ScanImageEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SCANIMAGE_EX:
	{
		ScanImageExEvent* pEvt = dynamic_cast<ScanImageExEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SHOWPROPERTY:
	{
		ShowPropertyEvent* pEvt = dynamic_cast<ShowPropertyEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SETPROPERTY:
	{
		SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_SETWINPOS:
	{
		SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_GETSTATUS:
	{
		GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
		pEvt->SetHandled();
		pEvt->m_ctx->Answer(Error_NotInit, GetLastUserCode());
	}
	break;
	case USER_EVT_GOTOHELL:
	{
		e->SetHandled();
	}
	break;
	case USER_EVT_INIT_FINISHED:
	{
		e->SetHandled();
	}
	break;
	default:
		break;
	}
	return uRet;
}

int CHSPScannerFSM::StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
	HSPScannerService_StartPreview_Ans>::Pointer ctx)
{
	bool nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	SetLastUserCode();
	if (ctx->Req.colorType || ctx->Req.scanType || ctx->Req.rotateType) {
		const int retCode = SetPreviewParam(ctx->Req.colorType, ctx->Req.rotateType, ctx->Req.scanType);
		if (retCode != 0)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("SetPreviewParam return some wrong:0x%X", retCode);
			erroCode = Error_DevCommFailed;
		}
		else {
			erroCode = Error_Succeed;
		}
	}
	HspsDevStatus status = { 0 };
	erroCode = GetDevStatusFromAdapter(status);
	if (ISSUCCEEDED(erroCode) && status.inPreview) {// 用于s6状态 [Josephus in 9:33:48 2016/11/22]
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_SHOW);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_SHOW");
		} else {
			//RTA2N0R
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_StartPreview, CombineJsonContext("HSPS_VIEW_SHOW"));
			const DWORD dwCode = GetAlarmDEC();
			CSimpleStringA tmpRTA(true), tmpDesc(true);
			if (GetEntityBase()->GetFunction()->GetVTMErrMsg(dwCode, tmpDesc, tmpRTA) == Error_Succeed)
				DbgToBeidou(ctx->link, "StartPreview::SetParam").setReturnCode(tmpRTA)();
			SetLastUserCode(dwCode);
		}
	} else if (ISSUCCEEDED(erroCode)) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetPreview(1);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (FAILURED(erroCode)) {
			//RTA2N03
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Open, "DevAdapter::SetPreview", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_StartPreview, CombineJsonContext4SetPreview(true, "StartPreview"));
			SetLastUserCode(GetAlarmDEC());
		} else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(true, "StartPreview"));
		}
	}

	if (FAILURED(erroCode)) {
		nRes = 1;
	} else {
		/** 无论如何都打开一次灯，所以这里应该是有所冗余的  [Gifur@2025325]*/
		ToSwithLight();
	}
	ctx->Answer(erroCode, GetLastUserCode());
	return nRes;
}

int CHSPScannerFSM::StopPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
	HSPScannerService_CancelPreview_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if (ctx->Req.bOnlyHide) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_HIDE");
			nRes = 1;
		} else {
			//RTA2N0Q
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_CancelPreview, CombineJsonContext("HSPS_VIEW_HIDE"));
			SetLastUserCode(GetAlarmDEC());
			nRes = 4;
		}
	}
	else
	{
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetPreview(0);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			nRes = 2;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(false));
		} else {
			//RTA2N04
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close, "DevAdapter::SetPreview", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_CancelPreview, CombineJsonContext4SetPreview(false));
			const DWORD dwCode = GetAlarmDEC();
			CSimpleStringA tmpRTA(true), tmpDesc(true);
			if (GetEntityBase()->GetFunction()->GetVTMErrMsg(dwCode, tmpDesc, tmpRTA) == Error_Succeed)
				DbgToBeidou(ctx->link, __FUNCTION__).setReturnCode(tmpRTA)();
			SetLastUserCode(dwCode);
		}
	}
	if (ISSUCCEEDED(erroCode)) {
		/** 取消预览时如果仅仅是隐藏也会关闭灯  [Gifur@2025325]*/
		ToSwithLight(false);
	}
	ctx->Answer(erroCode, GetLastUserCode());
	return nRes;
}

bool CHSPScannerFSM::ResizeImage(const CSimpleStringA& fileName, int kbSize, long& originSize, CSimpleStringA& retMsg)
{
	double rate; //limit rate
	int width;
	int height;

	originSize = 0;
	const int imageSize = kbSize * 1024;
	if (imageSize == 0) return TRUE;

	FILE* fHandle = fopen(fileName.GetData(), "rb");
	if (!fHandle) {
		retMsg = CSimpleStringA::Format("fopen image %s failed: %d", fileName.GetData(), errno);
		return FALSE;
	}

	fseek(fHandle, 0, SEEK_END);
	long fileSize = ftell(fHandle);
	fclose(fHandle);
	originSize = fileSize;
	if (fileSize <= (imageSize)) {
		return TRUE;
	}
	CSimpleStringA backUpFile, backUpPath;
    m_pEntity->GetFunction()->GetPath("Temp", backUpPath);
	backUpFile = backUpPath + SPLIT_SLASH_STR + "backupHSPSCannerImage";
	DeleteFileIfExisted(backUpFile);
	fileutil_copy_file((LPCTSTR)backUpFile, (LPCTSTR)fileName);

	bool success = TRUE;
	while (fileSize > imageSize)
	{
		rate = (double)fileSize / imageSize; 
		rate = 1.0 / sqrt(rate); //width and height limit rate
		cv::Mat img = cv::imread(fileName.GetData());
		if (!img.data) {
			retMsg = CSimpleStringA::Format("Opencv READ failed!");
			success = FALSE;
			break;
		}
		width = img.cols;
		height = img.rows;
		cv::resize(img, img, cv::Size(width * rate, height * rate));
		const bool openwrite = cv::imwrite(fileName.GetData(), img);
		if (!openwrite) {
			retMsg = CSimpleStringA::Format("Opencv WRITE failed!");
			success = FALSE;
			break;
		}

		fHandle = fopen(fileName.GetData(), "rb");
		fseek(fHandle, 0, SEEK_END);
		fileSize = ftell(fHandle);
		fclose(fHandle);
		Sleep(2);
	}

	if (!success) {
		fileutil_copy_file((LPCTSTR)fileName, (LPCTSTR)backUpFile); //recover original img
		DeleteFileIfExisted(backUpFile);
		return FALSE;
	}
	fileSize = fileSize / 1024;
	DeleteFileIfExisted(backUpFile);
	return TRUE;
}

int CHSPScannerFSM::ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req, 
	HSPScannerService_ScanImage_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	CSimpleStringA csImageFile;
	GetCurImageName(csImageFile);
	BOOL bRet = DelAndGetNewFileName(csImageFile);
	if (!bRet) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImage).setResultCode(MapCode2RTAString(HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED))("Cleare previous image failed before ScanImage");
		ctx->Answer(Error_Resource, HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED);
		return 1;
	}
	long pictureSize(0), resizeSize(0);
	ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	erroCode = m_hDevHelper->ScanImage((LPCTSTR)csImageFile);
	ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if (ISSUCCEEDED(erroCode)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::ScanImage").setCostTime(ullEnd - ullStart)();
		CSimpleStringA resizeMsg(true);
		if (ExistsFileA(csImageFile) && !ResizeImage(csImageFile, m_dwMaxImageSize, pictureSize, resizeMsg)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode(MapCode2RTAString(LOG_WARN_HSPS_RESIZE_IMAGE_FILE_FAILED)).setAPI(__FUNCTION__)("Resize image failed:%s", resizeMsg.GetData());
		}
		ctx->Ans.filePath = csImageFile;
		CBlob& cbData = ctx->Ans.imageData;
		const DWORD tmpCode(HSPScanner_UserErrorCode_READ_IMAGE_FILE_FAILED);
		FILE* fHandle = fopen(csImageFile, "rb");
		if (fHandle) {
			fseek(fHandle, 0, SEEK_END);
			long fileSize = ftell(fHandle);
			if (fileSize <= 0) {
				LogWarn(Severity_Middle, Error_NotExist, HSPScanner_UserErrorCode_READ_IMAGE_FILE_ZERO, CSimpleStringA::Format("ftell(%s) error after invoking scanimage: %ld.", (LPCTSTR)csImageFile, fileSize));
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImage).setResultCode(MapCode2RTAString(HSPScanner_UserErrorCode_READ_IMAGE_FILE_ZERO))("ftell(%s) error after invoking scanimage: %ld.", (LPCTSTR)csImageFile, fileSize);
				erroCode = Error_NotExist;
				fclose(fHandle);
				nRes = 4;
			} else {
				resizeSize = fileSize;
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("picture size:%ld", resizeSize);
				cbData.Alloc(fileSize);
				fseek(fHandle, 0, SEEK_SET);
				fread(cbData.m_pData, 1, fileSize, fHandle);
				fclose(fHandle);
			}
		} else {
			erroCode = Error_Resource;
			const int lasterr = errno;
			LogWarn(Severity_Middle, Error_Resource, tmpCode, CSimpleStringA::Format("fopen(%s) failed after invoking scanimage: %d", (LPCTSTR)csImageFile, lasterr));
			SetLastUserCode(tmpCode);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImage).setResultCode(MapCode2RTAString(tmpCode))("fopen(%s) failed  after invoking scanimage: %d", (LPCTSTR)csImageFile, lasterr);
			nRes = 4;
		}
		if (ISSUCCEEDED(erroCode)) {
			
			// Additional ChangeTo Hide --Josephus at 11:32:29 2016/11/22
			if (true/*TODO: */) {
				ullStart = SP::Module::Comm::RVCGetTickCount();
				ErrorCodeEnum eHide = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
				ullEnd = SP::Module::Comm::RVCGetTickCount();
				if (ISSUCCEEDED(eHide)) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_HIDE");
					nRes = 6;
				} else {
					//RTA2N0Q
					SetErrorAndLog(eHide, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, "", CombineJsonContext("HSPS_VIEW_HIDE"));
				}
				/** 拍照成功虽然隐藏了但没有关闭灯  [Gifur@2025325]*/
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImage).setAPI(__FUNCTION__)("ScanImage succ, originalPicSize:%ld, resizePicSize:%ld", pictureSize, resizeSize);
		}
		ctx->Answer(erroCode, GetLastUserCode());
	} else {
		SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_ScanImage, "DevAdapter::ScanImage", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_ScanImage);
		SetLastUserCode(GetAlarmDEC());
		ctx->Answer(erroCode, GetLastUserCode());
		nRes = 2;
	}
	ClearPictureFileSure(1);
	return nRes;
}

int CHSPScannerFSM::ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req, 
	HSPScannerService_ScanImageEx_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	CSimpleStringA csImageFile;
	GetCurImageName(csImageFile, true);
	BOOL bRet = DelAndGetNewFileName(csImageFile);
	if (!bRet) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode(MapCode2RTAString(HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED))("Cleare previous image failed before ScanImageEx");
		ctx->Answer(Error_Resource, HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED);
		return 1;
	}

	int len = 0;
	BYTE* pBtImage = NULL;
	LogWarn(Severity_Low, Error_Debug, LOG_DEBUG_HSPS_CRITICAL_OPERATION_SCANIMAGEEX_START, "to ScanImageEx...");
	ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	erroCode = m_hDevHelper->ScanImageEx(pBtImage, len, (LPCTSTR)csImageFile);
	ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if(erroCode == Error_TooSmallBuffer) {
		if (pBtImage) {
			delete pBtImage;
			pBtImage = NULL;
		}

		len += MAX_IMAGEDATA_SUFFIX;
		pBtImage = new BYTE[len+1];
		if (pBtImage == NULL) {
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_ScanImageEx).setResultCode("RTA2N0T")("new buffer[%d] failed %d.", len + 1, GetLastError());
			ctx->Answer(Error_Resource);
			return 3;
		}
		memset((void*)pBtImage, 0, len+1);
		ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->ScanImageEx(pBtImage, len, (LPCTSTR)csImageFile);
		ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (erroCode == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::ScanImageEx").setCostTime(ullEnd - ullStart)("len: %d, btLen:%d.", len, strlen((const char*)pBtImage));
		}
	}
	if (ISSUCCEEDED(erroCode)) {
		long pictureSize(0);
		CSimpleStringA resizeMsg(true);
		if (ResizeImage(csImageFile, m_dwMaxImageSize, pictureSize, resizeMsg)) {
			FILE* fHandle = fopen(csImageFile.GetData(), "rb");
			fseek(fHandle, 0, SEEK_END);
			len = ftell(fHandle);

			fseek(fHandle, 0, SEEK_SET);
			if (pBtImage) delete[] pBtImage;
			pBtImage = new BYTE[len];
			fread(pBtImage, 1, len, fHandle);
			fclose(fHandle);
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode(MapCode2RTAString(LOG_WARN_HSPS_RESIZE_IMAGE_FILE_FAILED)).setAPI(__FUNCTION__)("Resize image failed:%s", resizeMsg.GetData());
		}
		ctx->Ans.filePath = csImageFile;
		CBlob& cbData = ctx->Ans.imageData;

		cbData.Alloc((len + 1) * sizeof(BYTE));
		memcpy_s(cbData.m_pData, cbData.m_iLength, pBtImage, len);
		cbData.Resize(len);

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ScanImageEx ctx: %s, %d.", (LPCTSTR)ctx->Ans.filePath, ctx->Ans.imageData.m_iLength);
		// Additional ChangeTo Hide --Josephus at 11:29:03 2016/11/22
		if (ISSUCCEEDED(erroCode)) {
			ullStart = SP::Module::Comm::RVCGetTickCount();
			ErrorCodeEnum eHide = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
			ullEnd = SP::Module::Comm::RVCGetTickCount();
			if (ISSUCCEEDED(eHide)) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)("HSPS_VIEW_HIDE");
				nRes = 6;
			} else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart).setResultCode(MapCode2RTAString(HSPScanner_UserErrorCode_SetParam_Hide))("HSPS_VIEW_HIDE failed: %s", SpStrError(eHide));
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(HSPScannerService_LogCode_ScanImageEx)("ScanImageEx ctx: %s, %d.", (LPCTSTR)ctx->Ans.filePath, ctx->Ans.imageData.m_iLength);
		}
		ctx->Answer(erroCode);
	} else {
		//RTA2N06
		SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_ScanImageEx, "DevAdapter::ScanImageEx", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_ScanImageEx);
		SetLastUserCode(GetAlarmDEC());
		ctx->Answer(erroCode, GetLastUserCode());
		nRes = 2;
		}

	if (pBtImage) {
		delete pBtImage;
		pBtImage = NULL;
	}
	ClearPictureFileSure(2);
	return nRes;
}

int CHSPScannerFSM::ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
	HSPScannerService_ShowProperty_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Succeed;
	// Return ahead. [Josephus in 15:24:15 2016/11/21]
	const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum ePos = m_hDevHelper->SetViewPos(730, 100, 540);
	const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if (FAILURED(ePos)) {
		//RTA2N07
		SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetViewPos, "DevAdapter::SetViewPos", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_ShowProperty);
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ShowProperty).setAPI("DevAdapter::SetViewPos").setCostTime(ullEnd - ullStart)();
	}
	ctx->Answer(erroCode);
	
	DWORD dwStart = GetTickCount();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Start to show Property dialog...");
	erroCode = m_hDevHelper->SetProperty();
	DWORD dwEnd = GetTickCount();
	if (FAILURED(erroCode)) {
		//RTA2N0U
		SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetProperty, "DevAdapter::SetProperty", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_ShowProperty);
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetProperty").setCostTime(dwEnd - dwStart)();
		erroCode = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
	}
	return 0;
}

int CHSPScannerFSM::SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req, 
	HSPScannerService_SetProperty_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	int retCode = SetPreviewParam(ctx->Req.colorType, ctx->Req.rotateType, ctx->Req.scanType);
	if (retCode != 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetProperty).setResultCode(MapCode2RTAString(GetLastUserCode()))("SetParam failed retCode: 0x%X", retCode);
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetProperty)("Set Property succ.");
	}
	ctx->Ans.retCode = retCode;
	ctx->Answer(Error_Succeed);
	return nRes;
}

int CHSPScannerFSM::SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
	HSPScannerService_SetWinPos_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	ParamTypeValue value = HSPS_VIEW_SHOW;
	bool bSetCustom = false;
	switch (ctx->Req.type) {
	case 0: value = HSPS_VIEW_HIDE; break;
	case 1: value = HSPS_VIEW_SHOW; break;
	case 2: bSetCustom = true; break;
	default:
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetWinPos).setResultCode(MapCode2RTAString(HSPScanner_UserErrorCode_NOT_SUPPORT))("invalid param for SetWinPos operation type(%d).", ctx->Req.type);
		ctx->Answer(Error_Param, HSPScanner_UserErrorCode_NOT_SUPPORT);
		return nRes = 3;
	}
	break;
	}

	if (bSetCustom) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetViewPos(ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetViewPos").setLogCode(HSPScannerService_LogCode_SetWinPos).setCostTime(ullEnd - ullStart)("x:%d, y:%d, w:%d", ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth);
			m_nRecX = ctx->Req.pointX;
			m_nRecY = ctx->Req.pointY;
			m_nRecW = ctx->Req.nWidth;
		} else {
			//RTA2N07
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetViewPos, "DevAdapter::SetViewPos", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_SetWinPos);
			SetLastUserCode(GetAlarmDEC());
			nRes = 2;
		}
	} else {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, value);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setLogCode(HSPScannerService_LogCode_SetWinPos).setCostTime(ullEnd - ullStart)("%d", value);
		} else {
			//RTA2N02
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_SetWinPos);
			SetLastUserCode(GetAlarmDEC());
			nRes = 1;
		}
	}
	if (!ISSUCCEEDED(erroCode)) {
		CSimpleStringA tmpRTA(true), tmpDesc(true);
		if (GetEntityBase()->GetFunction()->GetVTMErrMsg(GetLastUserCode(), tmpDesc, tmpRTA) == Error_Succeed)
			DbgToBeidou(ctx->link, "SetWinPos").setReturnCode(tmpRTA)();
	}
	ctx->Answer(erroCode, GetLastUserCode());
	return nRes;
}

//JS改造后，作为内部逻辑处理，没有使用该接口
int CHSPScannerFSM::GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req, 
	HSPScannerService_GetDevStatus_Ans>::Pointer ctx)
{
	int nRes = 0;
	HspsDevStatus status = { 0 };
	ErrorCodeEnum erroCode = GetDevStatusFromAdapter(status, true);
	if (ISSUCCEEDED(erroCode)) {
		ctx->Ans.connected = status.isConnected;
		ctx->Ans.previewing = status.inPreview;
		ctx->Ans.showing = status.inShow;
	}
	else {
		nRes = 1;
	}
	ctx->Answer(erroCode, GetLastUserCode());
	return nRes;
}

ErrorCodeEnum CHSPScannerFSM::GetDevStatusFromAdapter(HspsDevStatus& status, bool fromBusiness)
{
	ErrorCodeEnum erroCode(Error_NotInit);
	if (m_hDevHelper) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->GetDevStatus(status);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_DEBUG, fromBusiness ? LOG_TYPE_USER : LOG_TYPE_SYSTEM).setLogCode(fromBusiness ? HSPScannerService_LogCode_GetDevStatus : "").setAPI("DevAdapter::GetDevStatus").setCostTime(ullEnd - ullStart)("{\"connected\": %d, \"previewing\": %d, \"showing\": %d}", status.isConnected, status.inPreview, status.inShow);
		}
		else {
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, fromBusiness ? IsInBusiness() : false, ullEnd - ullStart, fromBusiness ? HSPScannerService_LogCode_GetDevStatus : "");
			if (fromBusiness) SetLastUserCode(GetAlarmDEC());
		}
	}
	return erroCode;
}

int CHSPScannerFSM::GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
	HSPScannerService_GetDevInfo_Ans>::Pointer ctx)
{
	int nRes = 0;
	if (m_bOpening) {
		//如果打开还没有结束，GetDevInfo返回Error_NotInit
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_GetDevInfo).setResultCode(MapCode2RTAString(LOG_WARN_HSPS_OPENING_NOW)).setAPI(__FUNCTION__)("device is opening");
		ctx->Answer(Error_NotInit, LOG_WARN_HSPS_OPENING_NOW);
		nRes = 1;
	
	} else if (!m_bOpened) {
		//如果打开失败，GetDevInfo应该返回Error_DevNotAvailable
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_GetDevInfo).setAPI(__FUNCTION__).setResultCode(MapCode2RTAString(GetLastUserCode()))("高拍仪设备未打开");
		ctx->Answer(Error_DevNotAvailable, GetLastUserCode());
		nRes = 1;

	} else {
		//打开成功。GetDevInfo返回Error_Succeed，state放获取模块信息（GetDevCategory这个适配器接口调用）的返回值
		DevCategoryInfo info = { 0 };
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		ErrorCodeEnum erroCode = m_hDevHelper->GetDevCategory(info);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		ctx->Ans.state = (int)(erroCode);
		if (ISSUCCEEDED(erroCode)) {
			ctx->Ans.model = info.szModel;
			ctx->Ans.type = info.szType;
			ctx->Ans.version = CSimpleStringA::Format("%d.%d.%d.%d",
				info.version.wMajor, info.version.wMinor, info.version.wRevision, info.version.wBuild);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_GetDevInfo).setAPI("DevAdapter::GetDevCategory").setCostTime(ullEnd - ullStart)("model: %s, state:%d, type:%s, version:%s"
				, ctx->Ans.model.GetData(), ctx->Ans.state, ctx->Ans.type.GetData(), ctx->Ans.version.GetData());
		}
		else {
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_GetDevInfo);
			SetLastUserCode(GetAlarmDEC());
			nRes = 1;
		}
		ctx->Answer(Error_Succeed);
	}
	return nRes;
}

int CHSPScannerFSM::Initial()
{
	SetDevInitingFlag(true);
	SetDevInitFlag(false);
	ErrorCodeEnum erroCode = LoadUpAdapterLibrary();
	if (erroCode == Error_Succeed) {
		if (Error_Succeed == (erroCode = TryToOpenDevice())) {
			SetDevInitFlag(true);
			SetDevState(DEVICE_STATUS_NORMAL);
			SetDevInitingFlag(false);
			return 0;
		}
	}
	else if (erroCode == Error_NotExist) {
		SetLastUserCode(HSPScanner_UserErrorCode_LOAD_DLLFILE_NOTEIXT);
	}
	else {
		SetLastUserCode(HSPScanner_UserErrorCode_LOAD_DLLFILE_FAILED);
	}
	SetDevInitingFlag(false);
	SetDevInitFlag(false);
	return 1;
}

BOOL CHSPScannerFSM::GetCurImageName(CSimpleStringA& csImagName, bool bExt /*= false*/)
{
    if (bExt) {
        csImagName = "MaterialImageExt.jpg";
    } else {
        csImagName = "MaterialImage.jpg";
    }
    return TRUE;
}

BOOL CHSPScannerFSM::DelAndGetNewFileName(CSimpleStringA& csfileName, bool bInBusiness)
{
	char fileName[MAX_PATH_SIZE] = {0};
	memset(fileName, 0, sizeof(char)*MAX_PATH_SIZE);
	strcpy_s(fileName, MAX_PATH_SIZE, (LPCTSTR)csfileName);
	if (strlen(fileName) == 0 || strchr(fileName, (int)'*') != NULL) {
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Error input param");
		return FALSE;
	}
	CSimpleStringA strPath, strAimPath;
	m_pEntity->GetFunction()->GetPath("Dep", strPath);
	strAimPath = strPath + SPLIT_SLASH_STR + fileName;

	UpdateAndWarnFileFindInDepBak(strAimPath, fileName, HSPScanner_UserErrorCode_FindFile_in_DepBak);
	csfileName = strAimPath;
	if (ExistsFileA(csfileName)) {
		if (RemoveFileA((LPCTSTR)strAimPath) != 0) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("DeleteFile(%s) suc.", (LPCTSTR)strAimPath);
			return TRUE;
		} else {
			if (bInBusiness) {
				DWORD  lastErr = GetLastError();
				if (lastErr == 5) {
					Sleep(100);
					if (!ExistsFileA(csfileName) || RemoveFileA((LPCTSTR)strAimPath) != 0) {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("DeleteFile(%s) suc.", (LPCTSTR)strAimPath);
						return TRUE;
					}
					lastErr = GetLastError();
				} 
				LogError(Severity_Middle, Error_Unexpect, HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED, CSimpleStringA::Format(
					"DeleteFile(%s)  failed before ScanImage, LastError(%d).", (LPCTSTR)strAimPath, lastErr));
			} else {
				LogWarn(Severity_High, Error_Unexpect, HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED, CSimpleStringA::Format(
					"DeleteFile(%s) failed, LastError(%d).", (LPCTSTR)strAimPath, GetLastError()));
			}
			return FALSE;
		}
	} else {
		return TRUE;
	}
}

ErrorCodeEnum CHSPScannerFSM::OnDevExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed;
	if(m_hDevHelper)
	{
		HspsDevStatus status = { 0 };
		erroCode = GetDevStatusFromAdapter(status);
		if (ISSUCCEEDED(erroCode) && status.isConnected)
		{
			if (status.inPreview) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Invoke cancelPreview...");
				const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
				erroCode = m_hDevHelper->SetPreview(0);
				const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
				if (ISSUCCEEDED(erroCode)) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setLogCode(__FUNCTION__).setLogCode(CustomLogCode_CancelPreview_Default).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(false, "OnDevExit"));
					ToSwithLight(false);
				} else {
					//RTA2N04
					SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close, "DevAdapter::SetPreview", __FUNCTION__, false, ullEnd - ullStart, CustomLogCode_CancelPreview_Default, CombineJsonContext4SetPreview(false));
				}
			}
		} else if(ISSUCCEEDED(erroCode) && !status.isConnected){
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("HSPSCanner device is disconnected!");
		}
	}

	ClearPictureFileSure();
	return erroCode;
}

void CHSPScannerFSM::SelfTest(EntityTestEnum eTestType,
	CSmartPointer<ITransactionContext> pTransactionContext)
{
	OnHardwareShakeHand(pTransactionContext);
}

void CHSPScannerFSM::OnStateTrans(int iSrcState, int iDstState) 
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("trans from %s to %s", GetStateName(iSrcState), GetStateName(iDstState));
	m_nSrcState = iSrcState;
}

int CHSPScannerFSM::StartPreviewJS(SpReqAnsContext<HSPScannerService_StartPreviewJS_Req, HSPScannerService_StartPreviewJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Unexpect;
	int ret(0);
	SetLastUserCode();
	if(JS::PreviewSettings(ctx->Req).IsAvailable()) {
		erroCode = SetPreviewProperty(JS::PreviewSettings(ctx->Req), HSPScannerService_LogCode_StartPreviewJS);
		if (FAILURED(erroCode)) {
			ctx->Answer(Error_Unexpect, GetLastUserCode());
			return 1;
		}
	}
	//TODO:   [Gifur@2025318]
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("Start to Preview...");
	ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	erroCode = m_hDevHelper->SetPreview(1);
	ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if (FAILURED(erroCode)) {
		SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Open, "DevAdapter::SetPreview", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_StartPreviewJS, CombineJsonContext4SetPreview(true));
		SetLastUserCode(GetAlarmDEC());
		erroCode = Error_Unexpect;
		ret = 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreviewJS).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(true, "StartPreview"));
		ToSwithLight();
	}

	ctx->Answer(erroCode, GetLastUserCode());
	return ret;
}

int CHSPScannerFSM::CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreviewJS_Req, HSPScannerService_CancelPreviewJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Unexpect;
	int ret(0);
	SetLastUserCode();
	if (ctx->Req.hide) {
		erroCode = SetPreviewProperty(JS::PreviewSettings(false), HSPScannerService_LogCode_CancelPreviewJS);
		if (FAILURED(erroCode)) {
			ctx->Answer(Error_Unexpect, GetLastUserCode());
			ret = 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreviewJS)("HSPS_VIEW_HIDE");
			ctx->Answer(Error_Succeed);
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("Start to CancelPreview...");
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetPreview(0);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreviewJS).setAPI("DevAdapter::SetPreview").setCostTime(ullEnd - ullStart)(CombineJsonContext4SetPreview(false, "JS::CancelPreview"));
			ctx->Answer(Error_Succeed);
		}
		else {
			//RTA2N04
			SetErrorAndLog(erroCode, LOG_EVT_HSPS_CANCEL_PREVIEW_FAILED, "DevAdapter::SetPreview", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_CancelPreviewJS, CombineJsonContext4SetPreview(false));
			SetLastUserCode(GetAlarmDEC());
			ctx->Answer(Error_Unexpect, GetLastUserCode());
			ret = 1;
		}
	}

	if (ISSUCCEEDED(erroCode)) {
		ToSwithLight(false);
	}
	return ret;
}

int CHSPScannerFSM::ScanImageJS(SpReqAnsContext<HSPScannerService_ScanImageJS_Req, HSPScannerService_ScanImageJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Unexpect;
	int ret(0);
	SetLastUserCode();
	CSimpleStringA csImageFile(true);
	GetCurImageName(csImageFile);
	DelAndGetNewFileName(csImageFile);
	ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	erroCode = m_hDevHelper->ScanImage((LPCTSTR)csImageFile);
	ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if (ISSUCCEEDED(erroCode)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::ScanImage").setCostTime(ullEnd - ullStart)();
		long pictureSize(0), resizeSize(0);
		CSimpleStringA resizeMsg(true);
		if (ctx->Req.compress > 0 && ExistsFileA(csImageFile) && !ResizeImage(csImageFile, ctx->Req.compress/*KB*/, pictureSize, resizeMsg)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setResultCode(MapCode2RTAString(LOG_WARN_HSPS_RESIZE_IMAGE_FILE_FAILED)).setAPI(__FUNCTION__).setLogCode(HSPScannerService_LogCode_ScanImageJS).setCostTime(ullEnd - ullStart)("Resize image failed:%s", resizeMsg.GetData());
			SetLastUserCode(LOG_WARN_HSPS_RESIZE_IMAGE_FILE_FAILED);
			erroCode = Error_Unexpect;
			ret = 1;
		}
		else {
			CSimpleStringA tmpMsg(true);
			DWORD tmpCode(0);
			CBlob& cbData = ctx->Ans.imageData;
			FILE* fHandle = fopen(csImageFile, "rb");
			if (fHandle) {
				fseek(fHandle, 0, SEEK_END);
				long fileSize = ftell(fHandle);
				resizeSize = fileSize;
				if (fileSize <= 0) {
					tmpMsg = CSimpleStringA::Format("ftell(%s) error after invoking scanimage: %ld.", (LPCTSTR)csImageFile, fileSize);
					tmpCode = HSPScanner_UserErrorCode_READ_IMAGE_FILE_ZERO;
				}
				else {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("picture size:%ld", fileSize);
					cbData.Alloc(fileSize);
					fseek(fHandle, 0, SEEK_SET);
					fread(cbData.m_pData, 1, fileSize, fHandle);
				}
				fclose(fHandle);
			}
			else {
				tmpMsg = CSimpleStringA::Format("fopen(%s) error after invoking scanimage: %d.", (LPCTSTR)csImageFile, errno);
				tmpCode = HSPScanner_UserErrorCode_READ_IMAGE_FILE_FAILED;
			}

			if (!tmpCode) {//Succ
				if (ctx->Req.hide && FAILURED(SetPreviewProperty(JS::PreviewSettings(false), HSPScannerService_LogCode_ScanImageJS))) {
					erroCode = Error_Unexpect;
					ret = 1;
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImageJS).setAPI(__FUNCTION__)("ScanImage succ, originalPicSize:%ld, resizePicSize:%ld", pictureSize, resizeSize);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImageJS).setResultCode(MapCode2RTAString(tmpCode))(tmpMsg.GetData());
				SetLastUserCode(tmpCode);
				erroCode = Error_Unexpect;
				ret = 1;
			}
		}
	}
	else {
		SetErrorAndLog(erroCode, LOG_EVT_HSPS_SCANIMAGE_FAILED, "DevAdapter::ScanImage", __FUNCTION__
			, IsInBusiness(), ullEnd - ullStart, HSPScannerService_LogCode_ScanImageJS);
		SetLastUserCode(GetAlarmDEC());
		erroCode = Error_Unexpect;
		ret = 1;
	}
	ctx->Answer(erroCode, GetLastUserCode());
	ClearPictureFileSure(1);
	return ret;
}

int CHSPScannerFSM::SetParam(SpReqAnsContext<HSPScannerService_SetParamJS_Req, HSPScannerService_SetParamJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Unexpect;
	int ret(0);
	SetLastUserCode();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("rotate:%d,scan:%d,color:%d,pos:%d,x:%d,y:%d,w:%d",
		ctx->Req.rotate, ctx->Req.scan, ctx->Req.color, ctx->Req.pos, ctx->Req.pos_x, ctx->Req.pos_y, ctx->Req.pos_w);
	erroCode = SetPreviewProperty(JS::PreviewSettings(ctx->Req), HSPScannerService_LogCode_SetParamJS);
	if (FAILURED(erroCode)) ret = 1;
	ctx->Answer(erroCode, GetLastUserCode());
	return ret;
}

ErrorCodeEnum CHSPScannerFSM::SetPreviewProperty(const JS::PreviewSettings& val, const char* logCode)
{
	ErrorCodeEnum erroCode(Error_Succeed);
	const bool isBusiness = (logCode == NULL || strlen(logCode) == 0) ? false : IsInBusiness();
	if (val.color > 0 && val.color < 4) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, Param_Color_Map[val.color]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Color_Map[val.color]));
		}
		else {
			SetErrorAndLog(erroCode, HSPScanner_UserErrorCode_SetParam_Color, "DevAdapter::SetParam", __FUNCTION__, isBusiness, ullEnd - ullStart, logCode, CombineJsonContext(ParamValToString(Param_Color_Map[val.color])));
			SetLastUserCode(GetAlarmDEC());
			return Error_Unexpect;
		}
	}
	//////////////////////////////////////////////////////////////////////////
	if (val.rotate > 0 && val.rotate < 5) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, Param_Rotate_Map[val.rotate]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Rotate_Map[val.rotate]));
		}
		else {
			SetErrorAndLog(erroCode, HSPScanner_UserErrorCode_SetParam_Rotate, "DevAdapter::SetParam", __FUNCTION__, isBusiness, ullEnd - ullStart, logCode, CombineJsonContext(ParamValToString(Param_Rotate_Map[val.rotate])));
			SetLastUserCode(GetAlarmDEC());
			return Error_Unexpect;
		}
	}
	//////////////////////////////////////////////////////////////////////////
	if (val.scan > 0 && val.scan < 4) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, Param_Scan_Map[val.scan]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Scan_Map[val.scan]));
		}
		else {
			SetErrorAndLog(erroCode, HSPScanner_UserErrorCode_SetParam_Scan, "DevAdapter::SetParam", __FUNCTION__, isBusiness, ullEnd - ullStart, logCode, CombineJsonContext(ParamValToString(Param_Scan_Map[val.scan])));
			SetLastUserCode(GetAlarmDEC());
			return Error_Unexpect;
		}
	}

	//////////////////////////////////////////////////////////////////////////
	if (val.pos != 0) {
		CSimpleStringA tmpParm = CSimpleStringA::Format("x:%d, y:%d, w:%d", val.pos_x, val.pos_y, val.pos_w);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("Start to SetViewPos %s...", tmpParm.GetData());
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetViewPos(val.pos_x, val.pos_y, val.pos_w);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetViewPos").setCostTime(ullEnd - ullStart)(tmpParm);
			m_nRecX = val.pos_x;
			m_nRecY = val.pos_y;
			m_nRecW = val.pos_w;
		}
		else {
			//RTA2N07
			SetErrorAndLog(erroCode, HSPScanner_UserErrorCode_SetParam_Position, "DevAdapter::SetViewPos", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, logCode, CombineJsonContext(tmpParm));
			SetLastUserCode(GetAlarmDEC());
			return Error_Unexpect;
		}
	}
	//////////////////////////////////////////////////////////////////////////
	if (val.view != 0) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, Param_View_Map[val.view]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_View_Map[val.view]));
		}
		else {
			SetErrorAndLog(erroCode, val.view == 1 ? HSPScanner_UserErrorCode_SetParam_View : HSPScanner_UserErrorCode_SetParam_Hide
				, "DevAdapter::SetParam", __FUNCTION__, isBusiness, ullEnd - ullStart, logCode, CombineJsonContext(ParamValToString(Param_View_Map[val.view])));
			SetLastUserCode(GetAlarmDEC());
			return Error_Unexpect;
		}
	}
	return erroCode;
}

void CHSPScannerFSM::ToSwithLight(bool turnOn /*= true*/)
{
	if (m_lightOn != turnOn) {
		if (turnOn) LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_ON, "HSPScanner warning on.");
		else LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_OFF, "HSPScanner warning off.");
		m_lightOn = turnOn;
	}
}

//TODO: JS完全替换后，这个函数要废弃换成SetPreviewProperty替代  [Gifur@2025318]
int CHSPScannerFSM::SetPreviewParam(int colorType, int rotateType, int scanType, bool abortIfFault)
{
	ErrorCodeEnum erroCode;
	int retCode = 0;
	if (colorType > 0 && colorType < 4) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, Param_Color_Map[colorType]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Color_Map[colorType]));
		}
		else {
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, abortIfFault ? IsInBusiness() : false, ullEnd - ullStart, HSPScannerService_LogCode_SetProperty, CombineJsonContext(ParamValToString(Param_Color_Map[colorType])));
			retCode |= 0x0001;
			SetLastUserCode(GetAlarmDEC(MEC_DEVAPI_HSPSCANNER_SetParam));
		}
	}
	//////////////////////////////////////////////////////////////////////////
	if (rotateType > 0 && rotateType < 5) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, Param_Rotate_Map[rotateType]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Rotate_Map[rotateType]));
		}
		else {
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, abortIfFault ? IsInBusiness() : false, ullEnd - ullStart, HSPScannerService_LogCode_SetProperty, CombineJsonContext(ParamValToString(Param_Rotate_Map[rotateType])));
			retCode |= 0x0002;
			SetLastUserCode(GetAlarmDEC(MEC_DEVAPI_HSPSCANNER_SetParam));
		}
	}
	//////////////////////////////////////////////////////////////////////////
	if (scanType > 0 && scanType < 4) {
		const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, Param_Scan_Map[scanType]);
		const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (ISSUCCEEDED(erroCode)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::SetParam").setCostTime(ullEnd - ullStart)(ParamValToString(Param_Scan_Map[scanType]));
		}
		else {
			SetErrorAndLog(erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, abortIfFault ? IsInBusiness() : false, ullEnd - ullStart, HSPScannerService_LogCode_SetProperty, CombineJsonContext(ParamValToString(Param_Scan_Map[scanType])));
			retCode |= 0x0004;
			SetLastUserCode(GetAlarmDEC(MEC_DEVAPI_HSPSCANNER_SetParam));
		}
	}
	return retCode;
}

ErrorCodeEnum CHSPScannerFSM::DeleteFileIfExisted(LPCTSTR fileName)
{
	if (ExistsFileA(fileName)) {
		if (RemoveFileA(fileName) != 0) {
			return Error_Succeed;
		}
		else {
			LogWarn(Severity_High, Error_Unexpect, HSPScanner_UserErrorCode_CLEAR_RESOURCE_FAILED, CSimpleStringA::Format(
				"DeleteFile(%s) failed LastError(%d)", fileName, GetLastError()));
			return Error_Unexpect;
		}
	}
	else {
		return Error_Succeed;
	}
}

void CHSPScannerFSM::InitialMaxResizeValue()
{
	CSmartPointer<IEntityFunction> spFunction = this->GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	spFunction->OpenConfig(Config_CenterSetting, spConfig);
	int kb = 0;
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "ImageMaxSize", kb);
	if (kb > 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Get image max size from CS: %d", kb);
		m_dwMaxImageSize = kb;
		return;
	}
}

ErrorCodeEnum CHSPScannerFSM::TryToOpenDevice()
{
	ErrorCodeEnum result(Error_Succeed);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to open device...");
	ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
	result = m_hDevHelper->DevOpen();
	ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
	if (FAILURED(result)) {
		//RTA2N01 / 21700001
		SetErrorAndLog(result, MEC_DEVAPI_HSPSCANNER_DevOpen, "DevAdapter::DevOpen", __FUNCTION__, false, ullEnd - ullStart);
		SetLastUserCode(LOG_ERR_HSPS_DEVOPEN_FAILED);
	}
	else {
		SetLastUserCode();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(ullEnd - ullStart)();
		ullStart = SP::Module::Comm::RVCGetTickCount();
		result = FulfillAdapterDevCategory();
		ullEnd = SP::Module::Comm::RVCGetTickCount();
		if (result != Error_Succeed) {
			SetErrorAndLog(result, MEC_DEVAPI_HSPSCANNER_GetDevCategory, "DevAdapter::GetDevCategory", "FulfillAdapterDevCategory", false, ullEnd - ullStart);
		}
		m_nRecX = 0;
		m_nRecY = 224;
		m_nRecW = 1024;
		ErrorCodeEnum ecInit = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
		if (FAILURED(ecInit))
			SetErrorAndLog(ecInit, MEC_DEVAPI_HSPSCANNER_SetViewPos, "DevAdapter::SetViewPos", __FUNCTION__, false);
		ErrorCodeEnum ecInitScan = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL);
		if (FAILURED(ecInitScan))
			SetErrorAndLog(ecInitScan, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, 0, "", CombineJsonContext("HSPS_SCAN_FULL"));
		ErrorCodeEnum ecInitRotate = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE);
		if (FAILURED(ecInitRotate))
			SetErrorAndLog(ecInitRotate, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, 0, "", CombineJsonContext("HSPS_ROTATE_NOANGLE"));
		ErrorCodeEnum ecInitColor = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL);
		if (FAILURED(ecInitColor))
			SetErrorAndLog(ecInitColor, MEC_DEVAPI_HSPSCANNER_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, 0, "", CombineJsonContext("HSPS_COLOR_FULL"));
	}
	return result;
}

LPCTSTR CHSPScannerFSM::MapCode2RTAString(DWORD dwValue)
{
	static CSimpleStringA tmpRTA(true);
	CSimpleStringA tmpDesc(true);
	ErrorCodeEnum err(Error_Succeed);
	tmpRTA = "";
	if ((err=GetEntityBase()->GetFunction()->GetVTMErrMsg(dwValue, tmpDesc, tmpRTA)) == Error_Succeed) {
		return tmpRTA.GetData();
	}
	else if (dwValue != 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cannot found 0x%X from ResStatic: %s", dwValue, SpStrError(err));
	}
	/** 降级处理  [Gifur@2025325]*/
	switch (dwValue) {
	case 0x2170000C: /*未登记到资源管理平台*/
		return "RTA2N0C";
		break;
	case 0x21700204: /*未登记到资源管理平台*/
		return "RTA2N0S";
		break;
	case 0:
	default:
		return "SUC0000";
		break;
	}
}