myvtm/Module/mod_HSPScanner/HSPScannerFSM.cpp

#include "stdafx.h"
#include "HSPScannerFSM.h"
#include "EventCode.h"
#include "GetDevInfoHelper.h"
#include "CommDevEntityErrorCode.h"
#include "fileutil.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 = 30 * 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_STOPPREVIEW)
		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_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_EXIT)
		T_STRINGY(USER_EVT_QUIT)
		T_STRINGY(USER_EVT_RESET)
		T_STRINGY(USER_EVT_EXIT_FINISHED)
		T_STRINGY(USER_EVT_SHOWPROPERTY)
		T_STRINGY(USER_EVT_SHOWPROPERTY_FINISHED)
		T_STRINGY(EVT_TIMER)
		T_STRINGY(USER_EVT_SETPROPERTYINVIEW_FINISHED)
		T_STRINGY(USER_EVT_NOCFG)
		T_STRINGY(USER_EVT_HIDEPREVIEW)
		T_STRINGY(USER_EVT_GOTOHELL)
	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


CHSPScannerFSM::CHSPScannerFSM(void)
	:
	m_version(0),
	m_batch(0),
	m_ecSelfTest(Error_Succeed),
	m_dwErroCode(0),
	m_bOperating(FALSE),
	m_nTickTimes(0),
	m_nFatalTimes(0),
	m_nSrcState(s0),
	m_eDevStatus(DEVICE_STATUS_NOT_READY),
	m_desiredAction(USER_EVT_QUIT),
	m_bOpened(false)
{
	HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x217);
}

CHSPScannerFSM::~CHSPScannerFSM(void)
{

}

ErrorCodeEnum CHSPScannerFSM::OnInit()
{
	LOG_FUNCTION();
	GET_DEV_ENTITY_BASE_POINTER()->InitializeVendorLogSwitch();
	ErrorCodeEnum erroCode = Error_Succeed;
	//Dbg("Source Code complied at: %s %s", __DATE__, __TIME__);

	CSimpleStringA csDllName(true);
    auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
    auto result = pEntity->ExtractVendorLibFullPath(csDllName);
	if (result == Error_NotConfig) {
        PostEventLIFO(new FSMEvent(USER_EVT_NOCFG));
        return Error_Succeed;
	}
	if(FAILURED(result)) {
		Dbg("Fetch Vendor dllName failed %s.", (LPCTSTR)csDllName);
		goto FAIL;
	}
	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, pEntity->vendorLibInfo.strVendor);
	Dbg("VendorDllName: %s.", (LPCTSTR)csDllName);
    result = m_hDevHelper.LoadUp(csDllName);
    if (result != Error_Succeed) {
#ifdef RVC_OS_WIN
        Dbg("%s - GLE=%u", (LPCTSTR)pEntity->GetVendorLibName(), GetLastError());
#endif
        goto FAIL;
    }

	result = m_hDevHelper->DevOpen();
    if (FAILURED(result)) {
		LOG_HSPSCANNER_ERROR_MSG_MACRO(result, DevOpen);
        goto FAIL;
    }
    m_bOpened = true;
	{
        m_nRecX = 1280;
        m_nRecY = 0;
        m_nRecW = 1920;
        ErrorCodeEnum ecInit = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
        ErrorCodeEnum ecInitScan = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL);
        ErrorCodeEnum ecInitRotate = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE);
        ErrorCodeEnum ecInitColor = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL);
        Dbg("ViewPos: %s, Scan: %s, rotate: %s, color: %s.", SpStrError(ecInit), SpStrError(ecInitScan), SpStrError(ecInitRotate), SpStrError(ecInitColor));
    }
	m_eDevStatus = DEVICE_STATUS_NORMAL;
	return result;

FAIL:

	PostEventLIFO(new FSMEvent(USER_EVT_GOTOHELL));
	return Error_Succeed;
}

