myvtm/Module/mod_ScannerSet/ScannerSetFSM.cpp

#include "stdafx.h"
#include "ScannerSetFSM.h"
#include "EventCode.h"
#include "SpIni.h"


#if defined(RVC_OS_WIN)
#include "CameraImpl.h"
#include "SetupApi.h"
#pragma comment(lib, "SetupAPI.lib")
#else
#include "toolkit.h"
#include "iniutil.h"
#include "CommEntityUtil.hpp"
#endif //RVC_OS_WIN
#include "path.h"

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

const int 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;

#define MODULE_VERION_FULL "1.0.0.9"

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;
	}
	return "Unknown EventType";
}

const char* CameraTypeToString(CapTypeEnum devType)
{
	switch(devType) {
	case CAMTYPE_UNKNOWN:
		return "[Default]";
		break;
	case CAMTYPE_ENV:
		return "[ENV]";
		break;
	case CAMTYPE_OPT:
		return "[OPT]";
		break;
	case CAMTYPE_EWS:
		return "[EWS]";
		break;
	case CAMTYPE_HSPS:
		return "[HSPS]";
		break;
	case CAMTYPE_CIRCLE:
		return "[CIRCLE]";
		break;
	case CAMTYPE_MAX:
	default:
		break;
	}
	return "[Unregonized]";
}

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

CScannerFSM::CScannerFSM(void)
	:
	m_csMachineType(true),
	m_csSite(true),
	m_bPadMachine(false),
	m_bStand2SMachine(false),
	m_bDesk2SMachine(false),
	m_bUsePortableScanner(false),
	m_pHSPSClient(NULL),
	m_pPortableClient(NULL),
	m_pMediaControlClient(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)
	InitializeCriticalSection(&cs_devEvt);
    m_hrCoInited = CoInitializeEx(NULL, COINIT_MULTITHREADED);
#endif //RVC_OS_WIN
}

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

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

	FreeMediaControllerClient();
}

ErrorCodeEnum CScannerFSM::OnInit()
{
	ErrorCodeEnum erroCode = Error_Succeed;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Version: %s, Complied at: %s %s", MODULE_VERION_FULL, __DATE__, __TIME__);
	CSmartPointer<IConfigInfo> spConfig;
	CSystemStaticInfo sysInfo;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_strTerminalNo = sysInfo.strTerminalID;
	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);
#if defined(_MSC_VER)
	if(ShouldUsePortableScanner()) {
		m_bUsePortableScanner = true;
		LoadConfigAboutCamera();
		GetCameraInfors(m_cameralist);
		HANDLE hEvtThread = (HANDLE)_beginthreadex(NULL, 0, EventRevThread, this, 0, NULL);
		if(hEvtThread == NULL || hEvtThread == INVALID_HANDLE_VALUE) {
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Create EventRevThread failed");
		} else {
			int times = 0;
			while(gEventRevWnd == NULL && times < 10) {
				Sleep(200);
				times++;
			}
			if(times >= 10 && gEventRevWnd == NULL) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("event recv windows handle is null");
			}
		}
	}
#endif //_MSC_VER

	return erroCode;
}

void CScannerFSM::AfterInit()
{
    if (m_bDesk2SMachine && IsPortScanHoldEnvCameraFromSysVar()) {
        ScannerDeviceInfo existed = {};
        int state = 0;
        ErrorCodeEnum ec1 = IsPortScanHoldDevice(&existed, state);
        if (ISSUCCEEDED(ec1)) {
            if (state == 0 || existed.devType != CAMTYPE_ENV) {
                AccessCamerePriviledge(false, CAMTYPE_ENV);
            }
        }
    }
}

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

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

