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 "path.h"
#include "CommEntityUtil.hpp"

#if defined(RVC_OS_WIN)
#include "SetupApi.h"
#include <process.h>
#endif //RVC_OS_WIN

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

const int MAX_PATH_SIZE = 256;
const int MAX_ERROR_TIMES = 2;


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

using namespace HeartBeat;

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

CScannerFSM::CScannerFSM(void)
	:
	m_csMachineType(true),
	m_csSite(true),
	m_bPadMachine(false),
	m_bStand2SMachine(false),
	m_bDesk2SMachine(false),
	m_bJBMachine(false),
	m_bDesk1SMachine(false),
	m_bUsePortableScanner(false),
	m_pHSPSClient(NULL),
	m_pPortableClient(NULL),
	m_ecSelfTest(Error_Succeed),
	m_dwErroCode(0),
	m_nFatalTimes(0),
	m_nSrcState(s0),
	m_iEvt(-1)
{
	ListEntry_InitHead(&ContextListHead);
#if defined(RVC_OS_WIN)
    m_hrCoInited = CoInitializeEx(NULL, COINIT_MULTITHREADED);
#endif //RVC_OS_WIN
}

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

#if defined(RVC_OS_WIN)
    DestoryCamereBuckets(m_cameralist);
    if (m_hrCoInited == S_OK) {
        CoUninitialize();
    }
#endif //RVC_OS_WIN

	if(m_bJBMachine) {
		DestoryMethodQueue();
	}
}

ErrorCodeEnum CScannerFSM::OnInit()
{
	LOG_FUNCTION();
	ErrorCodeEnum erroCode = Error_Succeed;
	Dbg("Complied at: %s %s", __DATE__, __TIME__); 
	CSmartPointer<IConfigInfo> spConfig;
	CSystemStaticInfo sysInfo;
	erroCode = GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	if (FAILURED(erroCode))
	{
		Dbg("Get System Static info failed: %s.", SpStrError(erroCode));
		return Error_Unexpect;
	}
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_strTerminalNo = sysInfo.strTerminalID;
	Dbg("MachineType:%s, Site:%s, TerminalID:%s.", (LPCTSTR)m_csMachineType, (LPCTSTR)m_csSite, (LPCTSTR)m_strTerminalNo);
	m_bPadMachine = !m_csMachineType.Compare("RVC.Pad", true);
	if(!m_bPadMachine) {
		m_bDesk2SMachine = !m_csMachineType.Compare("RVC.Desk2S", true);
	}
	m_bStand2SMachine = !m_csMachineType.Compare("RVC.Stand2S", true);
	m_bJBMachine = !m_csMachineType.Compare("RVC.IL", true);
	m_bDesk1SMachine = !m_csMachineType.Compare("RVC.Desk1S", true);
#if defined(RVC_OS_WIN)
    if (m_bPadMachine || m_bDesk2SMachine || m_bDesk1SMachine) {
        m_bUsePortableScanner = true;
        LoadConfigAboutCamera();
        GetCameraInfors(m_cameralist);

        HANDLE hEvtThread = (HANDLE)_beginthreadex(NULL, 0, EventRevThread, this, 0, NULL);
        if (hEvtThread == NULL || hEvtThread == INVALID_HANDLE_VALUE) {
            Dbg("Create EventRevThread failed");
        } else {
            Sleep(100);
            LOG_ASSERT(gEventRevWnd != NULL);
        }
    }
#endif //RVC_OS_WIN
	if(m_bJBMachine) {
		InitializeMehodQueue();
	}
	return erroCode;
}

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

void CScannerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_nFatalTimes = 0;
	if(m_bStand2SMachine) //Stand2S
	{
		ErrorCodeEnum erroCode = CheckHSPSConnectStatus();
		if(FAILED(erroCode)) {
			PostEventFIFO(new FSMEvent(USER_EVT_DEV_INVALID));
		}
	}
	else if(m_bUsePortableScanner)
	{
		ErrorCodeEnum erroCode = CheckPortableConnectStatus();
		if(FAILED(erroCode)) {
			PostEventFIFO(new FSMEvent(USER_EVT_DEV_INVALID));
		}
	}
	else if(m_bJBMachine) {
		ErrorCodeEnum errorCode = CheckHeartbeatConnectStatus();
	}
	else {
		PostEventFIFO(new FSMEvent(USER_EVT_DEV_INVALID));
	}
	m_ecSelfTest = Error_Succeed;
}

void CScannerFSM::s0_on_exit()
{
}