ErrorCodeEnum CHSPScannerFSM::OnExit()
{
	LOG_FUNCTION();

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

void CHSPScannerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_bOperating = FALSE;
	m_nFatalTimes = 0;
	m_ecSelfTest = Error_Succeed;
}

void CHSPScannerFSM::s0_on_exit()
{
	m_bOperating = FALSE;
}

unsigned int CHSPScannerFSM::s0_on_event(FSMEvent* e)
{
	Dbg("s0_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	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)
			{
				Dbg("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;
		// 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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_NOCFG:
		{
			Dbg("HSPScaner is not cofig now.");
		}
		break;
	default:
		{
			Dbg("UnHandle event !");
		}
		break;
	}
	return uRet;
}

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

void CHSPScannerFSM::s1_on_exit()
{

}

unsigned int CHSPScannerFSM::s1_on_event(FSMEvent* e)
{
	Dbg("s1_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	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);
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			uRet = e->param1;
			if((uRet == 0 || uRet == 4) && ++m_nFatalTimes <= MAX_ERROR_TIMES)
			{
				Dbg("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));
			}
			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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

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

void CHSPScannerFSM::s2_on_exit()
{

}

unsigned int CHSPScannerFSM::s2_on_event(FSMEvent* e)
{
	Dbg("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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

void CHSPScannerFSM::s3_on_entry()
{
	LOG_FUNCTION();
	
	m_eDevStatus = DEVICE_STATUS_FAULT;

	m_nTickTimes = 0;
	m_bOperating = FALSE;

	int nStatus = IsDevConnected();

	if(nStatus == 0)
	{
		PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
	}
	else
	{
		// move here. --Josephus at 19:07:40 20161214
		m_ecSelfTest = Error_InvalidState;
		if(nStatus != -1) {
			ScheduleTimer(RESET_TIMER_ID, MILLISECOND_TO_RESET / 6);
		}
	}
}

void CHSPScannerFSM::s3_on_exit()
{
	m_eDevStatus = DEVICE_STATUS_NORMAL;
	m_bOperating = FALSE;
	m_ecSelfTest = Error_Succeed;
	m_nFatalTimes = 0;
	m_desiredAction = USER_EVT_QUIT;
	CancelTimer(RESET_TIMER_ID);
}

unsigned int CHSPScannerFSM::s3_on_event(FSMEvent* e)
{
	Dbg("s3_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	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();
		}
		break;
	case USER_EVT_STOPPREVIEW:
		{
			if(m_hDevHelper)
			{
				CancelTimer(RESET_TIMER_ID);
				StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
				HspsDevStatus status = {0};
				ErrorCodeEnum erroCode = m_hDevHelper->GetDevStatus(status);
				if(status.inPreview == 1)
				{
					StopPreviewTask* pTask = new StopPreviewTask(this);
					pTask->SetContext(pEvt->m_ctx);
					GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
				}
				else if(status.inShow == 1)
				{
					Dbg("Stay in show but not in preview status, thus try to hide it");
					erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);

					pEvt->m_ctx->Answer(erroCode);

					FSMEvent* timerEvent = new FSMEvent(EVT_TIMER);
					timerEvent->param1 = RESET_TIMER_ID;
					PostEventFIFO(timerEvent);
				}
			}
		}
		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:
		{
			ErrorCodeEnum erroCode = m_hDevHelper->Reset();
			Dbg("Reset operation returned %s.", SpStrError(erroCode));
			if(FAILURED(erroCode))
			{
				LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, Reset);
				uRet = 1;
			}
			else
			{
				ErrorCodeEnum eXYW = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
				if(FAILURED(eXYW))
				{
					LOG_HSPSCANNER_ERROR_MSG_MACRO(eXYW, SetViewPos);
					//LogErrMsg("s3_on_event::SetViewPos", erroCode, MEC_DEVAPI_HSPSCANNER_SetViewPos, TRUE);
					uRet = 1;
					e->SetHandled();
					break;
				}
				HspsDevStatus status = {0};
				CSimpleStringA strFuncName(true);
				erroCode = m_hDevHelper->GetDevStatus(status);
				if(status.inPreview == 1 && status.inShow == 1)
				{
					if(m_desiredAction == USER_EVT_STOPPREVIEW)
					{
						erroCode = m_hDevHelper->SetPreview(0);
						strFuncName = "SetPreview";
						UpdateDEC(MEC_DEVAPI_HSPSCANNER_SetPreview_Close);
						{
							HspsDevStatus retryStatus = {0};
							m_hDevHelper->GetDevStatus(retryStatus);
							if(retryStatus.inPreview == 1) 
							{
								Dbg("Still preview ?");
								erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
								UpdateDEC(MEC_DEVAPI_HSPSCANNER_SetParam);
								strFuncName = "SetParam";
							}
						}
					}
					else if(m_desiredAction == USER_EVT_HIDEPREVIEW)
					{
						erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
						UpdateDEC(MEC_DEVAPI_HSPSCANNER_SetParam);
						strFuncName = "SetParam";
					}
					if(FAILURED(erroCode))
					{
						Dbg("Recover failed under desiration of %s", EvtTypeToString(m_desiredAction));
						//GetAndDbgDevError();
						LogErrMsg(strFuncName, erroCode, 0, TRUE);
						uRet = 1;
						e->SetHandled();
						break;
					}
					uRet = 2;
				}
			}
		}
		e->SetHandled();
		break;
	case EVT_TIMER:
		{
			if(e->param1 == RESET_TIMER_ID)
			{
				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:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

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

void CHSPScannerFSM::s4_on_exit()
{

}

unsigned int CHSPScannerFSM::s4_on_event(FSMEvent* e)
{
	Dbg("s4_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_SCANIMAGEFINISHED:
		{
			uRet = e->param1;
			if(uRet == 2 && ++m_nFatalTimes < MAX_ERROR_TIMES)
			{
				Dbg("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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

void CHSPScannerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	m_eDevStatus = DEVICE_STATUS_MAINTAINCE;
	LogEvent(Severity_Middle,LOG_EVT_HSPS_LOST_CONNECT,"高拍仪断开连接！");
	ScheduleTimer(CHECK_CONNECT_TIMER_ID, MILLISECOND_TO_CHECK_CONNECT);
}

void CHSPScannerFSM::s5_on_exit()
{
	m_eDevStatus = DEVICE_STATUS_NORMAL;
	CancelTimer(CHECK_CONNECT_TIMER_ID);
}

unsigned int CHSPScannerFSM::s5_on_event(FSMEvent* e)
{
	Dbg("s5_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case EVT_TIMER:
		{
			if(e->param1 == CHECK_CONNECT_TIMER_ID)
			{
				HspsDevStatus status = {0};
				ErrorCodeEnum eResult = m_hDevHelper->GetDevStatus(status);
				if(ISSUCCEEDED(eResult))
				{
					if(status.isConnected == 0)
					{
						ScheduleTimer(CHECK_CONNECT_TIMER_ID, MILLISECOND_TO_CHECK_CONNECT);
					}
					else if(status.inShow == 1 && status.inPreview == 1)
					{
						//回到预览状态
						uRet = 2;
					}
					else
					{
						uRet = 1;
					}
				}
				Dbg("eResult(%d), connected(%d), preview(%d).", 
					eResult, status.isConnected, status.inPreview);
				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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

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

void CHSPScannerFSM::s6_on_exit()
{

}

unsigned int CHSPScannerFSM::s6_on_event(FSMEvent* e)
{
	Dbg("s6_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	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)
			{
				Dbg("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状态仅能进行彻底取消预览的操作
				StopPreviewTask* pTask = new StopPreviewTask(this);
				pTask->SetContext(pEvt->m_ctx);
				GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			uRet = e->param1;
			if(uRet == 0 && ++m_nFatalTimes < MAX_ERROR_TIMES)
			{
				Dbg("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));
			}
		}
		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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

void CHSPScannerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	FSMEvent* pEvt = new FSMEvent(USER_EVT_EXIT_FINISHED);

	if(ISSUCCEEDED(OnDevExit()))
	{
		pEvt->param1 = 0;
	}
	else 
	{
		pEvt->param1 = 1;
	}
	PostEventFIFO(pEvt);
}

void CHSPScannerFSM::s7_on_exit()
{
	if(m_hDevHelper)
	{
		HspsDevStatus status = {0};
		ErrorCodeEnum erroCode = m_hDevHelper->GetDevStatus(status);
		Dbg("Get status(%d): Connected(%d), Preview(%d), Show(%d).",
			erroCode, status.isConnected, status.inPreview, status.inShow);
	}
}

unsigned int CHSPScannerFSM::s7_on_event(FSMEvent* e)
{
	Dbg("s7_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)
			{
				m_desiredAction = USER_EVT_EXIT;
			}
		}
		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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

unsigned int CHSPScannerFSM::s8_on_event(FSMEvent* e)
{
	Dbg("s8_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	if(e->iEvt == USER_EVT_GETINFO) {
		GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
		Dbg("Josephus@note: no furnish status");
		pEvt->m_ctx->Ans.model = "";
		pEvt->m_ctx->Ans.state = DEVICE_STATUS_NOCFG;
		pEvt->m_ctx->Ans.type = "";
		pEvt->m_ctx->Ans.version = "";
		pEvt->m_ctx->Answer(Error_Succeed);
		e->SetHandled();
	}
	return uRet;
}

int CHSPScannerFSM::StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
	HSPScannerService_StartPreview_Ans>::Pointer ctx)
{
	bool nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	
	if(ctx->Req.colorType || ctx->Req.scanType || ctx->Req.rotateType)
	{
		erroCode = SetPreview(ctx);
		Dbg("SetPreview in StartPreview returned: %d, testCode: %d.", erroCode, ctx->Ans.reserved1);
	}

	HspsDevStatus status = {0};
	erroCode = m_hDevHelper->GetDevStatus(status);
	if(ISSUCCEEDED(erroCode) && status.inPreview)
	{// 用于s6状态 [Josephus in 9:33:48 2016/11/22]
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_SHOW);
		Dbg("SetPreview changeTo SetVisible and returned %s.", SpStrError(erroCode));
	}
	else if(ISSUCCEEDED(erroCode))
	{
		Dbg("Start to SetPreview(1).");
		erroCode = m_hDevHelper->SetPreview(1);
		Dbg("End to SetPreview(1) returned %s.", SpStrError(erroCode));
		if(FAILURED(erroCode)) {
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetPreview_Open);
		}
	}
	else
	{
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, GetDevStatus);
	}

	if(FAILURED(erroCode))
	{
		nRes = 1;
	}
	else
	{
		LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_ON, "HSPScanner warning on.");
	}
	ctx->Answer(erroCode);
	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)
	{
		Dbg("Start to SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE).");
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
		Dbg("End to SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE) returned %s.", SpStrError(erroCode));
		if(ISSUCCEEDED(erroCode))
		{
			nRes = 1;
		}
		else 
		{
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetParam);
			nRes = 4;
		}
	}
	else
	{
		Dbg("Start to SetPreview(0).");
		erroCode = m_hDevHelper->SetPreview(0);
		Dbg("End to SetPreview(0) reuturned %s.", SpStrError(erroCode));
		if(ISSUCCEEDED(erroCode))
		{
			nRes = 2;
		} else {
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetPreview_Close);
		}
	}
	if(ISSUCCEEDED(erroCode))
	{
		LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_OFF, "HSPScanner warning off.");
	}
	ctx->Answer(erroCode);
	return nRes;
}

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);
	Dbg("aimImageFileName: %s, bRet: %d.", (LPCTSTR)csImageFile, bRet);
	if(!bRet)
	{
		ctx->Answer(Error_Resource);
		//Todo: SetCustLastErrorCode();
		Dbg("Create imgPath failed.");
		return 1;
	}
	
	erroCode = m_hDevHelper->ScanImage((LPCTSTR)csImageFile);
	if(ISSUCCEEDED(erroCode))
	{
		Dbg("ScanImage suc.");
		//TODO:
		ctx->Ans.filePath = csImageFile;
		CBlob& cbData = ctx->Ans.imageData;
		FILE* fHandle = fopen(csImageFile.GetData(), "rb");
		if(fHandle) {
			fseek(fHandle, 0, SEEK_END);
			long fileSize = ftell(fHandle);
			if(fileSize <= 0) {
				LOG_TRACE("filesize(%s) error: %ld.", (LPCTSTR)csImageFile, fileSize);
				erroCode = Error_NotExist;
				fclose(fHandle);
				nRes = 4;
			}
			else
			{
				cbData.Alloc(fileSize);
				fseek(fHandle, 0, SEEK_SET);
				fread(cbData.m_pData, 1, fileSize, fHandle);
				fclose(fHandle);
			}
		}
		else
		{
			erroCode = Error_Resource;
			LogError(Severity_High, Error_Resource, LOG_EVT_HSPS_READ_IMAGE_FILE_FAILED, 
					 CSimpleStringA::Format("fopen(%s) failed: %d, %s", (LPCTSTR)csImageFile, errno, strerror(errno))
				);
			//GetAndDbgDevError();
			nRes = 4;
		}
		if(ISSUCCEEDED(erroCode))
		{
			// Additional ChangeTo Hide --Josephus at 11:32:29 2016/11/22
			if(true/*TODO: */)
			{
				ErrorCodeEnum eHide = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
				Dbg("SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE) returned %s", SpStrError(eHide));
				if(ISSUCCEEDED(eHide))
				{
					nRes = 6;
				}
			}
		}
		ctx->Answer(erroCode);
	}
	else
	{
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, ScanImage);
		ctx->Answer(erroCode);
		//Todo: SetCustLastErrorCode();
		return 2;
	}
	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);
	Dbg("aimImageFileName: %s, bRet: %d.", (LPCTSTR)csImageFile, bRet);
	if(!bRet)
	{
		ctx->Answer(Error_Resource);
		//Todo: SetCustLastErrorCode();
		Dbg("Create imgPath failed.");
		return 1;
	}

#if 0
	int len = MAX_IMAGEDATA_BUFSIZE;
	BYTE* pBtImage = new BYTE[len+1];
	if(pBtImage == NULL)
	{
		Dbg("new buffer[%d] failed %d.", len+1, GetLastError());
		ctx->Answer(Error_Resource);
		return 3;
	}
	memset((void*)pBtImage, 0, len+1);
#else
	int len = 0;
	BYTE* pBtImage = NULL;
#endif
	int nOldLen = len;
	erroCode = m_hDevHelper->ScanImageEx(pBtImage, len, (LPCTSTR)csImageFile);
	if(erroCode == Error_TooSmallBuffer)
	{
		Dbg("ScanImageEx buffer is too small.[%d][%d]", nOldLen, len);
		if(pBtImage)
		{
			delete pBtImage;
			pBtImage = NULL;
		}

		len += MAX_IMAGEDATA_SUFFIX;
		pBtImage = new BYTE[len+1];
		if(pBtImage == NULL)
		{
			Dbg("new buffer[%d] failed %d.", len+1, GetLastError());
			ctx->Answer(Error_Resource);
			return 3;
		}
		memset((void*)pBtImage, 0, len+1);
		erroCode = m_hDevHelper->ScanImageEx(pBtImage, len, (LPCTSTR)csImageFile);
	}

	if(ISSUCCEEDED(erroCode))
	{
		Dbg("ScanImageEx suc %d, %d.", len, strlen((const char*)pBtImage));
		//TODO:
		ctx->Ans.filePath = csImageFile;
		CBlob& cbData = ctx->Ans.imageData;
		
		Dbg("Start to Read.");
		
#if 1
		cbData.Alloc((len+1)*sizeof(BYTE));
		memcpy_s(cbData.m_pData, cbData.m_iLength, pBtImage, len);
		cbData.Resize(len);
#else 
		FILE* fHandle = fopen(csImageFile, "rb");
		if(fHandle)
		{
			fseek(fHandle, 0, SEEK_END);
			long fileSize = ftell(fHandle);
			cbData.Alloc(fileSize);
			fseek(fHandle, 0, SEEK_SET);
			fread(cbData.m_pData, 1, fileSize, fHandle);
			fclose(fHandle);
		}
		else
		{
			LOG_TRACE("fopen(%s) failed.", (LPCTSTR)csImageFile);
			erroCode = Error_IO;
			GetAndDbgDevError();
			nRes = 4;
		}
#endif

		//SpBuffer buffer;
		//buffer.OpenRead((const char*)pBtImage, len);
		//cbData = buffer.ToBlob();

		//buffer.OpenWrite(len+1);
		//buffer.SetCapacity(len+1);
		//buffer & pBtImage;
		


		//Or deal with in below way?		

		Dbg("ScanImageEx ctx: %s, %d.", (LPCTSTR)ctx->Ans.filePath, ctx->Ans.imageData.m_iLength);
		Dbg("End to read.");

		// Additional ChangeTo Hide --Josephus at 11:29:03 2016/11/22
		if(ISSUCCEEDED(erroCode))
		{
			ErrorCodeEnum eHide = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE);
			Dbg("SetParam(HSPS_MODEL_VIEW, HSPS_VIEW_HIDE) returned %s", SpStrError(eHide));
			if(ISSUCCEEDED(eHide))
			{
				nRes = 6;
			}
		}
		ctx->Answer(erroCode);
	}
	else
	{
		Dbg("ScanImageEx failed returned %s, %d, %d.", SpStrError(erroCode), len, strlen((const char*)pBtImage));
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, ScanImageEx);
		ctx->Answer(erroCode);
		nRes = 2;
	}

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

int CHSPScannerFSM::ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
	HSPScannerService_ShowProperty_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	// Return ahead. [Josephus in 15:24:15 2016/11/21]
	Dbg("Drop the preview dialog from vice minitor to main minitor.");
	ErrorCodeEnum ePos = m_hDevHelper->SetViewPos(730, 100, 540);
	Dbg("Show Property returned context ahead closing. %d", ePos);
	ctx->Answer(erroCode);
	
	Dbg("Start to show Property dialog...");
	erroCode = m_hDevHelper->SetProperty();
	Dbg("End to show Property dialog!");
	if(ISSUCCEEDED(ePos))
	{
		erroCode = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
		Dbg("Recover context position. %d", ePos);
	}
	return 0;
}

int CHSPScannerFSM::SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req, 
	HSPScannerService_SetProperty_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	int retCode = 0;
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.colorType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL);
		Dbg("SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.colorType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_GREY);
		Dbg("SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_GREY) returned %s", SpStrError(erroCode));
	}
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0001;
		LogErrMsg("SetProperty::SetParam", erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, TRUE);
		erroCode = Error_Succeed;
	}
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.rotateType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_LEFT);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_LEFT) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 3)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_MIRROR);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_MIRROR) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 4)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_RIGHT);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_RIGHT) returned %s", SpStrError(erroCode));
	}
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0002;
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetParam);
		erroCode = Error_Succeed;
	}
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.scanType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.scanType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_A4);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_A4) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.scanType == 3)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_IDCARD);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_IDCARD) returned %s", SpStrError(erroCode));
	}
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0004;
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetParam);
		erroCode = Error_Succeed;
	}

	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:
		{
			Dbg("invalid param for SetWinPos operation type(%d).", ctx->Req.type);
			ctx->Answer(Error_Param);
			return nRes = 3;
		}
		break;
	}
	Dbg("SetWinPos: %s(%d).", ParamValToString(value), value);

	if(bSetCustom)
	{
		Dbg("Start to SetViewPos x(%d), y(%d), w(%d), reserved(%d).", 
			ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth, ctx->Req.reserved4);
		erroCode = m_hDevHelper->SetViewPos(ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth);
		if(FAILURED(erroCode))
		{
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetViewPos);
			nRes = 2;
		}
		else
		{
			m_nRecX = ctx->Req.pointX;
			m_nRecY = ctx->Req.pointY;
			m_nRecW = ctx->Req.nWidth;
		}
	}
	else
	{
		Dbg("Start to SetViewParam with param %d.", value);
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, value);
		Dbg("End to SetViewParam returned 0x%x.", erroCode);
		if(FAILURED(erroCode))
		{
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetParam);
			nRes = 1;
		}
	}
	ctx->Answer(erroCode);
	return nRes;
}