void CScannerFSM::s0_on_exit()
{
}

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

		}
		e->SetHandled();
		break;
	case USER_EVT_STARTPREVIEW:
		{
			StartPreviewTask* pTask = new StartPreviewTask(this);
			StartPreviewEvent* pEvt = dynamic_cast<StartPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			e->SetHandled();
		}
		break;
	case USER_EVT_STOPPREVIEW:
		{
			StopPreviewTask* pTask = new StopPreviewTask(this);
			StopPreviewEvent* pEvt = dynamic_cast<StopPreviewEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SCANIMAGE:
		{
			ScanImageTask* pTask = new ScanImageTask(this);
			ScanImageEvent* pEvt = dynamic_cast<ScanImageEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SETPROPERTY:
		{
			SetPropertyEvent* pEvt = dynamic_cast<SetPropertyEvent*>(e);
			SetPropertyTask* pTask = new SetPropertyTask(this);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SHOWPROPERTY:
		{
			ShowPropertyEvent* pEvt = dynamic_cast<ShowPropertyEvent*>(e);
			ShowPropertyTask* pTask = new ShowPropertyTask(this);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_SETWINPOS:
		{
			SetWinPosEvent* pEvt = dynamic_cast<SetWinPosEvent*>(e);
			SetWinPosTask* pTask = new SetWinPosTask(this);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			PostEventFIFO(new OperatingEvent(e->iEvt)); //operating event.
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_CROSS_CALL:
		break;
	case USER_EVT_CROSS_CALL_ONEWAY:
		break;
	}
	return uRet;
}

/** No use for now [80374374@2022615]*/
void CScannerFSM::s1_on_entry()
{
	LOG_FUNCTION();
	FSMEvent* evt = new FSMEvent(USER_EVT_ESTIMATE_FINISHED);
	evt->param1 = evt->param2 = 0;
#if defined(RVC_OS_WIN)
	CAutoArray<ScannerDeviceInfo> cameralist;
	bool bInnerUpdated = true;
	int devCount = GetCurrentCameraList(cameralist, bInnerUpdated);
	LOG_ASSERT(!bInnerUpdated || devCount == m_cameralist.size());
	int flag = 0;
	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))) {

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

/** No use for now [80374374@2022615]*/
void CScannerFSM::s1_on_exit()
{

}

/** No use for now [80374374@2022615]*/
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()
{

}

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

unsigned int CScannerFSM::s2_on_event(FSMEvent* e)
{
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_STARTPREVIEW_FINISHED:
		{
			if(m_iEvt == USER_EVT_STARTPREVIEW)
			{
				//uRet = e->param1;
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_STOPPREVIEW_FINISHED:
		{
			if(m_iEvt == USER_EVT_STOPPREVIEW)
			{
				//uRet = e->param1;
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SCANIMAGEFINISHED:
		{
			if(m_iEvt == USER_EVT_SCANIMAGE)
			{
				//uRet = e->param1;
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SETPROPERTY_FINISHED:
		{
			if(m_iEvt == USER_EVT_SETPROPERTY)
			{
				//uRet = e->param1;
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SHOWPROPERTY_FINISHED:
		{
			if(m_iEvt == USER_EVT_SHOWPROPERTY)
			{
				//uRet = e->param1;
				uRet = 1;
				e->SetHandled();
			}
		}
		break;
	case USER_EVT_SETWINPOS_FINISHED:
		{
			if(m_iEvt == USER_EVT_SETWINPOS)
			{
				//uRet = e->param1;
				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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("s3_on_event: %s(%d), %d.", EvtTypeToString(e->iEvt), e->iEvt, e->param1);
	unsigned int uRet = 0;
	switch(e->iEvt)
	{
	case USER_EVT_GETSTATUS:
		{
			GetDevStatusTask* pTask = new GetDevStatusTask(this);
			GetDevStatusEvent* pEvt = dynamic_cast<GetDevStatusEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}


#pragma endregion Useless for current

void CScannerFSM::s4_on_entry()
{
	if(m_bStand2SMachine || m_bUsePortableScanner)
	{
		ScheduleTimer(CHECKDEV_TIMER_ID, MILLISECOND_TO_CHECKDEV);
	}
}

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

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

		}
		e->SetHandled();
		break;
	case EVT_TIMER:
		{
			if(e->param1 == CHECKDEV_TIMER_ID)
			{
				e->SetHandled();
				if(!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()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	case USER_EVT_GETINFO:
		{
			GetDevInfoTask* pTask = new GetDevInfoTask(this);
			GetDevInfoEvent* pEvt = dynamic_cast<GetDevInfoEvent*>(e);
			pTask->SetContext(pEvt->m_ctx);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		e->SetHandled();
		break;
	}
	return uRet;
}

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

	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_StartPreview).setResultCode("RTA2O01")();
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 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)(EntityResource::getLink().upgradeLink())->StartPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW, dwUserCode);
		if (FAILURED(erroCode)) {
			nRes = 1;
			if (MapErrorCode2Level(erroCode)) {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_StartPreview,
					CSimpleStringA::Format("StartPreview context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				erroCode = Error_DevNotAvailable;
			} else {
				LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_StartPreview,
					CSimpleStringA::Format("StartPreview context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			}
		} else {
			ctx->Ans.retCode = ans.retCode;
		}
	} 
	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)(EntityResource::getLink().upgradeLink())->StartPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_STARTPREVIEW, dwUserCode);
		if(FAILURED(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_StartPreview,
				CSimpleStringA::Format("StartPreview context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			nRes = 1;
		}
		else {
			ctx->Ans.retCode = ans.retCode;
		}
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

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

	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_CancelPreview).setResultCode("RTA2O01")();
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	if(m_bStand2SMachine) {

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

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

		if (FAILURED(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_CancelPreview,
				CSimpleStringA::Format("CancelPreview context failed: ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			nRes = 1;
		} else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER).setAPI(__FUNCTION__)("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)(EntityResource::getLink().upgradeLink())->CancelPreview(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
		ctx->Answer(erroCode, dwUserCode);

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

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

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

			if(FAILURED(erroCode)) {
				if (MapErrorCode2Level(erroCode)) {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
						CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
					erroCode = Error_DevNotAvailable;
				} else {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
						CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				}
				nRes = 1;
			} else {
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}else if(m_bUsePortableScanner) {
			PortableScannerService_ScanImage_Req req = {};
			PortableScannerService_ScanImage_Ans ans = {};

			erroCode = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->ScanImage(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE, dwUserCode);

			if(FAILURED(erroCode)) {
				if (MapErrorCode2Level(erroCode)) {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
						CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
					erroCode = Error_DevNotAvailable;
				} else {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImage,
						CSimpleStringA::Format("ScanImage context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				}
				nRes = 1;
			} else {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER).setAPI(__FUNCTION__)("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)(EntityResource::getLink().upgradeLink())->ScanImageEx(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE, dwUserCode);
			if(FAILURED(erroCode)) {
				if (MapErrorCode2Level(erroCode)) {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
						CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
					erroCode = Error_DevNotAvailable;
				} else {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
						CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				}
				nRes = 1;
			} else {
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}
		else if(m_bUsePortableScanner) {
			PortableScannerService_ScanImageEx_Req req = {};
			PortableScannerService_ScanImageEx_Ans ans = {};

			erroCode = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->ScanImageEx(req, ans, MILLISECOND_WAIT_TIMEOUT_SCANIMAGE, dwUserCode);
			if(FAILURED(erroCode)) {
				if (MapErrorCode2Level(erroCode)) {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
						CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
					erroCode = Error_DevNotAvailable;
				} else {
					LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ScanImageEx,
						CSimpleStringA::Format("ScanImageEx context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
				}
				nRes = 1;
			} else {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("ScanImageEx context suc.");
				ctx->Ans.filePath = ans.filePath;
				ctx->Ans.imageData = ans.imageData;
			}
		}
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

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

	int nRes = 0;
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_SetProperty).setResultCode("RTA2O01")();
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 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)(EntityResource::getLink().upgradeLink())->SetProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
		if(FAILURED(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_SetProperty,
				CSimpleStringA::Format("SetProperty context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			nRes = 1;
		} else {
			ctx->Ans.retCode = ans.retCode;
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("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)(EntityResource::getLink().upgradeLink())->SetProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
		if(FAILURED(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_SetProperty,
				CSimpleStringA::Format("SetProperty context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
			nRes = 1;
		} else {
			ctx->Ans.retCode = ans.retCode;
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("SetProperty context suc, retCode: ans(%d), ctx(%d).", ans.retCode, ctx->Ans.retCode);
		}
	}

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

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

	int retCode = 0;
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_ShowProperty).setResultCode("RTA2O01")();
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 1;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_ShowProperty_Req req = {};
		HSPScannerService_ShowProperty_Ans ans = {};
		erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->ShowProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);

	} else if(m_bUsePortableScanner) {
		PortableScannerService_ShowProperty_Req req = {};
		PortableScannerService_ShowProperty_Ans ans = {};
		erroCode = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->ShowProperty(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	}
	if(FAILURED(erroCode)) 
	{
		LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_ShowProperty,
			CSimpleStringA::Format("ShowLTProperty context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		nRes = 1;
		if(erroCode == Error_TimeOut)
		{
			erroCode = Error_Succeed;
			nRes = 0;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("ShowLTProperty context suc.");
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::SetWinPos(SpReqAnsContext<ScannerService_SetWindowPos_Req, 
	ScannerService_SetWindowPos_Ans>::Pointer ctx)
{
	int nRes = 0;
	ErrorCodeEnum erroCode = Error_Unexpect;
	DWORD dwUserCode(0);
	if(!IsSuitableEntityAvailable())
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(__FUNCTION__).setLogCode(ScannerService_LogCode_SetWindowPos).setResultCode("RTA2O01")();
		ctx->Answer(Error_DevNotAvailable, LOG_WARN_MODULE_INVALID);
		return 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)(EntityResource::getLink().upgradeLink())->SetWinPos(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);

	} 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)(EntityResource::getLink().upgradeLink())->SetWinPos(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
	}

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

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

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

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

		erroCode = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
		if(FAILURED(erroCode)) {
			LogWarn(Severity_Middle, erroCode, LOG_ERR_SCANNERSET_API_INVOKE_GetDevStatus,
				CSimpleStringA::Format("GetDevStatus context failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(erroCode), dwUserCode));
		}
		else 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("connected: %d, showing: %d, preview: %d.",
				ans.connected, ans.showing, ans.previewing);

			ctx->Ans.bInvalid = ans.connected == 0 ? false : true;
			ctx->Ans.bPreview = ans.previewing == 0 ? false : true;
		}
	}

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

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

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

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


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

	} else if(m_bUsePortableScanner) {

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

			ctx->Ans.type = ans.type;
			ctx->Ans.model = ans.model;
			ctx->Ans.version = ans.version;
			ctx->Ans.state = ans.state;
		}
	}
	ctx->Answer(erroCode, dwUserCode);
	return nRes;
}

int CScannerFSM::GetOnlineDevices(SpReqAnsContext<ScannerService_GetOnlineCameras_Req, 
	ScannerService_GetOnlineCameras_Ans>::Pointer ctx)
{
#if defined(_MSC_VER)
	CAutoArray<ScannerDeviceInfo> cameralist;
	if(FALSE) {
		UpdateCameraInfors(m_cameralist);
	}
	int nCount = m_cameralist.size();
	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);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("[%d]%s(%s)", i, (LPCTSTR)ctx->Ans.devFriendlyNames[i], CameraTypeToString((CapTypeEnum)ctx->Ans.devType[i]));
		}
	}
	ctx->Answer(Error_Succeed);
	return nCount;
#else
    ctx->Answer(Error_NotSupport);
    return 0;
#endif //_MSC_VER
}

ErrorCodeEnum CScannerFSM::OnDevExit()
{
	ErrorCodeEnum erroCode = Error_Unexpect;
	int nRes = 0;
	if(!IsSuitableEntityAvailable()) {
		return Error_DevNotAvailable;
	}
	if(m_bStand2SMachine) {
		HSPScannerService_Exit_Info info = {};
		erroCode = (*m_pHSPSClient)(EntityResource::getLink().upgradeLink())->Exit();
	}else if(m_bUsePortableScanner) {
		PortableScannerService_Exit_Info info = {};
		erroCode = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->Exit();
		if(erroCode == Error_Succeed && IsPortScanHoldEnvCameraFromSysVar()) {
			WaitPortableReleaseCamera(CAMTYPE_ENV);
			AccessCamerePriviledge(false, CAMTYPE_ENV);
		}
	}
	return erroCode;
}

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

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

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

		FreeHSPScannerClient();

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

	return Error_Succeed;
}

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

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

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

ErrorCodeEnum CScannerFSM::ConnectToPortableScanner()
{
	if (!IsPortableConnectSessionOK()) {
	
		FreePortableScannerClient();

		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_MODULE_INVALID,
				CSimpleStringA::Format("Connect to Portable Scanner entity failed: %s", SpStrError(erroCode)));

			GetPortableScannerInfo();
			return Error_DevNotAvailable;
		}
	}

	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)) {
		//环境摄像头 核身，交易录像，上（大机），前置（PAD），客户感知触发开启摄像头，连线
		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;
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EnvID: [%d](%s)", nEnvID, strEnvCamera.GetData());
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OptID: [%d](%s)", nOptID, strOptCamera.GetData());
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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");
					if(index != -1) {
						strPath[index] = '\0';
					} else {
						strPath[index] += SPLIT_SLASH;
					}
					CSimpleStringA strMCRunCfg = strPath + "runinfo" SPLIT_SLASH_STR "runcfg" SPLIT_SLASH_STR "MediaController.ini";
					if(nEnvID == -2) {
#if defined(_MSC_VER)
						DWORD dwSize = ::GetPrivateProfileStringA("Video", "FrontCamera", "$",
							lpValue, MAX_PATH, strMCRunCfg);
#else
						DWORD dwSize = inifile_read_str_s("Video", "FrontCamera", "$", lpValue, MAX_PATH, strMCRunCfg);
#endif //_MSC_VER

						if(strlen(lpValue) > 1) {
							CSimpleStringA strValue(lpValue);
							m_fixedCamera[CAMTYPE_ENV-1].strDevName = GetPrefixCameraName(strValue);
							m_fixedCamera[CAMTYPE_ENV-1].devType = CAMTYPE_ENV;
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Found front camera name from runinfo: %s", m_fixedCamera[CAMTYPE_ENV - 1].strDevName.GetData());
						}
					}
					if(nOptID == -2) {
#if defined(_MSC_VER)
						DWORD dwSize = ::GetPrivateProfileStringA("Video", "RearCamera", "$", lpValue, MAX_PATH, strMCRunCfg);
#else
						DWORD dwSize = inifile_read_str_s("Video", "RearCamera", "$", lpValue, MAX_PATH, strMCRunCfg);
#endif //_MSC_VER
						if(strlen(lpValue) > 1) {
							CSimpleStringA strValue(lpValue);
							m_fixedCamera[CAMTYPE_OPT-1].strDevName = GetPrefixCameraName(strValue);
							m_fixedCamera[CAMTYPE_OPT-1].devType = CAMTYPE_OPT;
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Found rear camera name from runinfo:  %s", m_fixedCamera[CAMTYPE_OPT - 1].strDevName.GetData());
						}
					}
				}
			}
		}
	}

	//Debug
	std::string strDebug;
	for(int i=0; i<FIX_CAMERA_COUNTS; ++i) {
		CSimpleStringA tmp = CSimpleStringA::Format("[%s]%s: %d", CameraTypeToString(m_fixedCamera[i].devType),
			m_fixedCamera[i].strDevName.GetData(),m_fixedCamera[i].bIdle);
		if(i != 0) strDebug += "$$";
		strDebug += tmp.GetData();
	}
	LogWarn(Severity_Low, Error_Debug, LOG_ERR_SCANNERSET_CONFIGURE_CAMERA, strDebug.c_str());
	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);
        if (nCount > 0) {
            RefreshCameraBusyState(devInforLists, buckets, nCount);
            DestoryCamereBuckets(buckets);
        }
    } else {
        UpdateCameraInfors(m_cameralist);
        nCount = m_cameralist.size();
        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;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("[%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);
	}
}
#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)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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 strTemp(lpcszDevName);
			if(IsTheSameDevice(strTemp, m_fixedCamera[i].strDevName)) {
				type = m_fixedCamera[i].devType;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Detect [%s] is %s", lpcszDevName, CameraTypeToString(type));
				bGet = true;
				break;
			}
		}
		if(!bGet && !m_bEwsNameRefreshed && m_strEwsRecordName.GetLength() > 1) {
			if(IsEwsCamera(lpcszDevName)) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
	EnterCriticalSection(&cs_devEvt);
	CAMERA_BUCKET newBuckets;
	int newCount = GetCameraInfors(newBuckets);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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 
					) {//设备是高拍仪才进行绑定
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)) {
									DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Bind Portable scanner -force succ.");
								}else {
									DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Bind Portable scanner -force failed RC=0X%X", ec); 
								}
							}
						}
						break;
				}
				citer++;
			}
			DestoryCamereBuckets(diffBuckes);
		}
		UpdateCameraInfors(m_cameralist);
	}
	
	DestoryCamereBuckets(newBuckets);

	LeaveCriticalSection(&cs_devEvt);