unsigned int CScannerFSM::s0_on_event(FSMEvent* e)
{
	Dbg("%s: %s(%d), %d.", __FUNCTION__,  EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->PostEntityTaskFIFO(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()->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);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(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()->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);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_CROSS_CALL:
		{
			CrossTermCallTask* pTask = new CrossTermCallTask(this);
			CrossTermCallEvent* pEvt = dynamic_cast<CrossTermCallEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_CROSS_CALL_ONEWAY:
		{
			CrossTermInvokeTask* pTask = new CrossTermInvokeTask(this);
			CrossTermInvokeEvent* pEvt = dynamic_cast<CrossTermInvokeEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostEntityTaskFIFO(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}


void CScannerFSM::s1_on_entry()
{
	LOG_FUNCTION();
	FSMEvent* evt = new FSMEvent(USER_EVT_ESTIMATE_FINISHED);
	evt->param1 = evt->param2 = 0;
    int flag = 0;
#if defined(RVC_OS_WIN)
	CAutoArray<ScannerDeviceInfo> cameralist;
	bool bInnerUpdated = true;
	int devCount = GetCurrentCameraList(cameralist, bInnerUpdated);
	LOG_ASSERT(!bInnerUpdated || devCount == m_cameralist.size());
	if(devCount > 0) {
		for(int i=0; i<devCount; ++i) {
			//识别到高拍仪摄像头
			if(cameralist[i].devType == CAMTYPE_HSPS) {
				evt->param1 = CAMTYPE_HSPS;
				if(cameralist[i].bIdle) {
					//没有被占用呢，赶紧通知外接高拍仪实体将其占用了。
				}else {
					//确认是否被外接高拍仪实体占用，不是的话得告警查出是谁占用了。
					evt->param2 = 1;
					bool bHode = false;
					int devID = -1;
					bool bBusy = false;
					CSimpleStringA devName(true);
					if(ISSUCCEEDED(IsPortScanHoldDevice(bHode, devID, devName, bBusy))) {

					}
				}
			}
		}
	}
#endif //RVC_OS_WIN
	evt->param1 = flag;
	PostEventFIFO(evt);
	m_nFatalTimes = 0;
}

void CScannerFSM::s1_on_exit()
{

}

unsigned int CScannerFSM::s1_on_event(FSMEvent* e)
{
	unsigned int uRet = 0;
	if(e->iEvt == USER_EVT_ESTIMATE_FINISHED) {
		e->SetHandled();
		if(e->param1 == CAMTYPE_HSPS) {
			if(e->param2 == 0) {
				//TODO: 
			}
		}
	}
	return uRet;
}

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

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

unsigned int CScannerFSM::s2_on_event(FSMEvent* e)
{
	Dbg("%s: %s(%d), %s(%d), %d.", __FUNCTION__,
		EvtTypeToString(m_iEvt), m_iEvt, EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	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;
	}
	return uRet;
}


#pragma region Useless for current
//2016-11-18

void CScannerFSM::s3_on_entry()
{
	LOG_FUNCTION();
	m_ecSelfTest = Error_Hardware;
}

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

unsigned int CScannerFSM::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_RESET:
	//	{
	//		//TODO:......
	//	}
	//	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;
}


#pragma endregion Useless for current

void CScannerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	if(m_bStand2SMachine || m_bUsePortableScanner)
	{
		ScheduleTimer(CHECKDEV_TIMER_ID, MILLISECOND_TO_CHECKDEV);
	}
	else
	{
		Dbg("MachineType: %s, do nothing in this entity.", (LPCTSTR)m_csMachineType);
	}
}

void CScannerFSM::s4_on_exit()
{
	if(m_bStand2SMachine || m_bUsePortableScanner)
	{
		CancelTimer(CHECKDEV_TIMER_ID);
	}
}

unsigned int CScannerFSM::s4_on_event(FSMEvent* e)
{
	Dbg("%s: %s(%d), %d.", __FUNCTION__, EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	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(!m_bUsePortableScanner) {
					if(ISSUCCEEDED(CheckHSPSConnectStatus()))
					{
						PostEventFIFO(new FSMEvent(USER_EVT_DEV_RECOVER));
						break;
					}
				} else {
					if(ISSUCCEEDED(CheckPortableConnectStatus()))
					{
						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()->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;
}

int CScannerFSM::StartPreview(SpReqAnsContext<ScannerService_StartPreview_Req,
	ScannerService_StartPreview_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_StartPreview,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {
		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->StartPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW);
		if(FAILURED(erroCode)) {
			Dbg("StartPreview context failed 0x%x(%d).", erroCode, erroCode);
			nRes = 1;
		}
		else {
			ctx->Ans.retCode = ans.retCode;
			Dbg("StartPreview context suc, retCode: ans(%d), ctx(%d).", ans.retCode, ctx->Ans.retCode);
		}
	} 
	else if(m_bUsePortableScanner) {
		PortableScannerService_StartPreview_Req req = {};
		PortableScannerService_StartPreview_Ans ans = {};

		req.rotateType = ctx->Req.rotateType;
		req.scanType = ctx->Req.scanType;
		req.colorType = ctx->Req.colorType;

		erroCode = m_pPortableClient->StartPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW);
		if(FAILURED(erroCode)) {
			Dbg("StartPreview context failed 0x%x(%d).", erroCode, erroCode); nRes = 1;
		}
		else {
			ctx->Ans.retCode = ans.retCode;
			Dbg("StartPreview context suc, retCode: ans(%d), ctx(%d).", ans.retCode, ctx->Ans.retCode);
		}
	}
	ctx->Answer(erroCode);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::StopPreview(SpReqAnsContext<ScannerService_CancelPreview_Req,
	ScannerService_CancelPreview_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_CancelPreview,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {

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

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

		if(FAILURED(erroCode)) {
			Dbg("CancelPreview context failed 0x%x(%d).", erroCode, erroCode);
			nRes = 1;
		}else {
			Dbg("CancelPreview context suc.");
		}
	}else if(m_bUsePortableScanner) {

		PortableScannerService_CancelPreview_Req req = {};
		PortableScannerService_CancelPreview_Ans ans = {};

		req.bOnlyHide = ctx->Req.reserved1 == 0 ? false : true;
		erroCode = m_pPortableClient->CancelPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		ctx->Answer(erroCode);

		if(FAILURED(erroCode)) {
			Dbg("CancelPreview context failed 0x%x(%d).", erroCode, erroCode);
			nRes = 1;
		}else {
			Dbg("CancelPreview context suc.");
		}
	}
	
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::ScanImage(SpReqAnsContext<ScannerService_ScanImage_Req, 
	ScannerService_ScanImage_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_ScanImage,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(ctx->Req.nWay == 0)
	{
		if(m_bStand2SMachine) {
			HSPScannerService_ScanImage_Req req = {};
			HSPScannerService_ScanImage_Ans ans = {};

			erroCode = m_pHSPSClient->ScanImage(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE);

			if(FAILURED(erroCode)) {
				Dbg("ScanImage context failed 0x%x(%d).", erroCode, erroCode);
				nRes = 1;
			} else {
				Dbg("ScanImage context suc.");
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}else if(m_bUsePortableScanner) {
			PortableScannerService_ScanImage_Req req = {};
			PortableScannerService_ScanImage_Ans ans = {};

			erroCode = m_pPortableClient->ScanImage(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE);

			if(FAILURED(erroCode)) {
				Dbg("ScanImage context failed %s.",  SpStrError(erroCode));
				nRes = 1;
			} else {
				Dbg("ScanImage context suc.");
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}
	}
	else if(ctx->Req.nWay == 1)
	{
		if(m_bStand2SMachine) {
			HSPScannerService_ScanImageEx_Req req = {};
			HSPScannerService_ScanImageEx_Ans ans = {};

			erroCode = m_pHSPSClient->ScanImageEx(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE);
			if(FAILURED(erroCode)) {
				Dbg("ScanImageEx context failed %s.", SpStrError(erroCode));
				nRes = 1;
			} else {
				Dbg("ScanImageEx context suc.");
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}
		else if(m_bUsePortableScanner) {
			PortableScannerService_ScanImageEx_Req req = {};
			PortableScannerService_ScanImageEx_Ans ans = {};

			erroCode = m_pPortableClient->ScanImageEx(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE);
			if(FAILURED(erroCode)) {
				Dbg("ScanImageEx context failed %s.", SpStrError(erroCode));
				nRes = 1;
			} else {
				Dbg("ScanImageEx context suc.");
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}
	}
	ctx->Answer(erroCode);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::SetProperty(SpReqAnsContext<ScannerService_SetProperty_Req, 
	ScannerService_SetProperty_Ans>::Pointer ctx)
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_SetProperty,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {

		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->SetProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(erroCode)) {
			Dbg("SetProperty context failed %s.", SpStrError(erroCode));
			nRes = 1;
		} else {
			ctx->Ans.retCode = ans.retCode;
			Dbg("SetProperty context suc, retCode: ans(%d), ctx(%d).", ans.retCode, ctx->Ans.retCode);
		}
	}else if(m_bUsePortableScanner) {

		PortableScannerService_SetProperty_Req req = {};
		PortableScannerService_SetProperty_Ans ans = {};

		req.rotateType = ctx->Req.rotateType;
		req.scanType = ctx->Req.scanType;
		req.colorType = ctx->Req.colorType;

		erroCode = m_pPortableClient->SetProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(erroCode)) {
			Dbg("SetProperty context failed %s.", SpStrError(erroCode));
			nRes = 1;
		} else {
			ctx->Ans.retCode = ans.retCode;
			Dbg("SetProperty context suc, retCode: ans(%d), ctx(%d).", ans.retCode, ctx->Ans.retCode);
		}
	}

	ctx->Answer(erroCode);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::ShowLTProperty(SpReqAnsContext<ScannerService_ShowProperty_Req, 
	ScannerService_ShowProperty_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Succeed;
	int retCode = 0;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_ShowProperty,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_ShowProperty_Req req = {};
		HSPScannerService_ShowProperty_Ans ans = {};
		erroCode = m_pHSPSClient->ShowProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);

	} else if(m_bUsePortableScanner) {
		PortableScannerService_ShowProperty_Req req = {};
		PortableScannerService_ShowProperty_Ans ans = {};
		erroCode = m_pPortableClient->ShowProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
	}
	if(FAILURED(erroCode)) 
	{
		Dbg("ShowLTProperty context failed %s.", SpStrError(erroCode));
		nRes = 1;
		if(erroCode == Error_TimeOut)
		{
			Dbg("Error_Timeout ?? ignore and return Error_Succeed.");
			erroCode = Error_Succeed;
			nRes = 0;
		}
	}
	else {
		Dbg("ShowLTProperty context suc.");
	}
	ctx->Answer(erroCode);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::SetWinPos(SpReqAnsContext<ScannerService_SetWindowPos_Req, 
	ScannerService_SetWindowPos_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_SetWindowPos,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if (m_bStand2SMachine) {
		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->SetWinPos(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
	} else if(m_bUsePortableScanner) {
		PortableScannerService_SetWinPos_Req req = {};
		PortableScannerService_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_pPortableClient->SetWinPos(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
	}
	if(FAILURED(erroCode)) {
		Dbg("SetWinPos context failed %s.", SpStrError(erroCode));
		nRes = 1;
	} else  {
		Dbg("SetWinPos context suc.");
	}
	ctx->Answer(erroCode);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::GetDevStatus(SpReqAnsContext<ScannerService_GetDevStatus_Req, 
	ScannerService_GetDevStatus_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_GetDevStatus,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_GetDevStatus_Req req = {};
		HSPScannerService_GetDevStatus_Ans ans = {};

		erroCode = m_pHSPSClient->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(erroCode)) {Dbg("GetDevStatus context failed %s.", SpStrError(erroCode)); nRes = 1;}
		else 
		{
			Dbg("GetDevStatus context suc.");

			Dbg("connected: %d\r\n\tshowing: %d\r\n\tpreview: %d.",
				ans.connected, ans.showing, ans.previewing);

			ctx->Ans.bInvalid = ans.connected == 0 ? false : true;
			ctx->Ans.bPreview = ans.previewing == 0 ? false : true;
		}
	} else if(m_bUsePortableScanner) {
		PortableScannerService_GetDevStatus_Req req = {};
		PortableScannerService_GetDevStatus_Ans ans = {};

		erroCode = m_pPortableClient->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(erroCode)) {Dbg("GetDevStatus context failed  %s.", SpStrError(erroCode)); nRes = 1;}
		else 
		{
			Dbg("GetDevStatus context suc.");

			Dbg("connected: %d\r\n\tshowing: %d\r\n\tpreview: %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);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::GetDevInfo(SpReqAnsContext<ScannerService_GetDevInfo_Req, 
	ScannerService_GetDevInfo_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	if(!IsSuitableEntityAvailable())
	{
		ctx->Answer(Error_Break);
		return 1;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_GetDevInfo,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_GetDevInfo_Req req = {};
		HSPScannerService_GetDevInfo_Ans ans = {};

		erroCode = m_pHSPSClient->GetDevInfo(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);


		if(FAILURED(erroCode)) {Dbg("GetDevInfo context failed %s.", SpStrError(erroCode)); nRes = 1;}
		else
		{
			Dbg("GetDevInfo context suc.");

			Dbg("type: %s\r\n\tmodel: %s\r\n\tversion: %s\r\n\tstate:%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;
		}
	}else if(m_bUsePortableScanner) {
		PortableScannerService_GetDevInfo_Req req = {};
		PortableScannerService_GetDevInfo_Ans ans = {};
		erroCode = m_pPortableClient->GetDevInfo(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(erroCode)) {
			Dbg("GetDevInfo context failed  %s.", SpStrError(erroCode));
			nRes = 1;
		}
		else
		{
			Dbg("GetDevInfo context suc.");

			Dbg("type: %s\r\n\tmodel: %s\r\n\tversion: %s\r\n\tstate:%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);
	ReleaseSuitableEntity();
	return nRes;
}

int CScannerFSM::GetOnlineDevices(SpReqAnsContext<ScannerService_GetOnlineCameras_Req, 
	ScannerService_GetOnlineCameras_Ans>::Pointer ctx)
{
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		SpObject2Blob(ctx->Req, sndBuf);
		SpObject2Blob(ctx->Ans, retBuf);
		ptCtx = TransferCtx(ctx);
		ctx.AddRef();
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_GetOnlineCameras,
			sndBuf, retBuf, &ptCtx);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret == Error_Succeed ? 0 : 1;
	}

#if defined(RVC_OS_WIN)
    int nCount = m_cameralist.size();
    Dbg("Path3: Current camera count: %d", nCount);
    ctx->Ans.devCount = nCount;
    if (nCount > 0) {
        ctx->Ans.devFriendlyNames.Init(nCount);
        ctx->Ans.devType.Init(nCount);
        for (int i = 0; i < nCount; ++i) {
            ctx->Ans.devFriendlyNames[i] = m_cameralist[i]->szDevName;
            ctx->Ans.devType[i] = GetRVCCameraType(m_cameralist[i]->szDevName);
            Dbg("[%d]%s(%d)", i, (LPCTSTR)ctx->Ans.devFriendlyNames[i], ctx->Ans.devType[i]);
        }
    }
    ctx->Answer(Error_Succeed);
    return nCount;
#else
    ctx->Answer(Error_NotSupport);
    return 0;
#endif //RVC_OS_WIN
}

ErrorCodeEnum CScannerFSM::OnDevExit()
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if(!IsSuitableEntityAvailable()) {
		return Error_Break;
	}
	if(m_bJBMachine) {
		LPVOID ptCtx = NULL;
		CBlob retBuf;
		CBlob sndBuf;
		Dbg("tmp Ctx: %p", ptCtx);
		auto ret = SendRequest2Heatbeat(ScannerService_Method_Exit,
			sndBuf, retBuf, &ptCtx, false);
		Dbg("SendRequest to Heatbeat return %d immediately", ret);
		ReleaseSuitableEntity();
		return ret;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_Exit_Info info = {};
		erroCode = m_pHSPSClient->Exit();
	}else if(m_bUsePortableScanner) {
		PortableScannerService_Exit_Info info = {};
		erroCode = m_pPortableClient->Exit();
	}
	return erroCode;
}

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

void CScannerFSM::OnStateTrans(int iSrcState, int iDstState)
{
	m_nSrcState = iSrcState;
}

ErrorCodeEnum CScannerFSM::ConnectToHSPScanner()
{
	if(m_pHSPSClient)
	{
		m_pHSPSClient->GetFunction()->CloseSession();
		//m_pHSPSClient->SafeDelete();
		m_pHSPSClient = NULL;
	}

	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_EVT_SCANNERSET_HSPSCNT_FAILED, 
			"Connect to HSPScanner entity failed.");
		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(ISSUCCEEDED(ecInfo))
	{
		Dbg("HSPScanner: eState: %d.", 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_Middle, Error_InvalidState, LOG_EVT_SCANNERSET_HSPSCNT_FAILED, 
			"HSPScanner entity is disconnectable.");
		GetHSPSInfo();
		return Error_InvalidState;
	}
	Dbg("HSPScanner entity is Connectable.");
	pCheckClient->GetFunction()->CloseSession();
	pCheckClient = NULL;
	return Error_Succeed;
}

ErrorCodeEnum CScannerFSM::CheckPortableConnectStatus()
{
	AvailableEntityCheck<CPortableScannerClient> checker;
	bool bConnectable = checker(this->GetEntityBase());
	if(!bConnectable) {
		GetPortableScannerInfo();
	}
	return (bConnectable ? Error_Succeed : Error_InvalidState);
}

ErrorCodeEnum CScannerFSM::ConnectToPortableScanner()
{
	if(m_pPortableClient) {
		m_pPortableClient->GetFunction()->CloseSession();
		//m_pPortableClient->SafeDelete();
		m_pPortableClient = NULL;
	}

	m_pPortableClient = new CPortableScannerClient(GetEntityBase());
	ErrorCodeEnum erroCode = m_pPortableClient->Connect();
	if(FAILURED(erroCode)) {
		m_pPortableClient->SafeDelete();
		m_pPortableClient = NULL;
		LogWarn(Severity_Middle, Error_InvalidState, LOG_WARN_CONNECT_PORTABLESCANNER_FAILED, 
			"Connect to Portable Scanner entity failed.");
		GetPortableScannerInfo();
		return Error_InvalidState;
	}

	//Dbg("Connect to Portable Scanner entity suc.");
	return Error_Succeed;
}

static CSimpleStringA GetPrefixCameraName(CSimpleStringA& cameraFullConfigName)
{
	auto results = cameraFullConfigName.Split(';');
	LOG_ASSERT(results.GetCount() > 0);
	return results[0];
}

ErrorCodeEnum CScannerFSM::LoadConfigAboutCamera()
{
	for(int i=0; i<FIX_CAMERA_COUNTS; ++i) {
		m_fixedCamera[i].strDevName = "";
		m_fixedCamera[i].devType = CAMTYPE_UNKNOWN;
		m_fixedCamera[i].bIdle = FALSE;
	}
	m_bEwsNameRefreshed = false;
	CSmartPointer<IEntityFunction> spFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	ErrorCodeEnum ec = spFunction->OpenConfig(Config_Root, spConfig);
	CSimpleStringA strEnvCamera;
	CSimpleStringA strOptCamera;
	CSimpleStringA strEwsCamera;
	int nEnvID = -1, nOptID = -1, nEwsID = -1;
	if(ISSUCCEEDED(ec)) {
		table.AddEntryString("Video", "EnvCamera", strEnvCamera, "$");
		table.AddEntryString("Video", "OptCamera", strOptCamera, "$");
		table.AddEntryString("Video", "EwsCamera", strEwsCamera, "$");
		ec = table.Load(spConfig);
		if(ISSUCCEEDED(ec)) {
			nEnvID = strEnvCamera.GetLength() > 1 ? /*GetVideoDeviceID(strEnvCamera)*/ 0 : -2;
			nOptID = strOptCamera.GetLength() > 1 ? /*GetVideoDeviceID(strOptCamera)*/ 0 : -2;
			nEwsID = strEwsCamera.GetLength() > 1 ? /*GetVideoDeviceID(strEwsCamera)*/ 0 : -2;
			{
				Dbg("EnvID: [%d](%s)", nEnvID, strEnvCamera.GetData());
				Dbg("OptID: [%d](%s)", nOptID, strOptCamera.GetData());
				Dbg("EwsID: [%d](%s)", nEwsID, strEwsCamera.GetData());

				m_fixedCamera[CAMTYPE_ENV-1].strDevName = strEnvCamera;
				m_fixedCamera[CAMTYPE_ENV-1].devType = CAMTYPE_ENV;

				m_fixedCamera[CAMTYPE_OPT-1].strDevName = strOptCamera;
				m_fixedCamera[CAMTYPE_OPT-1].devType = CAMTYPE_OPT;

				m_fixedCamera[CAMTYPE_EWS-1].strDevName = strEwsCamera;
				m_fixedCamera[CAMTYPE_EWS-1].devType = CAMTYPE_EWS;

				CSimpleStringA strEwsRealName;
				m_strEwsRecordName = strEwsCamera;
				if(nEwsID == 0 && FindEwsCameraName(strEwsRealName, strEwsCamera)) {
					m_fixedCamera[CAMTYPE_EWS-1].strDevName = strEwsRealName;
					m_fixedCamera[CAMTYPE_EWS-1].devType = CAMTYPE_EWS;
					m_bEwsNameRefreshed = true;
				}
			}
			if(nEnvID == -2 || nOptID == -2) {
				CSimpleStringA strPath;
				char lpValue[MAX_PATH] = {0};
				if(GetEntityBase()->GetFunction()->GetPath("HardwareCfg", strPath) == Error_Succeed) {
					int index = strPath.IndexOf("hardwarecfg");
					Dbg("%s(%d)", strPath.GetData(), index);
					if(index != -1) {
						strPath[index] = '\0';
					} else {
						strPath[index] += SPLIT_SLASH;
					}
					CSimpleStringA strMCRunCfg = strPath + "runinfo" SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "MediaController.ini";
					Dbg("%s", (LPCTSTR)strMCRunCfg);
					if(nEnvID == -2) {
						DWORD dwSize = inifile_read_str_s("Video", "FrontCamera", "$", lpValue, MAX_PATH, strMCRunCfg);
						Dbg("Retrive env(front) camera: %s", lpValue);
						if(strlen(lpValue) > 1) {
							CSimpleStringA strValue(lpValue);
							m_fixedCamera[CAMTYPE_ENV-1].strDevName = GetPrefixCameraName(strValue);
							m_fixedCamera[CAMTYPE_ENV-1].devType = CAMTYPE_ENV;
							Dbg("Found front camera name: %s", strEnvCamera.GetData());
						}
					}
					if(nOptID == -2) {
						DWORD dwSize = inifile_read_str_s("Video", "RearCamera", "$", lpValue, MAX_PATH, strMCRunCfg);
						Dbg("Retrive opt(rear) camera from runtime config: %s", lpValue);
						if(strlen(lpValue) > 1) {
							CSimpleStringA strValue(lpValue);
							m_fixedCamera[CAMTYPE_OPT-1].strDevName = GetPrefixCameraName(strValue);
							m_fixedCamera[CAMTYPE_OPT-1].devType = CAMTYPE_OPT;
							Dbg("Found rear camera name: %s", strOptCamera.GetData());
						}
					}
				}
			}
		}
	}

	//Debug
	for(int i=0; i<FIX_CAMERA_COUNTS; ++i) {
		Dbg("[%d]%s:%d", m_fixedCamera[i].devType,
			m_fixedCamera[i].strDevName.GetData(),m_fixedCamera[i].bIdle);
	}
	return ec;
}

bool CScannerFSM::IsPortableScannerDetected(LPCTSTR strDeviceID, BOOL& bUpstairOne)
{
	//TODO: 根据良田和南天提供的设备标识名，判断插入的是否为高拍仪所有的摄像头
	CSimpleStringA strDevice(strDeviceID);
	bUpstairOne = FALSE;
	LPCTSTR split = strrchr(strDeviceID, '#');
	if(split != NULL) {
		if(!_strnicmp(split+1, "upcamera", strlen("upcamera"))) {
			bUpstairOne = TRUE;
			return true;
		}
		else if(!_strnicmp(split+1, "downcamera", strlen("downcamera"))) {
			return true;
		}
	}
	return false;
}

int CScannerFSM::GetCurrentCameraList(
	CAutoArray<ScannerDeviceInfo>& devInforLists, 
	bool bUpdatedRecord)
{
	int nCount = 0;
#if defined(RVC_OS_WIN)
    devInforLists.Clear();
    if (!bUpdatedRecord) {
        CAMERA_BUCKET buckets;
        nCount = GetCameraInfors(buckets);
        Dbg("Path1: Current camera count: %d", nCount);
        if (nCount > 0) {
            RefreshCameraBusyState(devInforLists, buckets, nCount);
            DestoryCamereBuckets(buckets);
        }
    } else {
        UpdateCameraInfors(m_cameralist);
        nCount = m_cameralist.size();
        Dbg("Path2: Current camera count: %d", nCount);
        if (nCount > 0) {
            RefreshCameraBusyState(devInforLists, m_cameralist, nCount);
        }
    }
#endif //RVC_OS_WIN
	return nCount;
}

#if defined(RVC_OS_WIN)

void CScannerFSM::RefreshCameraBusyState(
	CAutoArray<ScannerDeviceInfo>& devInforLists, const CAMERA_BUCKET& buckets, int bucketSize)
{
	devInforLists.Init(bucketSize);
	for(int i=0; i<bucketSize; ++i) 
	{
		devInforLists[i].strDevName = buckets[i]->szDevName;
		Dbg("[%d]%s(%s)", i, (LPCTSTR)devInforLists[i].strDevName, buckets[i]->szDevPath);
		devInforLists[i].devType = GetRVCCameraType(devInforLists[i].strDevName);

		if(TRUE && devInforLists[i].devType == CAMTYPE_HSPS)
			devInforLists[i].bIdle = TRUE;
		else 
			devInforLists[i].bIdle = (IsDeviceBusy(devInforLists[i].strDevName) == 0);

		if(devInforLists[i].devType == CAMTYPE_HSPS && !devInforLists[i].bIdle) {
			devInforLists[i].bIdle = TRUE;
			Dbg("Reset hsps to idle!!");
		}
	}
}
#endif //RVC_OS_WIN

static BOOL IsTheSameDevice(CSimpleStringA& szRunDev, CSimpleStringA& szConfigDev)
{
	if(szRunDev.IsNullOrEmpty() || szConfigDev.IsNullOrEmpty()) {
		return FALSE;
	}
	if(szConfigDev.IsStartWith(szRunDev)) {
		return TRUE;
	}
	return FALSE;
}

/*判断摄像头的类型（使用途径）*/
CapTypeEnum CScannerFSM::GetRVCCameraType(LPCTSTR lpcszDevName)
{
	CapTypeEnum type = CAMTYPE_UNKNOWN;

	BOOL bUpstairs = FALSE;

	if(lpcszDevName == NULL || strlen(lpcszDevName) == 0) {
		LOG_TRACE("invalid dev name.");
		return type;
	}

	if(IsPortableScannerDetected(lpcszDevName, bUpstairs)) {
		Dbg("Detect royal scanner type, up one: %d", bUpstairs);
		return bUpstairs ? CAMTYPE_CIRCLE : CAMTYPE_HSPS;
	} else {
		bool bGet = false;
		for(int i=0; i<FIX_CAMERA_COUNTS; ++i) {
			CSimpleStringA strDevName(lpcszDevName);
			if(IsTheSameDevice(strDevName, m_fixedCamera[i].strDevName)) {
				type = m_fixedCamera[i].devType;
				Dbg("Detect [%s] is %d", lpcszDevName, type);
				bGet = true;
				break;
			}
		}
		if(!bGet && !m_bEwsNameRefreshed && m_strEwsRecordName.GetLength() > 1) {
			if(IsEwsCamera(lpcszDevName)) {
				Dbg("detect ews camera.");
				m_fixedCamera[CAMTYPE_EWS-1].strDevName = lpcszDevName;
				m_fixedCamera[CAMTYPE_EWS-1].devType = CAMTYPE_EWS;
				m_bEwsNameRefreshed = true;
				type = CAMTYPE_EWS;
			}
		}
	}
	return type;
}

void CScannerFSM::OnDeviceInsert()
{
	if(!m_bUsePortableScanner) {
		return;
	}
#if defined(RVC_OS_WIN)
	std::lock_guard<std::mutex> guard(mMtx);
	CAMERA_BUCKET newBuckets;
	int newCount = GetCameraInfors(newBuckets);
	Dbg("OnDeviceInsert: %d VS %d", newCount, m_cameralist.size());
	if(newCount > m_cameralist.size()) {
		CAMERA_BUCKET diffBuckes;
		int diffCount = ExclusiveCameraBuckes(newBuckets, m_cameralist, diffBuckes);
		DisplayCameraInfos(diffBuckes);
		if(diffCount > 0) {
			{
				int state = 0;
				ScannerDeviceInfo info = {};
				auto rc = IsPortScanHoldDevice(&info, state);
				if(ISSUCCEEDED(rc)) {
					Dbg("hold status: %d, devName: %s type:%d",
						state, (LPCTSTR)info.strDevName, info.devType);
				}
			}
			CAMERA_BUCKET_CITER citer = diffBuckes.cbegin();
			while(citer != diffBuckes.cend()) {
				if(CAMTYPE_HSPS == GetRVCCameraType((*citer)->szDevName)
					/*risk: cannot open*/
					&& IsDeviceBusy((*citer)->szDevName) == 0 
					) {
						Dbg("Found new CAMTYPE_HSPS type scanner");
						//Should be set advanced PortableHSPS directly ?
						ScannerDeviceInfo newInfo;
						int nDevID = GetAdvancedScannerDevice(&newInfo);
						if(nDevID >= 0) {
							if(!newInfo.strDevName.Compare((*citer)->szDevName)) {
								auto ec = BindPSDevice(nDevID, newInfo.strDevName);
								if(ISSUCCEEDED(ec)) {
									Dbg("Bind Portable scanner -force succ.");
								}else {
									Dbg("Bind Portable scanner -force failed RC=0X%X", ec); 
								}
							}
						}
						break;
				}
				citer++;
			}
		}
		UpdateCameraInfors(m_cameralist);
	}
#endif //RVC_OS_WIN
}

void CScannerFSM::OnDeviceRemoved()
{
	if(!m_bUsePortableScanner) {
		return;
	}

#if defined(RVC_OS_WIN)

	std::lock_guard<std::mutex> guard(mMtx);
	CAMERA_BUCKET newBuckets;
	int newCount = GetCameraInfors(newBuckets);
	Dbg("OnDeviceRemoved: now %d VS before %d", newCount, m_cameralist.size());
	if(newCount < m_cameralist.size()) {
		CAMERA_BUCKET diffBuckes;
		int diffCount = ExclusiveCameraBuckes(m_cameralist, newBuckets, diffBuckes);
		DisplayCameraInfos(diffBuckes);
		if(diffCount > 0) {
			bool bReBind = false;			
			int state = 0;
			ScannerDeviceInfo info = {};
			auto rc = IsPortScanHoldDevice(&info, state);
			if(ISSUCCEEDED(rc) && state > 0) {
				CAMERA_BUCKET_CITER citer = diffBuckes.cbegin();
				while(citer != diffBuckes.cend()) {
					if(!info.strDevName.Compare((*citer)->szDevName)) {

						ScannerDeviceInfo replacedInfo;
						int nReplaceDevID = GetAdvancedScannerDevice(&replacedInfo);
						if(nReplaceDevID >= 0) {
							auto ec = BindPSDevice(nReplaceDevID, replacedInfo.strDevName);
							if(ISSUCCEEDED(ec)) {
								Dbg("Bind Portable scanner -force succ.");
							}else {
								Dbg("Bind Portable scanner -force failed RC=0X%X", ec); 
							}
						}else {
							Dbg("Thera are no any appropriate device, send drop message.");
							auto rc = DropOffPortScannerDevice();
							if(FAILURED(rc)) {
								Dbg("Opps! DropOffPortScannerDevice failed RC=0x%X", rc);
							}else {
								bReBind = true;
							}
						}
						break;
					}else {
						Dbg("removed one: %s", (*citer)->szDevName);
					}
					citer++;
				}
			}
		}
		UpdateCameraInfors(m_cameralist);
	}

#endif //RVC_OS_WIN

}

void CScannerFSM::PSEntityPostCameraError(LPCTSTR lpcszCameraName)
{
	if((!m_bUsePortableScanner) || lpcszCameraName == NULL) {
		return;
	}
	CSimpleStringA strCameraName = lpcszCameraName;
	if(strCameraName.GetLength() <= 0) {
		ScannerDeviceInfo existed = {};
		int state = 0;
		if(Error_Succeed != IsPortScanHoldDevice(&existed, state)) {
			Dbg("IsPortScanHoldDevice invoked failed");
			return;
		}

		if(state == 0) {
			Dbg("Occasion@1");
			return;
		}
		strCameraName = existed.strDevName;
		if(strCameraName.GetLength() <= 0) {
			Dbg("Occasion@2");
			return;
		}
	}

	CAutoArray<CSimpleStringA> devNames;
	devNames.Init(1);
	devNames[0] = strCameraName;
	ScannerDeviceInfo info;
	ErrorCodeEnum ec = Error_Succeed;
	int nDevID = GetAdvancedScannerDeviceEx(&info, devNames);
	if(nDevID >= 0) {
		ec = BindPSDevice(nDevID, info.strDevName);
		if(ISSUCCEEDED(ec)) {
			Dbg("wait a little...");
			Sleep(200);
		}
	} else {
		Dbg("There are no advanced device could be used, so drop off the current one");
		auto rc = DropOffPortScannerDevice();
		if(FAILURED(rc)) {
			Dbg("Opps! DropOffPortScannerDevice failed RC=0x%X", rc);
		}
		ec = Error_DevNotAvailable;
	}
}

ErrorCodeEnum CScannerFSM::IsPortScanHoldDevice(ScannerDeviceInfo* pInfo, int& curState)
{
	if(pInfo == NULL) {
		return Error_Param;
	}
	if((m_bUsePortableScanner) && ISSUCCEEDED(ConnectToPortableScanner())) {
		PortableScannerService_GetDevStatus_Req req = {};
		PortableScannerService_GetDevStatus_Ans ans = {};
		auto ec = m_pPortableClient->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		ReleaseSuitableEntity();
        if (FAILURED(ec)) {
            Dbg("GetDevStatus failed %s.", SpStrError(ec));
        }
		else {
			pInfo->devIdx = ans.devIndex;
			pInfo->strDevName = ans.checkcode;
			if(ans.connected == 0) {
				curState = 0;
			}else {
				if(ans.previewing && ans.showing) {
					curState = 6;
				}else if(ans.previewing){
					curState = 2;
				}else if(ans.showing) {
					curState = 4;
				}else {
					curState = 1;
				}
			}
			Dbg("GetDevStatus: state:%d, devIdx:%d, devName:%s", 
				curState, pInfo->devIdx, (LPCTSTR)pInfo->strDevName);
			pInfo->bIdle = (BOOL)curState;
			pInfo->devType = (CapTypeEnum)ans.type;
		}
		ReleaseSuitableEntity();
		return ec;
	}
	return Error_Unexpect;
}

ErrorCodeEnum CScannerFSM::IsPortScanHoldDevice(bool& hasHolden,
	int& DevID, 
	CSimpleStringA& strDevName,
	bool& bBusy)
{
	if((m_bUsePortableScanner) && ISSUCCEEDED(ConnectToPortableScanner())) {
		PortableScannerService_GetDevStatus_Req req = {};
		PortableScannerService_GetDevStatus_Ans ans = {};
		auto ec = m_pPortableClient->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		ReleaseSuitableEntity();
        if (FAILURED(ec)) {
            Dbg("GetDevStatus failed %s.", SpStrError(ec));
        }
		else 
		{
			DevID = ans.devIndex;
			strDevName = ans.checkcode;
			if(ans.connected == 0) {
				hasHolden = false;
			}else {
				hasHolden = true;
			}
			if(ans.previewing && ans.showing) {
				bBusy = true;
			}else {
				bBusy = false;
			}
			Dbg("GetDevStatus succ: (%d)[%s]", DevID, (LPCTSTR)strDevName);
		}
		ReleaseSuitableEntity();
		return ec;
	}
	return Error_Unexpect;
}

ErrorCodeEnum CScannerFSM::AttachCheck()
{
	if(!m_bUsePortableScanner) {
		return Error_Succeed;
	}
	ErrorCodeEnum ec = Error_Succeed;
	ScannerDeviceInfo existed = {};
	int state = 0;
	ec = IsPortScanHoldDevice(&existed, state);
	if(ISSUCCEEDED(ec)) {
		if(state == 0) {
			Dbg("Set available portable scanner before start preview.");
			ScannerDeviceInfo info;
			int nDevID = GetAdvancedScannerDevice(&info);
			if(nDevID >= 0) {
				ec = TryBindPSDevice(nDevID, info.strDevName);
				if(ISSUCCEEDED(ec)) {
					Dbg("wait a little...");
					Sleep(200);
				}
 			} else {
				Dbg("There are no advanced device could be used.");
				ec = Error_DevNotAvailable;
			}
		}else {
			Dbg("PortableScanner holds device now, [%d](%s)",
				existed.devIdx, (LPCTSTR)existed.strDevName);
		}
	}
	return ec;
}

ErrorCodeEnum CScannerFSM::_BindPSDevice(int nDevID, LPCTSTR lpcszDevName,  bool bForce)
{
	if(!m_bUsePortableScanner) {
		return Error_InvalidState;
	}
	auto rc = ConnectToPortableScanner();
	if(ISSUCCEEDED(rc)) {
		PortableScannerService_BindCameraDevice_Req req = {};
		PortableScannerService_BindCameraDevice_Ans ans = {};
		req.devId = nDevID;
		req.devName = lpcszDevName;
		req.type = (int)GetRVCCameraType(lpcszDevName);
		req.force = bForce ? 1 : 0;
		rc = m_pPortableClient->BindCameraDevice(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(ISSUCCEEDED(rc)) {
			Dbg("Bind portable scan device (%d)[%s] suc, previous one: [%d](%s)",
				req.devId, (LPCTSTR)req.devName,
				ans.usedId, (LPCTSTR)ans.checkcode);
		} else {
			Dbg("Bind portable scan device failed %s.", SpStrError(rc));
		}
	}
	return rc;
}

int CScannerFSM::GetAdvancedScannerDevice(ScannerDeviceInfo* pDevInfo)
{
	CAutoArray<CSimpleStringA> emptys;
	return GetAdvancedScannerDeviceEx(pDevInfo, emptys);
}

int CScannerFSM::GetAdvancedScannerDeviceEx(ScannerDeviceInfo* pDevInfo, 
	const CAutoArray<CSimpleStringA>& caForbitDeviceNames)
{
	if(pDevInfo == NULL) {
		Dbg("%s: Invalid param", __FUNCTION__);
		return -2;
	}

	CAutoArray<ScannerDeviceInfo> cameralist;
	bool bInnerUpdated = false;
	int devCount = GetCurrentCameraList(cameralist, bInnerUpdated);
	Dbg("Get current camera list returned: %d(devCount)", devCount);
	int nHSPS = -1, nOpt = -1, nOptional = -1, nEws = -1;
	bool bIgonre = false;
	const bool bFilter = (caForbitDeviceNames.GetCount() > 0);
	if(devCount > 0) {
		//requirements: available, 
		for(int i=0; i<devCount; ++i) {

			if(bFilter)
			{
				bIgonre = false;
				for(int j=0, count=caForbitDeviceNames.GetCount(); j<count; ++j) {
					if(cameralist[i].strDevName.Compare(caForbitDeviceNames[j]) == 0) {
						bIgonre = true;
						break;
					}
				}
				if(bIgonre) {
					Dbg("Ignore: [%d](%s)", i, (LPCTSTR)cameralist[i].strDevName);
					continue;
				}
			}

			if(cameralist[i].bIdle && cameralist[i].devType == CAMTYPE_HSPS) {
				nHSPS = i;
				break;
			
			}else if(cameralist[i].bIdle && cameralist[i].devType == CAMTYPE_OPT) {
				nOpt = i;
			
			}else if(cameralist[i].bIdle && cameralist[i].devType == CAMTYPE_EWS) {
				nEws = i;
			
			}else if(cameralist[i].bIdle && cameralist[i].devType != CAMTYPE_ENV && nOptional == -1) {
					nOptional = i;
			}
		}
	}
	/*高拍仪 > 后摄（一般不进行配置，所以作用不大） > 非前置摄像头！！，有可能是 EWS 或者 后摄（如果没配置）或者未知其他摄像头，*/
	int aim = nHSPS != -1 ? nHSPS : ( nOpt != -1 ? nOpt : (nOptional != -1 ? nOptional : nEws ) );
	//int aim = nHSPS == -1 ? ( nOpt == -1 ? nOptional : nOpt ) : nHSPS;
	if(aim != -1) {
		pDevInfo->strDevName = cameralist[aim].strDevName;
		pDevInfo->bIdle = FALSE;
		Dbg("Ex Lucky choice device: %s", (LPCTSTR)pDevInfo->strDevName);
	
	}else {
		Dbg("Opps! no available advanced portable scanner.");
		SendBroadcastAbout();
	}
	return aim;
}

ErrorCodeEnum CScannerFSM::DropOffPortScannerDevice()
{
	ErrorCodeEnum rc = Error_Unexpect;
	if((m_bUsePortableScanner) && ISSUCCEEDED(ConnectToPortableScanner())) {
		rc = m_pPortableClient->DropOffDevice();
		FreePortableScannerClient();
	}
	return rc;
}

void CScannerFSM::InitializeMehodQueue()
{
	for (int idx=0; idx<SS_MAX_METHOD_COUNT; ++idx) {
		ListEntry_InitHead(&m_methods[idx].ContextListHead);
		m_methods[idx].dwSequence = 0;
		m_methods[idx].dwMethodSig = (DWORD)-1;
	}
	m_methods[0].dwMethodSig = ScannerService_Method_StartPreview;
	m_methods[1].dwMethodSig = ScannerService_Method_CancelPreview;
	m_methods[2].dwMethodSig = ScannerService_Method_ScanImage;
	m_methods[3].dwMethodSig = ScannerService_Method_SetWindowPos;
	m_methods[4].dwMethodSig = ScannerService_Method_SetProperty;
	m_methods[5].dwMethodSig = ScannerService_Method_ShowProperty;
	m_methods[6].dwMethodSig = ScannerService_Method_GetDevStatus;
	m_methods[7].dwMethodSig = ScannerService_Method_GetOnlineCameras;
	m_methods[8].dwMethodSig = ScannerService_Method_CrossTermCall;
	m_methods[9].dwMethodSig = ScannerService_Method_GetDevInfo;
	m_methods[10].dwMethodSig = ScannerService_Method_Exit;
	LOG_ASSERT(11 == SS_MAX_METHOD_COUNT);
}

void CScannerFSM::DestoryMethodQueue()
{
		for (int idx=0; idx<SS_MAX_METHOD_COUNT; ++idx) {
			while(!ListEntry_IsEmpty(&m_methods[idx].ContextListHead)) {
				PLIST_ENTRY pListEntry = ListEntry_RemoveListTail(&m_methods[idx].ContextListHead);
				PTC_CONTEXT_CALL_ITEM ptContextItem = CONTAINING_RECORD(pListEntry, TC_CONTEXT_CALL_ITEM, ListEntry);
				if(ptContextItem != NULL) {
					TWHeapFree(ptContextItem);
					ptContextItem = NULL;
				}
			}
		}
}

ErrorCodeEnum CScannerFSM::TryBindPSDevice(int nDevID, LPCTSTR lpcszDevName)
{
	return _BindPSDevice(nDevID, lpcszDevName);
}

ErrorCodeEnum CScannerFSM::BindPSDevice(int nDevID, LPCTSTR lpcszDevName)
{
	return _BindPSDevice(nDevID, lpcszDevName, true);
}

void CScannerFSM::SendBroadcastAbout()
{
	if(!m_bUsePortableScanner) {
		return;
	}

	EventMsg evt;
	evt.eventType = 0;
	evt.reserved2 = "无可用的摄像头或摄像头故障，请检查设备！";

	Dbg("SpSendBroadcast(%d, %s)", evt.eventType, (LPCTSTR)evt.reserved2);
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(EventMsg), SP_MSG_SIG_OF(EventMsg), evt);
}

ErrorCodeEnum CScannerFSM::CheckHeartbeatConnectStatus()
{
	return Error_NotImpl;
}

ErrorCodeEnum CScannerFSM::ConnectToHeartbeat()
{
	FreePortableScannerClient();
	m_pHeartBeatClient = new CHeartBeatClient(GetEntityBase());
	ErrorCodeEnum erroCode = m_pHeartBeatClient->Connect();
	if(FAILURED(erroCode)) {
		m_pHeartBeatClient->SafeDelete();
		m_pHeartBeatClient = NULL;
		LogWarn(Severity_Middle, Error_InvalidState, 0, "Connect to heatbeat entity failed.");
		return Error_InvalidState;
	}
	return Error_Succeed;
}

bool CScannerFSM::GetAttachedTerminal(CSimpleStringA &csTerm)
{
	auto ec = GetEntityBase()->GetFunction()->GetSysVar("AttachedTerminal", csTerm);
	return (ec == Error_Succeed);
}

ErrorCodeEnum CScannerFSM::SendRequest2Heatbeat(
	DWORD dwMethodSig, const CBlob& bbReq, CBlob& bbAns, PVOID* ptCtx, bool fTwoWay)
{
	LOG_FUNCTION();
	static PTC_ENTITY_INTERFACE_QUEUE ptInterfaceQueue = NULL;
	static std::mutex mt4InterfaceQueue;

	Dbg("dwMethodSigure: %d", dwMethodSig);
	ErrorCodeEnum Error = Error_Succeed;
	ptInterfaceQueue = NULL;
	for (int i=0; i<SS_MAX_METHOD_COUNT; ++i) {
		if(dwMethodSig == m_methods[i].dwMethodSig) {
			ptInterfaceQueue = &m_methods[i];
			break;
		}
	}
	if(ptInterfaceQueue == NULL) {
		return Error_MethodNotFound;
	}

	mt4InterfaceQueue.lock();
	ptInterfaceQueue->dwSequence += 1;
	mt4InterfaceQueue.unlock();
	PTC_CONTEXT_CALL_ITEM ptContextItem = NULL;
	if(ptCtx != NULL) {
		ptContextItem = (PTC_CONTEXT_CALL_ITEM)TWHeapAlloc(sizeof(TC_CONTEXT_CALL_ITEM));
		ptContextItem->dwRequestID = ptInterfaceQueue->dwSequence;
		ptContextItem->Context = *ptCtx;
		ListEntry_AddTail(&ptInterfaceQueue->ContextListHead, &ptContextItem->ListEntry);
	} else {
		Dbg("ptCtx is nullptr, ignore it !");
	}

	HeartBeatService_CrossTermCall_Req hb_ctc_req;
	HeartBeatService_CrossTermCall_Ans hb_ctc_ans;
	hb_ctc_req.type = (((int)ptInterfaceQueue->dwSequence << 16) | (ptInterfaceQueue->dwMethodSig & 0xFFFF));
	hb_ctc_req.paramX = bbReq;
	hb_ctc_req.isTwoWay = fTwoWay;
	hb_ctc_req.nEntityID = 0x218; //ScannerSet在shell.ini里的值
	hb_ctc_req.fromTerminalNo = m_strTerminalNo;
#ifdef TWINKLE_LOCAL_DEBUG
	hb_ctc_req.toTerminalNo = "7715010050";
#else
	GetAttachedTerminal(hb_ctc_req.toTerminalNo);
#endif
	hb_ctc_req.param1 = "";
	hb_ctc_req.param2 = "";
	//TODO:
	if(ISSUCCEEDED(Error = ConnectToHeartbeat())) {
		Dbg("Start CrossTermCall %d", hb_ctc_req.paramX.m_iLength);
		Error = m_pHeartBeatClient->CrossTermCall(hb_ctc_req, hb_ctc_ans, 20000);
		Dbg("End CrossTermCall: %d", Error);
	}
	if(FAILURED(Error)) {
		if(ptContextItem != NULL) {
			ListEntry_DeleteNode(&ptContextItem->ListEntry);
			TWHeapFree(ptContextItem);
			ptContextItem = NULL;
		}
	} else {
		Dbg("Invoke CrossTermCall succ, waitting for result...");
	}
	return Error;
}

// 简版机型，接收到回收包
ErrorCodeEnum CScannerFSM::ReceiveAnswer5Heartbeat(
	const ScannerService_CrossTermCall_Req& req, ScannerService_CrossTermCall_Ans& ans)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = Error_Succeed;
	static PTC_ENTITY_INTERFACE_QUEUE ptInterfaceQueue = NULL;
	Dbg("ReceiveAnswer5Heartbeat: %d", ans.retCode);
	ptInterfaceQueue = NULL;
	DWORD dwMethodSig = (ans.retCode & 0xFFFF);
	DWORD dwRequestID = (ans.retCode & 0xFFFF0000) >> 16;
	for (int i=0; i<SS_MAX_METHOD_COUNT; ++i) {
		if(dwMethodSig == m_methods[i].dwMethodSig) {
			ptInterfaceQueue = &m_methods[i];
			break;
		}
	}
	if(ptInterfaceQueue == NULL) {
		return Error_MethodNotFound;
	}

	PTC_CONTEXT_CALL_ITEM ptContextItem = NULL;
	ListEntry_ForEach(ptContextItem, &(ptInterfaceQueue->ContextListHead), TC_CONTEXT_CALL_ITEM, ListEntry)
	{
		if(ptContextItem->dwRequestID == dwRequestID) {
			break;
		}
	}
	if(ptContextItem == NULL || &(ptContextItem->ListEntry) == &(ptInterfaceQueue->ContextListHead)) {
		return Error_BridgeNotBind;
	}

	switch (dwMethodSig) {
	case ScannerService_Method_StartPreview:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_StartPreview_Req,
				ScannerService_StartPreview_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_StartPreview_Req,
				ScannerService_StartPreview_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_CancelPreview:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_CancelPreview_Req,
				ScannerService_CancelPreview_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_CancelPreview_Req,
				ScannerService_CancelPreview_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_ScanImage:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_ScanImage_Req,
				ScannerService_ScanImage_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_ScanImage_Req,
				ScannerService_ScanImage_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_SetWindowPos:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_SetWindowPos_Req,
				ScannerService_SetWindowPos_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_SetWindowPos_Req,
				ScannerService_SetWindowPos_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_SetProperty:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_SetProperty_Req,
				ScannerService_SetProperty_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_SetProperty_Req,
				ScannerService_SetProperty_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_ShowProperty:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_ShowProperty_Req,
				ScannerService_ShowProperty_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_ShowProperty_Req,
				ScannerService_ShowProperty_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_GetDevStatus:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetDevStatus_Req,
				ScannerService_GetDevStatus_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetDevStatus_Req,
				ScannerService_GetDevStatus_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_GetOnlineCameras:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
				ScannerService_GetOnlineCameras_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
				ScannerService_GetOnlineCameras_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_GetDevInfo:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetDevInfo_Req,
				ScannerService_GetDevInfo_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetDevInfo_Req,
				ScannerService_GetDevInfo_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(ans.retParamX, ctx->Ans);
		}
		break;
	case ScannerService_Method_Exit:
		{

		}
		break;
	default:
		Error = Error_MethodNotFound;
		break;
	}

	if(ptContextItem != NULL) {
		ListEntry_DeleteNode(&ptContextItem->ListEntry);
		TWHeapFree(ptContextItem);
		ptContextItem = NULL;
	}
	return Error;
}

ErrorCodeEnum CScannerFSM::ReceiveAnswer5Heartbeat(
	SpOnewayCallContext<ScannerService_CrossTermInvokeInfo_Info>::Pointer context)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = Error_Succeed;
	static PTC_ENTITY_INTERFACE_QUEUE ptInterfaceQueue = NULL;
	Dbg("ReceiveAnswer5Heartbeat: %d, type: 0x%08X", context->Info.result, context->Info.type);
	ptInterfaceQueue = NULL;
	ErrorCodeEnum ec = (ErrorCodeEnum)context->Info.result;
	Dbg("Operation result: %d, %d", context->Info.result, ec);
	DWORD dwMethodSig = (context->Info.type & 0xFFFF);
	DWORD dwRequestID = (context->Info.type & 0xFFFF0000) >> 16;
	for (int i=0; i<SS_MAX_METHOD_COUNT; ++i) {
		if(dwMethodSig == m_methods[i].dwMethodSig) {
			ptInterfaceQueue = &m_methods[i];
			break;
		}
	}
	if(ptInterfaceQueue == NULL) {
		Dbg("Cannot found the method item !");
		return Error_MethodNotFound;
	}

	PTC_CONTEXT_CALL_ITEM ptContextItem = NULL;
	ListEntry_ForEach(ptContextItem, &(ptInterfaceQueue->ContextListHead), TC_CONTEXT_CALL_ITEM, ListEntry) {
		if(ptContextItem->dwRequestID == dwRequestID) {
			break;
		}
	}
	if(ptContextItem == NULL || &(ptContextItem->ListEntry) == &(ptInterfaceQueue->ContextListHead)) {
		Dbg("Cannot found the specified context item");
		return Error_BridgeNotBind;
	}
	Dbg("method signature: %d", dwMethodSig);
	switch (dwMethodSig) {
	case ScannerService_Method_StartPreview:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_StartPreview_Req,
				ScannerService_StartPreview_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_StartPreview_Req,
				ScannerService_StartPreview_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_CancelPreview:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_CancelPreview_Req,
				ScannerService_CancelPreview_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_CancelPreview_Req,
				ScannerService_CancelPreview_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_ScanImage:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_ScanImage_Req,
				ScannerService_ScanImage_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_ScanImage_Req,
				ScannerService_ScanImage_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_SetWindowPos:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_SetWindowPos_Req,
				ScannerService_SetWindowPos_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_SetWindowPos_Req,
				ScannerService_SetWindowPos_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_SetProperty:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_SetProperty_Req,
				ScannerService_SetProperty_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_SetProperty_Req,
				ScannerService_SetProperty_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_ShowProperty:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_ShowProperty_Req,
				ScannerService_ShowProperty_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_ShowProperty_Req,
				ScannerService_ShowProperty_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_GetDevStatus:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetDevStatus_Req,
				ScannerService_GetDevStatus_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetDevStatus_Req,
				ScannerService_GetDevStatus_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_GetOnlineCameras:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
				ScannerService_GetOnlineCameras_Ans>*>(ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
				ScannerService_GetOnlineCameras_Ans>::Pointer ctx;
			ctx.Attach(pt);
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			ctx->Answer(ec);
		}
		break;
	case ScannerService_Method_GetDevInfo:
		{
			auto pt = reinterpret_cast<SpReqAnsContext<ScannerService_GetDevInfo_Req,
				ScannerService_GetDevInfo_Ans>*>(ptContextItem->Context);
			Dbg("evt Ctx: %p", ptContextItem->Context);
			SpReqAnsContext<ScannerService_GetDevInfo_Req,
				ScannerService_GetDevInfo_Ans>::Pointer ctx;
			Dbg("test1");
			ctx.Attach(pt);
			Dbg("test2");
			SpBlob2Object(context->Info.paramX, ctx->Ans);
			Dbg("rtype: %s\r\n\tmodel: %s\r\n\tversion: %s\r\n\tstate:%d.",
				(LPCTSTR)ctx->Ans.type, (LPCTSTR)ctx->Ans.model, (LPCTSTR)ctx->Ans.version, ctx->Ans.state);
			Dbg("test3: %d", ec);
			Dbg("answer:%d", ctx->Answer(ec));
		}
		break;
	case ScannerService_Method_Exit:
		{

		}
		break;
	default:
		Dbg("eventually not found it: %d", dwMethodSig);
		Error = Error_MethodNotFound;
		break;
	}

	if(Error == Error_Succeed) {

	}

	if(ptContextItem != NULL) {
		ListEntry_DeleteNode(&ptContextItem->ListEntry);
		TWHeapFree(ptContextItem);
		ptContextItem = NULL;
	}
	return Error;
}

//接收到心跳的操作请求，常规机型
ErrorCodeEnum CScannerFSM::ReceiveRequest5Heartbeat(
	const ScannerService_CrossTermCall_Req& hcReq, ScannerService_CrossTermCall_Ans& hcAns)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = Error_Succeed;
	Dbg("ReceiveRequest5Heartbeat: %d", hcReq.type);
	hcAns.retCode = hcReq.type;
	switch (hcReq.type & 0xFFFF) {
	case ScannerService_Method_StartPreview:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_StartPreview_Req, ScannerService_StartPreview_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				Dbg("rotate:%d, scan:%d, color:%d, r1:%d, r2:%d, r3:%d, r4:%d", ctx->Req.rotateType, ctx->Req.scanType, ctx->Req.colorType,
					ctx->Req.reserved1, ctx->Req.reserved2, ctx->Req.reserved3, ctx->Req.reserved4);
				Error = this->AttachCheck();
				if(ISSUCCEEDED(Error)) {
					if(this->StartPreview(ctx) != 0) {
						Error = Error_Unexpect;
					} else {
						Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
					}
				}else {
					ctx->Answer(Error_DevNotAvailable);
					/* //test
					ctx->Ans.retCode = 1234;
					ctx->Ans.reserved1 = 7890;
					Error = Error_Succeed;
					Dbg("Test test twtwt");
					ctx->Answer(Error_Succeed);
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
					/**/
				}
				/**/
			} else {
				Dbg("SpBlob2Object in ReceiveRequest5Heartbeat failed: %d", Error);
			}			

			/*
			SpBuffer spbuf2;
			ScannerService_StartPreview_Req scannerReq;
			if(spbuf2.OpenRead((const char*)hcReq.paramX.m_pData, hcReq.paramX.m_iLength)) {
				scannerReq.Serialize(spbuf2);
				Dbg("rotate:%d, scan:%d, color:%d, r1:%d, r2:%d, r3:%d, r4:%d", scannerReq.rotateType, scannerReq.scanType, scannerReq.colorType,
					scannerReq.reserved1, scannerReq.reserved2, scannerReq.reserved3, scannerReq.reserved4);

				//The Test case. should invoke the real interface to 

				ScannerService_StartPreview_Ans scannerAns;
				scannerAns.retCode = 1234;
				scannerAns.reserved1 = 7890;
				hcAns.retType = hcReq.type;
				CAutoBuffer buf = SpObject2Buffer<ScannerService_StartPreview_Ans>(scannerAns);
				SpBuffer spbuf;
				if (!spbuf.OpenRead((const char*)&buf[0], buf.GetCount())) {
					return Error_Unexpect;
				}
				hcAns.retParamX = spbuf.ToBlob();
			} else {
				Dbg("SpBuffer2Object in ReceiveRequest5Heartbeat failed: %d", Error);
			}
			/**/
		}
		break;
	case ScannerService_Method_CancelPreview:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_CancelPreview_Req, ScannerService_CancelPreview_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->StopPreview(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_ScanImage:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_ScanImage_Req, ScannerService_ScanImage_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->ScanImage(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_SetWindowPos:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_SetWindowPos_Req, ScannerService_SetWindowPos_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->SetWinPos(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_SetProperty:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_SetProperty_Req, ScannerService_SetProperty_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->SetProperty(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_ShowProperty:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_ShowProperty_Req, ScannerService_ShowProperty_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->ShowLTProperty(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_GetDevStatus:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_GetDevStatus_Req, ScannerService_GetDevStatus_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->GetDevStatus(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_GetOnlineCameras:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_GetOnlineCameras_Req, ScannerService_GetOnlineCameras_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				this->GetOnlineDevices(ctx);
				Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
			}
		}
		break;
	case ScannerService_Method_GetDevInfo:
		{
			DEFINE_PUPPET_CONTEXT_WITH_TYPE(ScannerService_GetDevInfo_Req, ScannerService_GetDevInfo_Ans);
			if((Error = SpBlob2Object(hcReq.paramX, ctx->Req)) == Error_Succeed) {
				if(this->GetDevInfo(ctx) != 0) {
					Error = Error_Unexpect;
				} else {
					Error = SpObject2Blob(ctx->Ans, hcAns.retParamX);
				}
			}
		}
		break;
	case ScannerService_Method_Exit:
		Error = OnDevExit();
		break;
	default:
		Error = Error_MethodNotFound;
		break;
	}
	return Error;
}

namespace
{

#if defined(RVC_OS_WIN)

GUID* StrToGUID(const WCHAR* guid_string)
{
    static char buffer[64];
    memset(buffer, 0, sizeof(buffer));
    GUID* guid = (GUID*)buffer;
    WCHAR	upperGuid[40 + 1] = { 0 };
    for (int i = 0; i < 40 + 1; i++) {
        upperGuid[i] = guid_string[i];
        if (upperGuid[i] >= L'a' && upperGuid[i] <= L'z') {
            upperGuid[i] += L'A' - L'a';
        }
    }

    swscanf_s(upperGuid, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
              &guid->Data1,
              &guid->Data2,
              &guid->Data3,
              &guid->Data4[0],
              &guid->Data4[1],
              &guid->Data4[2],
              &guid->Data4[3],
              &guid->Data4[4],
              &guid->Data4[5],
              &guid->Data4[6],
              &guid->Data4[7]);

    return guid; //TODO: 
}

#endif //RVC_OS_WIN

}

bool CScannerFSM::FindEwsCameraName(CSimpleStringA& strRetrievedName,
	const CSimpleStringA& strRootName)
{
	if(strRootName.GetLength() <= 1) {
		return false;
	}
	bool bRet = false;

#if defined(RVC_OS_WIN)

	GUID deviceGuid = *StrToGUID(L"{6BDD1FC6-810F-11D0-BEC7-08002BE2092F}");
	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev) {
		return bRet;
	}
	SP_CLASSIMAGELIST_DATA _spImageData = {0};
	_spImageData.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
	SetupDiGetClassImageList(&_spImageData);

	SP_DEVINFO_DATA DevInfo;
	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DWORD DeviceIndex = 0;
	Dbg("Current EwsCamera: %s", strRootName.GetData());
	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo)) {
		int wImageIdx = 0;
		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx)) {
			char szName[MAX_PATH] = {0};
			//先获取获取设备名
			bool bHere = false;
			if(SetupDiGetDeviceInstanceId(hDev, &DevInfo, szName, MAX_PATH - 1, NULL)) {
				Dbg("InstanceId: %s", szName);
				if (0 == _stricmp(szName, strRootName.GetData())) {
					bHere = true;
				}
			} else {
				if (SetupDiGetDeviceRegistryProperty(
					hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
						Dbg("RegistryProperty: %s", szName);
					if (0 == _stricmp(szName, strRootName.GetData())) {
						bHere = true;
					}
				}
			}
			if(bHere){
				Dbg("Enter SPDRP_FRIENDLYNAME routine.");
				if (SetupDiGetDeviceRegistryProperty(
					hDev, &DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
						Dbg("FriendName: %s", szName);
						strRetrievedName = szName;
						bRet = !!(strRetrievedName.GetLength() > 0);
				}
				break;
			}
		}
		DeviceIndex++;
	}
	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev) {
		SetupDiDestroyDeviceInfoList(hDev);
	}

#endif //RVC_OS_WIN

	return bRet;
}

//TODO(Gifur): draw out the same code with FindEwsCameraName
bool CScannerFSM::IsEwsCamera(LPCTSTR lpcszDevfriendlyName)
{
	CSimpleStringA strRetrievedName(true);
	CSimpleStringA strRootName(true);
	bool bRet = FindEwsCameraName(strRetrievedName, m_strEwsRecordName);
	if (bRet) {
		if (strRetrievedName.Compare(lpcszDevfriendlyName, true) == 0) {
			return true;
		}
	}
	return false;
}