int CHSPScannerFSM::GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req, 
	HSPScannerService_GetDevStatus_Ans>::Pointer ctx)
{
	int nRes = 0;
	HspsDevStatus status = {0};
	ErrorCodeEnum erroCode = m_hDevHelper->GetDevStatus(status);
	if(ISSUCCEEDED(erroCode))
	{
		Dbg("GetDevStatus suc.");
		ctx->Ans.connected = status.isConnected;
		ctx->Ans.previewing = status.inPreview;
		ctx->Ans.showing = status.inShow;
	}
	else
	{
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, GetDevStatus);
		nRes = 1;
	}
	ctx->Answer(erroCode);
	return nRes;
}

int CHSPScannerFSM::GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req, 
	HSPScannerService_GetDevInfo_Ans>::Pointer ctx)
{
	int nRes = 0;
	DevCategoryInfo info = {0};
	ErrorCodeEnum erroCode = m_hDevHelper->GetDevCategory(info);
	if(ISSUCCEEDED(erroCode))
	{
		Dbg("GetDevCategory suc.");
		ctx->Ans.model = info.szModel;
		ctx->Ans.state = (int)info.eState;
		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);
	}
	else
	{
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, GetDevCategory);
		nRes = 1;
	}
	{
		Dbg("Reset Ctx::state from %d to %d", ctx->Ans.state, m_eDevStatus);
		ctx->Ans.state = (int)m_eDevStatus;
	}
	ctx->Answer(erroCode);
	return nRes;
}

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