#endif //RVC_OS_WIN
}

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

#if defined(RVC_OS_WIN)

	EnterCriticalSection(&cs_devEvt);
	CAMERA_BUCKET newBuckets;
	int newCount = GetCameraInfors(newBuckets);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)) {
								DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Bind Portable scanner -force succ.");
							}else {
								DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Bind Portable scanner -force failed RC=0X%X", ec); 
							}
						} else {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Thera are no any appropriate device, send drop message.");
							auto rc = DropOffPortScannerDevice();
							if(FAILURED(rc)) {
								DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("Opps! Drop Off PortScanner Device failed RC=0x%X", rc);
							}else {
								if(info.devType == CAMTYPE_ENV) {
									WaitPortableReleaseCamera(CAMTYPE_ENV);
									AccessCamerePriviledge(false, CAMTYPE_ENV);
								}
								bReBind = true;
							}
						}
						break;
					}else {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("removed one: %s", (*citer)->szDevName);
					}
					citer++;
				}
			}

			DestoryCamereBuckets(diffBuckes);
		}
		UpdateCameraInfors(m_cameralist);
	}
	
	DestoryCamereBuckets(newBuckets);

	LeaveCriticalSection(&cs_devEvt);
	
#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)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("IsPortScanHoldDevice invoked failed");
			return;
		}

		if(state == 0) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Occasion@1");
			return;
		}
		strCameraName = existed.strDevName;
		if(strCameraName.GetLength() <= 0) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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)) {
			Sleep(200);
		}
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("There are no advanced device could be used, so drop off the current one");
		auto rc = DropOffPortScannerDevice(!m_bDesk2SMachine);
		if(FAILURED(rc)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Opps! Drop Off PortScanner Device failed RC=0x%X", rc);
		}
		ec = Error_DevNotAvailable;
	}
}

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

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

