myvtm/Module/mod_ScannerSet/ScannerSetFSM.cpp

#include "stdafx.h"
#include "ScannerSetFSM.h"
#include "EventCode.h"
#include "SpIni.h"
#include "toolkit.h"
#include "iniutil.h"
#include "CommEntityUtil.hpp"
#include "path.h"

#define CHECKDEV_TIMER_ID 1
const int MILLISECOND_TO_CHECKDEV = 15 * 1000;
const int MILLISECOND_TO_CHECK_CONNECT = 30 * 1000;

const int MILLISECOND_WAIT_TIMEOUT_DEFAULT = 10 * 1000;
const int MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW = 20 * 1000;
const int MILLISECOND_WAIT_TIMEOUT_SCANIMAGE = 15 * 1000;

#define MODULE_VERION_FULL "2024.6"

const char* EvtTypeToString(int nEvtType)
{
	switch(nEvtType)
	{
	case USER_EVT_STARTPREVIEW: return "USER_EVT_STARTPREVIEW";
		break;
	case USER_EVT_STARTPREVIEW_FINISHED: return "USER_EVT_STARTPREVIEW_FINISHED";
		break;
	case USER_EVT_STOPPREVIEW: return "USER_EVT_STOPPREVIEW";
		break;
	case USER_EVT_STOPPREVIEW_FINISHED: return "USER_EVT_STOPPREVIEW_FINISHED";
		break;
	case USER_EVT_SETWINPOS: return "USER_EVT_SETWINPOS";
		break;
	case USER_EVT_SETWINPOS_FINISHED: return "USER_EVT_SETWINPOS_FINISHED";
		break;
	case USER_EVT_SCANIMAGE: return "USER_EVT_SCANIMAGE";
		break;
	case USER_EVT_SCANIMAGEFINISHED: return "USER_EVT_SCANIMAGEFINISHED";
		break;
	case USER_EVT_SETPROPERTY: return "USER_EVT_SETPROPERTY";
		break;
	case USER_EVT_SETPROPERTY_FINISHED: return "USER_EVT_SETPROPERTY_FINISHED";
		break;
	case USER_EVT_SHOWPROPERTY: return "USER_EVT_SHOWPROPERTY";
		break;
	case USER_EVT_SHOWPROPERTY_FINISHED: return "USER_EVT_SHOWPROPERTY_FINISHED";
		break;
	case USER_EVT_GETSTATUS: return "USER_EVT_GETSTATUS";
		break;
	case USER_EVT_GETSTATUS_FINISHED: return "USER_EVT_GETSTATUS_FINISHED";
		break;
	case USER_EVT_GETINFO: return "USER_EVT_GETINFO";
		break;
	case USER_EVT_GETINFO_FINISHED: return "USER_EVT_GETINFO_FINISHED";
		break;
	case USER_EVT_EXIT: return "USER_EVT_EXIT";
		break;
	case USER_EVT_QUIT: return "USER_EVT_QUIT";
		break;
	case USER_EVT_RESET: return "USER_EVT_RESET";
		break;

	case USER_EVT_DEV_INVALID: return "USER_EVT_DEV_INVALID";
		break;
	case USER_EVT_DEV_RECOVER: return "USER_EVT_DEV_RECOVER";
		break;
	case USER_EVT_OPERATING: return "USER_EVT_OPERATING";
		break;
	case EVT_TIMER: return "EVT_TIMER";
		break;
	default:
		return "Unknown EventType";
		break;
	}
}

static bool MapErrorCode2Level(ErrorCodeEnum ec)
{
	return (ec == Error_IO || ec == Error_NetBroken || ec == Error_TimeOut);
}

CScannerFSM::CScannerFSM(void)
	:
	m_pHSPSClient(NULL),
	m_ecSelfTest(Error_Succeed),
	m_dwErroCode(0),
	m_nFatalTimes(0),
	m_nSrcState(s0),
	m_iEvt(-1)
{
}

CScannerFSM::~CScannerFSM(void)
{
	ReleaseSuitableEntity();
}

ErrorCodeEnum CScannerFSM::OnInit()
{
	ErrorCodeEnum erroCode = Error_Succeed;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Version: %s, Complied at: %s %s", MODULE_VERION_FULL, __DATE__, __TIME__);
	return erroCode;
}