BOOL CHSPScannerFSM::DelAndGetNewFileName(CSimpleStringA& csfileName)
{
	LOG_FUNCTION();
	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)
	{
		Dbg("Invalid or empty fileName(%s)", fileName);
		return FALSE;
	}
	CSimpleStringA strPath, strAimPath;
	ErrorCodeEnum erroCode = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	strAimPath = strPath + SPLIT_SLASH_STR + fileName;

	// Add [Josephus in 17:04:27 2016/10/25]
	csfileName = strAimPath;
	if (ExistsFileA(csfileName)) {
        if (RemoveFileA((LPCTSTR)strAimPath) != 0) {
            Dbg("DeleteFile(%s) suc.", (LPCTSTR)strAimPath);
            return TRUE;
        } else {
            LogError(Severity_High, Error_Unexpect, UpdateDEC(MEC_CLEAR_RESOURCE_FAILED), CSimpleStringA::Format(
                "DeleteFile(%s) failed LastError(%d).", (LPCTSTR)strAimPath, GetLastError()));
            return FALSE;
        }
	} else {
		return TRUE;
	}
	Dbg("DeleteFile(%s) Unexpect GetLastError(%d).", (LPCTSTR)strAimPath, GetLastError());
	return FALSE;
}

ErrorCodeEnum CHSPScannerFSM::OnDevExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed;
	if(m_hDevHelper)
	{
		HspsDevStatus status = {0};
		erroCode = m_hDevHelper->GetDevStatus(status);
		if(ISSUCCEEDED(erroCode) && status.isConnected)
		{
			if(status.inPreview)
			{
				Dbg("Invoke cancelPreview...");
				erroCode = m_hDevHelper->SetPreview(0);
				Dbg("Close Preview OnDevExit returned %s", SpStrError(erroCode));
				if(ISSUCCEEDED(erroCode)) {
					LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_OFF, "HSPScanner warning off.");
				} else {
					LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetPreview_Close);
				}
			}
		} else if (!FAILURED(erroCode)) {
			LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, GetDevStatus);
		} else {
			Dbg("HSPSCanner device is disconnected!");
		}
	}
	return erroCode;
}

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

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