ErrorCodeEnum CScannerFSM::IsPortScanHoldDevice(ScannerDeviceInfo* pInfo, int& curState)
{
	if(pInfo == NULL) {
		return Error_Param;
	}
	if(IsSuitableEntityAvailable()) {
		PortableScannerService_GetDevStatus_Req req = {};
		PortableScannerService_GetDevStatus_Ans ans = {};
		auto ec = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(ec)) {
			if (MapErrorCode2Level(ec)) {
				LogWarn(Severity_Middle, ec, LOG_ERR_SCANNERSET_API_INVOKE_GetDevStatus,
					CSimpleStringA::Format("GetDevStatus failed 0x%x(%d).", ec, ec));
				ec = Error_DevNotAvailable;
			} else {
				LogWarn(Severity_Middle, ec, LOG_ERR_SCANNERSET_API_INVOKE_GetDevStatus,
					CSimpleStringA::Format("GetDevStatus failed 0x%x(%d).", ec, 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;
				}
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus: state:%d, devIdx:%d, devName:%s", 
				curState, pInfo->devIdx, (LPCTSTR)pInfo->strDevName);
			pInfo->bIdle = (BOOL)curState;
			pInfo->devType = (CapTypeEnum)ans.type;
		}
		return ec;
	} else {
		LogWarn(Severity_Middle, Error_DevNotAvailable, LOG_WARN_ATTACH_FAILED, "Connect to PortableScanner entity failed!");
		return Error_DevNotAvailable;
	}
}