void CScannerFSM::AfterInit()
{

}

ErrorCodeEnum CScannerFSM::OnExit()
{
	return Error_Succeed;
}

void CScannerFSM::s0_on_entry()
{
	m_nFatalTimes = 0;
	m_ecSelfTest = Error_Succeed;
}

void CScannerFSM::s0_on_exit()
{
}

unsigned int CScannerFSM::s0_on_event(FSMEvent* e)
{
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_OPERATING:
		{
			OperatingEvent* pEvt = dynamic_cast<OperatingEvent*>(e);
			m_iEvt = pEvt->m_bindEvt;
			pEvt->SetHandled();
		}
		break;
	case USER_EVT_DEV_INVALID:
		{

		}
		e->SetHandled();
		break;
	case USER_EVT_STARTPREVIEW:
		{
			StartPreviewTask* pTask = new StartPreviewTask(this);
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		break;
	case USER_EVT_STOPPREVIEW:
		{
			StopPreviewTask* pTask = new StopPreviewTask(this);
			StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SCANIMAGE:
		{
			ScanImageTask* pTask = new ScanImageTask(this);
			ScanImageEvent* pEvt = dynamic_cast<ScanImageEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SETPROPERTY:
		{
			SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
			SetPropertyTask* pTask = new SetPropertyTask(this);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SHOWPROPERTY:
		{
			ShowPropertyEvent* pEvt = dynamic_cast<ShowPropertyEvent*>(e);
			ShowPropertyTask* pTask = new ShowPropertyTask(this);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			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);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unknown event id: %d", e->iEvt);
	}
	return uRet;
}

void CScannerFSM::s2_on_entry()
{

}

void CScannerFSM::s2_on_exit()
{
	m_iEvt = -1;
}

unsigned int CScannerFSM::s2_on_event(FSMEvent* e)
{
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_STARTPREVIEW_FINISHED:
		{
			if(m_iEvt == USER_EVT_STARTPREVIEW)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			if(m_iEvt == USER_EVT_STOPPREVIEW)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SCANIMAGEFINISHED:
		{
			if(m_iEvt == USER_EVT_SCANIMAGE)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SETPROPERTY_FINISHED:
		{
			if(m_iEvt == USER_EVT_SETPROPERTY)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SHOWPROPERTY_FINISHED:
		{
			if(m_iEvt == USER_EVT_SHOWPROPERTY)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SETWINPOS_FINISHED:
		{
			if(m_iEvt == USER_EVT_SETWINPOS)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_GETSTATUS_FINISHED:
		{
			if(m_iEvt == USER_EVT_GETSTATUS)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_GETINFO_FINISHED:
		{
			if(m_iEvt == USER_EVT_GETINFO)
			{
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unknown event id: %d", e->iEvt);
		break;
	}
	return uRet;
}

void CScannerFSM::s4_on_entry()
{
	ScheduleTimer(CHECKDEV_TIMER_ID, MILLISECOND_TO_CHECKDEV);
}

void CScannerFSM::s4_on_exit()
{
	CancelTimer(CHECKDEV_TIMER_ID);
}

unsigned int CScannerFSM::s4_on_event(FSMEvent* e)
{
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_DEV_RECOVER:
		{

		}
		e->SetHandled();
		break;
	case EVT_TIMER:
		{
			if(e->param1 == CHECKDEV_TIMER_ID)
			{
				e->SetHandled();
				if (ISSUCCEEDED(CheckHSPSConnectStatus()))
				{
					PostEventFIFO(new FSMEvent(USER_EVT_DEV_RECOVER));
					break;
				}
				ScheduleTimer(CHECKDEV_TIMER_ID, MILLISECOND_TO_CHECKDEV);
			}
		}
		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:
		{
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

int CScannerFSM::StartPreview(SpReqAnsContext<ScannerService_StartPreview_Req,
	ScannerService_StartPreview_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_StartPreview).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_StartPreview_Req req = {};
	HSPScannerService_StartPreview_Ans ans = {};

	req.rotateType = ctx->Req.rotateType;
	req.scanType = ctx->Req.scanType;
	req.colorType = ctx->Req.colorType;
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->StartPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW, dwUserCode);
	if (FAILURED(erroCode)) {
		nRes = 1;
		if (MapErrorCode2Level(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_StartPreview,
				CSimpleStringA::Format("StartPreview context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			erroCode = Error_DevNotAvailable;
		}
		else {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_StartPreview,
				CSimpleStringA::Format("StartPreview context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		}
	}
	else {
		ctx->Ans.retCode = ans.retCode;
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::StopPreview(SpReqAnsContext<ScannerService_CancelPreview_Req,
	ScannerService_CancelPreview_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		//Error_DevNotAvailable，识别该错误码，并提示客户，但不纳入万笔硬件故障统计 主 题：Re: 【阅知】万笔业务故障web端优化
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_CancelPreview).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}

	HSPScannerService_CancelPreview_Req req = {};
	HSPScannerService_CancelPreview_Ans ans = {};

	req.bOnlyHide = ctx->Req.reserved1 == 0 ? false : true;
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->CancelPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	ctx->Answer(erroCode, dwUserCode);

	if (FAILURED(erroCode)) {
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_CancelPreview,
			CSimpleStringA::Format("CancelPreview context failed: ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		nRes = 1;
	}
	return nRes;
}

int CScannerFSM::ScanImage(SpReqAnsContext<ScannerService_ScanImage_Req, 
	ScannerService_ScanImage_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_ScanImage).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	if(ctx->Req.nWay == 0)
	{
		HSPScannerService_ScanImage_Req req = {};
		HSPScannerService_ScanImage_Ans ans = {};
		erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->ScanImage(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE, dwUserCode);

		if (FAILURED(erroCode)) {
			if (MapErrorCode2Level(erroCode)) {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
					CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				erroCode = Error_DevNotAvailable;
			}
			else {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
					CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			}
			nRes = 1;
		}
		else {
			ctx->Ans.filePath = ans.filePath;
			ctx->Ans.imageData = ans.imageData;
		}
	}
	else if(ctx->Req.nWay == 1)
	{
		HSPScannerService_ScanImageEx_Req req = {};
		HSPScannerService_ScanImageEx_Ans ans = {};
		erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->ScanImageEx(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE, dwUserCode);
		if (FAILURED(erroCode)) {
			if (MapErrorCode2Level(erroCode)) {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
					CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				erroCode = Error_DevNotAvailable;
			}
			else {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
					CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			}
			nRes = 1;
		}
		else {
			ctx->Ans.filePath = ans.filePath;
			ctx->Ans.imageData = ans.imageData;
		}
	}
	else {
		erroCode = Error_Param;
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_ScanImage).setResultCode("RTA2O01")("Invalid Param: Way:%d", ctx->Req.nWay);
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::SetProperty(SpReqAnsContext<ScannerService_SetProperty_Req, 
	ScannerService_SetProperty_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_SetProperty).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_SetProperty_Req req = {};
	HSPScannerService_SetProperty_Ans ans = {};

	req.rotateType = ctx->Req.rotateType;
	req.scanType = ctx->Req.scanType;
	req.colorType = ctx->Req.colorType;
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->SetProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	if (FAILURED(erroCode)) {
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_SetProperty,
			CSimpleStringA::Format("SetProperty context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		nRes = 1;
	}
	else {
		ctx->Ans.retCode = ans.retCode;
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::ShowLTProperty(SpReqAnsContext<ScannerService_ShowProperty_Req, 
	ScannerService_ShowProperty_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	DWORD dwUserCode(0);

	int retCode = 0;
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_ShowProperty).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_ShowProperty_Req req = {};
	HSPScannerService_ShowProperty_Ans ans = {};
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->ShowProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	if (FAILURED(erroCode))
	{
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ShowProperty,
			CSimpleStringA::Format("ShowLTProperty context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		nRes = 1;
		if (erroCode == Error_TimeOut)
		{
			erroCode = Error_Succeed;
			nRes = 0;
		}
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::SetWinPos(SpReqAnsContext<ScannerService_SetWindowPos_Req, 
	ScannerService_SetWindowPos_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_SetWindowPos).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_SetWinPos_Req req = {};
	HSPScannerService_SetWinPos_Ans ans = {};

	req.type = ctx->Req.type;
	req.pointX = ctx->Req.pointX;
	req.pointY = ctx->Req.pointY;
	req.nWidth = ctx->Req.nWidth;

	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->SetWinPos(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);

	if (FAILURED(erroCode)) {
		if (MapErrorCode2Level(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_SetWinPos,
				CSimpleStringA::Format("SetWinPos context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			erroCode = Error_DevNotAvailable;
		}
		else {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_SetWinPos,
				CSimpleStringA::Format("SetWinPos context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		}
		nRes = 1;
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::GetDevStatus(SpReqAnsContext<ScannerService_GetDevStatus_Req, 
	ScannerService_GetDevStatus_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_GetDevStatus).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_GetDevStatus_Req req = {};
	HSPScannerService_GetDevStatus_Ans ans = {};
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	if (FAILURED(erroCode)) {
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_GetDevStatus,
			CSimpleStringA::Format("GetDevStatus context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("connected: %d, showing: %d, preview: %d.",
			ans.connected, ans.showing, ans.previewing);

		ctx->Ans.bInvalid = ans.connected == 0 ? false : true;
		ctx->Ans.bPreview = ans.previewing == 0 ? false : true;
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::GetDevInfo(SpReqAnsContext<ScannerService_GetDevInfo_Req, 
	ScannerService_GetDevInfo_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);

	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_GetDevInfo).setResultCode("RTA2O01")("entity HSPScanner is not available");
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	HSPScannerService_GetDevInfo_Req req = {};
	HSPScannerService_GetDevInfo_Ans ans = {};
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->GetDevInfo(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);

	if (FAILURED(erroCode)) {
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_GetDevInfo,
			CSimpleStringA::Format("GetDevInfo context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		nRes = 1;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("type: %s, model: %s, version: %s, state:%d.",
			(LPCTSTR)ans.type, (LPCTSTR)ans.model, (LPCTSTR)ans.version, ans.state);

		ctx->Ans.type = ans.type;
		ctx->Ans.model = ans.model;
		ctx->Ans.version = ans.version;
		ctx->Ans.state = ans.state;
	}

	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

ErrorCodeEnum CScannerFSM::OnDevExit()
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if(!IsSuitableEntityAvailable()) {
		return Error_DevNotAvailable;
	}
	HSPScannerService_Exit_Info info = {};
	erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->Exit();
	return erroCode;
}

void CScannerFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	pTransactionContext->SendAnswer(m_ecSelfTest);
}

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

ErrorCodeEnum CScannerFSM::ConnectToHSPScanner()
{
	if (!IsHSPSConnectSessionOK()) {

		FreeHSPScannerClient();

		m_pHSPSClient = new CHSPSInnerClient(GetEntityBase());
		ErrorCodeEnum erroCode = m_pHSPSClient->Connect();
		if (FAILURED(erroCode)) {
			m_pHSPSClient->SafeDelete();
			m_pHSPSClient = NULL;
			LogWarn(Severity_Middle, Error_InvalidState, LOG_WARN_MODULE_INVALID,
					CSimpleStringA::Format("Connect to HSPScanner entity failed: %s", SpStrError(erroCode)));
			GetHSPSInfo();
			return Error_InvalidState;
		}
	}

	return Error_Succeed;
}

ErrorCodeEnum CScannerFSM::GetHSPSInfo()
{
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo info = {0};
	ErrorCodeEnum ecInfo = pFunc->GetEntityRunInfo("HSPScanner", info);
	if (info.eState != EntityState_Idle) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("HSPScanner entity illegal state: %d", (int)info.eState);
	}
	return ecInfo;
}

ErrorCodeEnum CScannerFSM::CheckHSPSConnectStatus()
{
	CHSPSInnerClient* pCheckClient = new CHSPSInnerClient(GetEntityBase());
	ErrorCodeEnum erroCode = pCheckClient->Connect();
	if(FAILURED(erroCode))
	{
		pCheckClient->SafeDelete();
		pCheckClient = NULL;
		LogWarn(Severity_Low, Error_InvalidState, LOG_EVT_SCANNERSET_HSPSCNT_FAILED, 
			"HSPScanner entity is disconnectable.");
		GetHSPSInfo();
		return Error_InvalidState;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("HSPScanner entity is Connectable.");
	pCheckClient->GetFunction()->CloseSession();
	pCheckClient = NULL;
	return Error_Succeed;
}

bool CScannerFSM::IsHSPSConnectSessionOK()
{
	return (m_pHSPSClient != NULL && !m_pHSPSClient->QuerySessionClosed());
}