ErrorCodeEnum CHSPScannerFSM::SetPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
	HSPScannerService_StartPreview_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	int retCode = 0;
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.colorType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL);
		Dbg("SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.colorType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_GREY);
		Dbg("SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_GREY) returned %s", SpStrError(erroCode));
	}
	else 
	{
		Dbg("To do nothing with colortype: %d", ctx->Req.colorType);
	}
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0001;
		LogErrMsg("SetPreview::SetParam", erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, TRUE);
		erroCode = Error_Succeed;
	}
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.rotateType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_LEFT);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_LEFT) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 3)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_MIRROR);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_MIRROR) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.rotateType == 4)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_RIGHT);
		Dbg("SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_RIGHT) returned %s", SpStrError(erroCode));
	}
    else {
        Dbg("To do nothing with rotateType: %d", ctx->Req.rotateType);
    }
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0002;
		LogErrMsg("SetPreview::SetParam", erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, TRUE);
		erroCode = Error_Succeed;
	}
	//////////////////////////////////////////////////////////////////////////
	if(ctx->Req.scanType == 1)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.scanType == 2)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_A4);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_A4) returned %s", SpStrError(erroCode));
	}
	else if(ctx->Req.scanType == 3)
	{
		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_IDCARD);
		Dbg("SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_IDCARD) returned %s", SpStrError(erroCode));
	}
    else {
        Dbg("To do nothing with scanType: %d", ctx->Req.scanType);
    }
	if(FAILURED(erroCode)) 
	{
		retCode |= 0x0004;
		LOG_HSPSCANNER_ERROR_MSG_MACRO(erroCode, SetParam);
		//LogErrMsg("SetPreview::SetParam", erroCode, MEC_DEVAPI_HSPSCANNER_SetParam, TRUE);
		erroCode = Error_Succeed;
	}

	ctx->Ans.retCode = retCode;
	ctx->Ans.reserved1 = 404040404;
	Dbg("retCode: %d, testCode: %d.", ctx->Ans.retCode, ctx->Ans.reserved1);
	
	if(retCode == 0)
	{
		return Error_Succeed;
	}
	return Error_DevCommFailed;
}

ErrorCodeEnum CHSPScannerFSM::DeleteFileIfExisted(LPCTSTR fileName)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	if (ExistsFileA(fileName)) {
        if (RemoveFileA(fileName) != 0) {
            Dbg("DeleteFile(%s) suc.", fileName);
            return Error_Succeed;
        } else {
            LogError(Severity_High, Error_Unexpect, UpdateDEC(MEC_CLEAR_RESOURCE_FAILED), CSimpleStringA::Format(
                "DeleteFile(%s) failed LastError(%d).", fileName, GetLastError()));
            return Error_Unexpect;
        }
	} else {
		return Error_Succeed;
	}
	Dbg("DeleteFile(%s) Unexpect GetLastError(%d).", fileName, GetLastError());
	return Error_Unexpect;
}