ErrorCodeEnum CScannerFSM::IsPortScanHoldDevice(bool& hasHolden,
	int& DevID, 
	CSimpleStringA& strDevName,
	bool& bBusy)
{
	if(IsSuitableEntityAvailable()) {
		PortableScannerService_GetDevStatus_Req req = {};
		PortableScannerService_GetDevStatus_Ans ans = {};
		auto ec = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->GetDevStatus(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT);
		if(FAILURED(ec)) {
			LogWarn(Severity_Middle, ec, LOG_ERR_SCANNERSET_API_INVOKE_GetDevStatus,
				CSimpleStringA::Format("GetDevStatus failed 0x%x(%d).", ec, 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;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus succ: (%d)[%s]", DevID, (LPCTSTR)strDevName);
		}
		return ec;
	} else {
		return Error_DevNotAvailable;
	}
}

bool CScannerFSM::IsPortScanHoldLimitedDevice(CapTypeEnum& devType)
{
	bool result(false);
	if(!m_bDesk2SMachine) return result;

	for(int i=0; i<FIX_CAMERA_COUNTS; ++i) {
		if(!m_fixedCamera[i].strDevName.IsNullOrEmpty() && m_fixedCamera[i].strDevName.Compare("$") != 0) {
			CSimpleStringA owner;
			ErrorCodeEnum rc1 = GetCameraOccpuiedStatus(GetEntityBase(),
				GetPrefixCameraName(m_fixedCamera[i].strDevName), owner);
			if(!owner.IsNullOrEmpty() && owner.Compare("PortableScanner") == 0) {
				devType = m_fixedCamera[i].devType;
				result = true;
				break;
			}
		}
	}
	return result;
}

void CScannerFSM::ClearPortScanHoldLimitedDevice(const CapTypeEnum& devType, const char* lpcszDevName)
{
	if(CAMTYPE_UNKNOWN < devType && devType < CAMTYPE_MAX) {
		if(!m_fixedCamera[devType-1].strDevName.IsNullOrEmpty()) {
			OccpyCameraStruct item(GetPrefixCameraName(m_fixedCamera[devType-1].strDevName), "PortableScanner");
			RemoveOccpuiedCamera(item, GetEntityBase()->GetFunction());
		}
	} else if(devType == CAMTYPE_MAX) {
		OccpyCameraStruct item("*", "PortableScanner");
		RemoveOccpuiedCamera(item, GetEntityBase()->GetFunction());
	} else if(devType == CAMTYPE_UNKNOWN && lpcszDevName != NULL) {
		OccpyCameraStruct item(lpcszDevName, "PortableScanner");
		RemoveOccpuiedCamera(item, GetEntityBase()->GetFunction());
	}
}

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) {
			ScannerDeviceInfo info;
			int nDevID = GetAdvancedScannerDevice(&info);
			if(nDevID >= 0) {
				ec = TryBindPSDevice(nDevID, info.strDevName);
				if(ISSUCCEEDED(ec)) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("AttachCheck::TryBindPSDevice [%d][%s] succ", nDevID, info.strDevName.GetData());
					Sleep(200);
				} else {
					/** 为抹平 Level3 所加的告警 Gifur@2023222]*/
					if (ec != Error_DevNotAvailable) {
						LogError(Severity_Middle, ec, LOG_ERR_SCANNERSET_BIND_CAMERA, CSimpleStringA::Format("AttachCheck::TryBindPSDevice [%d][%s] failed: %s", nDevID, info.strDevName.GetData(), SpStrError(ec)));
					}
				}
 			} else {
				LogWarn(Severity_Middle, Error_DevNotAvailable, LOG_WARN_ATTACH_FAILED, "There are no advanced device could be used.");
				ec = Error_DevNotAvailable;
			}
		}else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PortableScanner holds device now, [%d](%s)",
				existed.devIdx, (LPCTSTR)existed.strDevName);
		}
	}
	return ec;
}

ErrorCodeEnum CScannerFSM::AttachReleaseIfNecessary()
{
	if(m_bDesk2SMachine) {
		ErrorCodeEnum ec = Error_Succeed;
		ScannerDeviceInfo existed = {};
		int state = 0;
		ec = IsPortScanHoldDevice(&existed, state);
		if(existed.devType == CAMTYPE_ENV && DropOffPortScannerDevice() == Error_Succeed) {
			WaitPortableReleaseCamera(CAMTYPE_ENV);
			AccessCamerePriviledge(false, CAMTYPE_ENV);
		}
	}
	return Error_Succeed;
}

void CScannerFSM::OnChildEntityStateChange(const EntityStateEnum& oldState, const EntityStateEnum& curState)
{
	if(m_bDesk2SMachine) {
		if(IsNoralEntityState(oldState) && !IsNoralEntityState(curState)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PortableScnner is dead!");
			if(IsPortScanHoldEnvCameraFromSysVar()) {
				AccessCamerePriviledge(false, CAMTYPE_ENV);
			}
		}
	}
}

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;
		if(CAMTYPE_ENV == req.type) {
			rc = AccessCamerePriviledge(true, CAMTYPE_ENV);
			if(rc != Error_Succeed && rc != Error_Param) {
				LogWarn(Severity_Middle, rc, LOG_ERR_SCANNERSET_HSPSCNT_ACCESS_ENV_FAILED, "get access env camera priviledge failed!");
				return rc;
			}
		}
		DWORD dwUserCode(0);
		rc = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->BindCameraDevice(req, ans, MILLISECOND_WAIT_TIMEOUT_DEFAULT, dwUserCode);
		if(ISSUCCEEDED(rc)) {
			LogWarn(Severity_Low, rc, LOG_ERR_SCANNERSET_BIND_CAMERA,
				CSimpleStringA::Format("Bind portable scan device (%d)[%s] suc, previous one: (%d)[%s]",
				req.devId, (LPCTSTR)req.devName,
				ans.usedId, (LPCTSTR)ans.checkcode));
			
			if(CAMTYPE_ENV == GetRVCCameraType(ans.checkcode)) {
				AccessCamerePriviledge(false, CAMTYPE_ENV);
			} else {
				ClearPortScanHoldLimitedDevice(CAMTYPE_UNKNOWN, ans.checkcode);
			}
			OccpyCameraStruct curItem(req.devName, "PortableScanner");
			AppendOccpuiedCamera(curItem, GetEntityBase()->GetFunction());

		} else {
			if (MapErrorCode2Level(rc)) {
				LogWarn(Severity_Middle, rc, LOG_ERR_SCANNERSET_API_INVOKE_BindCameraDevice, CSimpleStringA::Format("Bind portable scan device failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(rc), dwUserCode));
				rc = Error_DevNotAvailable;
			} else {
				LogWarn(Severity_Middle, rc, LOG_ERR_SCANNERSET_API_INVOKE_BindCameraDevice, CSimpleStringA::Format("Bind portable scan device failed, ErrCode:%s, userCode: 0x%08X.", SpStrError(rc), dwUserCode));
			}
		}
	} else {
		//LogWarn(Severity_Middle, rc, LOG_WARN_CONNECT_PORTABLESCANNER_FAILED,
		//	CSimpleStringA::Format("Connect to  portable scan entity failed for BindDevice, EC = %u", 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) {
		return -2;
	}

	CAutoArray<ScannerDeviceInfo> cameralist;
	bool bInnerUpdated = false;
	const int devCount = GetCurrentCameraList(cameralist, bInnerUpdated);
	int nHSPS = -1, nOpt = -1, nOptional = -1, nEws = -1, nEnv = -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) {
					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;
			}else if(cameralist[i].bIdle && cameralist[i].devType == CAMTYPE_ENV) {
				nEnv = i;
			}
		}
	}
	/*高拍仪 > 后摄（一般不进行配置，所以作用不大） > 非前置摄像头！！，有可能是 EWS 或者 后摄（如果没配置）或者未知其他摄像头，*/
	int aim = nHSPS != -1 ? nHSPS : ( nOpt != -1 ? nOpt : (nOptional != -1 ? nOptional : nEws ) );
	if(aim != -1) {
		pDevInfo->strDevName = cameralist[aim].strDevName;
		pDevInfo->bIdle = FALSE;
		pDevInfo->devType = cameralist[aim].devType;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Ex Lucky choice device: %s", (LPCTSTR)pDevInfo->strDevName);
	
	} else if(m_bDesk2SMachine && devCount == 1 && nEnv != -1) {
		aim = nEnv;
		pDevInfo->strDevName = cameralist[nEnv].strDevName;
		pDevInfo->bIdle = FALSE;
		pDevInfo->devType = cameralist[nEnv].devType;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("!!!!! Desk2S at single camera: choice env camera: %s", (LPCTSTR)pDevInfo->strDevName);
	} else {
		LogWarn(Severity_Middle, Error_DevNotAvailable, LOG_ERR_SCANNERSET_NO_AVAILABLE_CAMERA,
			CSimpleStringA::Format("Opps! no available advanced portable scanner. %d", devCount));
		SendBroadcastAbout();
	}
	return aim;
}

ErrorCodeEnum CScannerFSM::DropOffPortScannerDevice(bool skipToCheck)
{
	ErrorCodeEnum rc = Error_Unexpect;
	if((m_bUsePortableScanner) && ISSUCCEEDED(rc = ConnectToPortableScanner())) {
		ScannerDeviceInfo preDev = {};
		preDev.devType = CAMTYPE_UNKNOWN;
		if(!skipToCheck) {
			int state = 0;
			IsPortScanHoldDevice(&preDev, state);
		}

		rc = (*m_pPortableClient)(EntityResource::getLink().upgradeLink())->DropOffDevice();
		if(rc == Error_Succeed) {
			if(preDev.devType == CAMTYPE_ENV) { //not skip to check!!!!
				WaitPortableReleaseCamera(CAMTYPE_ENV);
				AccessCamerePriviledge(false, CAMTYPE_ENV);
			} else {
				ClearPortScanHoldLimitedDevice(CAMTYPE_MAX);
			}
		}
		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;
}

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 = "无可用的摄像头或摄像头故障，请检查设备！";

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

void CScannerFSM::WaitPortableReleaseCamera(int nCameraType, DWORD dwTimeoutMilSec)
{
	const DWORD eachTimeElaspe = 300;
	int times = 0;
	while (times * eachTimeElaspe < dwTimeoutMilSec)
	{
		int state = 0;
		ErrorCodeEnum ec = Error_Succeed;
		ScannerDeviceInfo existed = {};
		ec = IsPortScanHoldDevice(&existed, state);
		if(existed.devType == nCameraType) {
			Sleep(eachTimeElaspe);
			times++;
		} else {
			break;
		}
	}
}

ErrorCodeEnum CScannerFSM::ConnectToMediaController()
{
	FreeMediaControllerClient();
	m_pMediaControlClient = new CMediaCtrlClient(GetEntityBase());
	ErrorCodeEnum erroCode = m_pMediaControlClient->Connect();
	if(FAILURED(erroCode)) {
		m_pMediaControlClient->SafeDelete();
		m_pMediaControlClient = NULL;
		LogWarn(Severity_Middle, Error_InvalidState, LOG_ERR_SCANNERSET_CONNECT_MEDIACONTRLLER_FAILED,
			CSimpleStringA::Format("Connect to mediacontroller entity failed: 0x%X", erroCode));
		return Error_InvalidState;
	}
	return Error_Succeed;
}


ErrorCodeEnum CScannerFSM::AccessCamerePriviledge(bool fWinOver, int nCameraType)
{
	CSimpleStringA strDevName = m_fixedCamera[nCameraType-1].strDevName;
	if(strDevName.IsNullOrEmpty() || strDevName == "$")
		return Error_Param;
	CSimpleStringA tmp = GetPrefixCameraName(strDevName);
	strDevName = tmp;
	ErrorCodeEnum result = HandleCamereAccessPriviledge(fWinOver, nCameraType, strDevName);
	if(!fWinOver) {
		ClearPortScanHoldLimitedDevice((CapTypeEnum)nCameraType);
	}
	return result;
}

ErrorCodeEnum CScannerFSM::HandleCamereAccessPriviledge(bool fWinOver, int nCameraType, const char* lpcszDevName)
{
#if defined(_MSC_VER)
	ErrorCodeEnum result = ConnectToMediaController();
	if(result == Error_Succeed) {
		MediaController::MediaService_ManipulateMediaDevice_Req req = {};
		MediaController::MediaService_ManipulateMediaDevice_Ans ans = {};
		req.cmdType = fWinOver ? 0 : 1;
		req.devType = nCameraType;
		req.reserved1 = 0;
		req.reserved2 = "";

		result = (*m_pMediaControlClient)(EntityResource::getLink().upgradeLink())->ManipulateMediaDevice(req, ans, 20 * 1000);
		if(result == Error_Succeed) {
			if(ans.retCode != 0) {
				result = Error_Unexpect;
			}
		}
		if(result != Error_Succeed) {
			LogWarn(Severity_Middle, result, LOG_ERR_SCANNERSET_MEDIACONTROLLER_MANIPULATE_FAILED,
				CSimpleStringA::Format("Manipulate media device failed: ec: %s, ret: %d", SpStrError(result), ans.retCode));
		}
	} else {
		EntityStateEnum state;
		result = GetMediaControllerInfo(state);
		if(result == Error_Succeed && IsNoralEntityState(state) && fWinOver) {
			result = Error_Resource;
		}
	}

	if(result != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s 0x%X", fWinOver ? "GetIt":"GiveUp", result);
	} else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s %s succ !", fWinOver ? "GetIt":"GiveUp",CameraTypeToString((CapTypeEnum)nCameraType));
	}
	return result;
#else
	return Error_NotSupport;
#endif //_MSC_VER

}

UINT CScannerFSM::UnitTest()
{
	ScannerDeviceInfo info;
	int nDevID = GetAdvancedScannerDevice(&info);
	return 0;
}

#if defined(RVC_OS_WIN)

GUID* StrToGUID(const WCHAR *guid_string)
{
	char buffer[64];
	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;
}

#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;
	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)) {
				if (0 == _stricmp(szName, strRootName.GetData())) {
					bHere = true;
				}
			} else {
				if (SetupDiGetDeviceRegistryProperty(
					hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
					if (0 == _stricmp(szName, strRootName.GetData())) {
						bHere = true;
					}
				}
			}
			if(bHere){
				if (SetupDiGetDeviceRegistryProperty(
					hDev, &DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FriendName: %s", szName);
						strRetrievedName = szName;
						bRet = !!(strRetrievedName.GetLength() > 0);
				}
				break;
			}
		}
		DeviceIndex++;
	}
	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev) {
		SetupDiDestroyDeviceInfoList(hDev);
	}

#endif //RVC_OS_WIN

	return bRet;
}

bool CScannerFSM::IsEwsCamera(LPCTSTR lpcszDevfriendlyName)
{
	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;

	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)) {
				if (!_stricmp(szName, m_strEwsRecordName.GetData())) {
					bHere = true;
				}
			} else {
				if (SetupDiGetDeviceRegistryProperty(
					hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
						if (!_stricmp(szName, m_strEwsRecordName.GetData())) {
							bHere = true;
						}
				}
			}
			if(bHere){
				if (SetupDiGetDeviceRegistryProperty(
					hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0)) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FriendName: %s", szName);
						if(!_stricmp(szName, lpcszDevfriendlyName)) {
							bRet = true;
						}
				}
				break;
			}
		}
		DeviceIndex++;
	}
	SetupDiDestroyClassImageList(&_spImageData);
	if(hDev) {
		SetupDiDestroyDeviceInfoList(hDev);
	}

#endif //RVC_OS_WIN

	return bRet;
}