myvtm/Module/mod_FingerPrint/FingerPrintFSM.cpp

#include "stdafx.h"
#include "FingerPrintFSM.h"
#include "EventCode.h"
#include "GetDevInfoHelper.h"
#include "fileutil.h"

#ifdef RVC_OS_WIN
#include <map>
#include "RVCComm.h"
#include "publicFunExport.h"
#else
#include <cstdio>
#include <thread>
#include <chrono>
#include <fstream>
#include <sys/stat.h>
#include <unistd.h>
#endif




#define FINGERPRINT_SCAN_TIMEOUT 15000
#define FINGERPRINT_GETFINGER_TIMEOUT 25000
#define FINGERPRINT_SCAN_INTERNAL 100
#define FINGERPRINT_MATCH_TIMEOUT 15000
#define MAX_FEATURE_LEN 1024
#define STANDARD_FEATURE_LEN 684




void CFingerPrintFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_devState = DEVICE_STATUS_NORMAL;

	if (!(m_csMachineType.Compare("RVC.PAD", true) == 0 && m_fwbSN.IsNullOrEmpty())) {
		ToLogWarnInfoAboutTerm();
	}
}

void CFingerPrintFSM::s0_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s0_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s0 evt %d", e->iEvt);
	switch(e->iEvt)
	{
		case USER_EVT_ERROR:
			{
				e->SetHandled();
			}
			break;
		case USER_EVT_QUIT:
			{
				e->SetHandled();
			}
			break;
		case USER_EVT_SCAN:
			{
				e->SetHandled();
				ScanEvent* pScanEvt = dynamic_cast<ScanEvent*>(e);
				ScanTask* pScanTask = new ScanTask(this);
				pScanTask->ctx = pScanEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pScanTask);
			}
			break;
		case USER_EVT_SCANEX:
			{
				e->SetHandled();
				ScanExEvent* pScanExEvt = dynamic_cast<ScanExEvent*>(e);
				ScanExTask* pScanExTask = new ScanExTask(this);
				pScanExTask->ctx = pScanExEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pScanExTask);
			}
			break;
		case USER_EVT_GETFINGER:
			{
				e->SetHandled();
				GetFingerEvent* getFingerEvt = dynamic_cast<GetFingerEvent*>(e);
				GetFingerTask* getFingerTask = new GetFingerTask(this);
				getFingerTask->ctx = getFingerEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(getFingerTask);
			}
			break;
		case USER_EVT_GENERATE_TEMPLATE:
			{
				e->SetHandled();
				GenerateTemplateEvent* gtEvt = dynamic_cast<GenerateTemplateEvent*>(e);
				GenerateTemplateTask* gtTask = new GenerateTemplateTask(this);
				gtTask->ctx = gtEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(gtTask);
			}
			break;
		case USER_EVT_CANCEL_SCAN:
			{
				e->SetHandled();
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s0 set cancel flag!");
				m_bCancelRegister = true;
			}
			break;
		case USER_EVT_MATCH:
			{
				e->SetHandled();
				MatchEvent* pMatchEvt = dynamic_cast<MatchEvent*>(e);
				MatchTask* pMatchTask = new MatchTask(this);
				pMatchTask->ctx = pMatchEvt->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pMatchTask);
			}
			break;
		case USER_EVT_FWB_OPEN_SUC:
			{
				e->SetHandled();
				ProcFWBReConnTask* task = new ProcFWBReConnTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			}
			break;
		case USER_EVT_FWB_OPEN_SUC_FINISHED:
			{
				e->SetHandled();
				return e->param1;
			}

		default:
			break;
	}
	return 0;
}

//Init
void CFingerPrintFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_devState = DEVICE_STATUS_NOT_READY;
	InitTask* task = new InitTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}

void CFingerPrintFSM::s4_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s4_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("s4_on_event")("s4 evt %d",pEvt->iEvt);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_ERROR:
		pEvt->SetHandled();
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_INIT_FINISHED:
		{
			pEvt->SetHandled();
			ret = pEvt->param1;
		}
		break;
	default:
		break;
	}
	return ret;
}


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

void CFingerPrintFSM::s1_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s1_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 evt(%d, %d)", e->iEvt, e->param1);
	int ret = 0;
	switch (e->iEvt)
	{
	case USER_EVT_SCAN_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_SCANEX_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_GETFINGER_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_GENERATE_TEMPLATE_FINISHED:
		e->SetHandled();
		ret = e->param1;
		break;
	case USER_EVT_CANCEL_SCAN:
		e->SetHandled();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 set cancel scan flag");
		m_bCancelRegister = true;
		break;
	case USER_EVT_EXIT:
		e->SetHandled();
		m_bExit = true;
		break;
	case USER_EVT_QUIT:
		e->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

void CFingerPrintFSM::s2_on_entry()
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FingerPrint entity failed.");
	m_devState = DEVICE_STATUS_FAULT;
	m_testResult = Error_InvalidState;
}

void CFingerPrintFSM::s2_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CFingerPrintFSM::s2_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s2 evt %d",e->iEvt);
	switch (e->iEvt)
	{
	case USER_EVT_QUIT:
		e->SetHandled();
		break;
	case USER_EVT_FWB_OPEN_SUC:
		{
			e->SetHandled();
			ProcFWBReConnTask* task = new ProcFWBReConnTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		}
		break;
	case USER_EVT_FWB_OPEN_SUC_FINISHED:
		{
			e->SetHandled();
			return e->param1;
		}
	}
	return 0;
}

void CFingerPrintFSM::s3_on_entry()
{
	LOG_FUNCTION();
}

void CFingerPrintFSM::s3_on_exit()
{
	LOG_FUNCTION();
}

unsigned CFingerPrintFSM::s3_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s3 evt %d,%d", e->iEvt, e->param1);

	switch (e->iEvt)
	{
	case USER_EVT_MATCH_FINISHED:
		{
			e->SetHandled();
			MatchFinishedEvent* matchFinishEvt = dynamic_cast<MatchFinishedEvent*>(e);
			if (matchFinishEvt->param1 == 0)
				matchFinishEvt->ctx->Answer(Error_Succeed);
			else
				matchFinishEvt->ctx->Answer((ErrorCodeEnum)matchFinishEvt->param1);
		}
		break;
	case USER_EVT_CANCEL_MATCH:
		{
			e->SetHandled();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s3 set cancel match flag");
			m_bCancelMatch = true;
		}
		break;
	case USER_EVT_EXIT:
		{
			e->SetHandled();
			m_bExit = true;
		}
		break;
	case USER_EVT_QUIT:
		{
			e->SetHandled();		
		}
		break;
	default:
		break;
	}
	return 0;
}



#pragma region entity init

ErrorCodeEnum CFingerPrintFSM::OnInit()
{
	CSystemStaticInfo sysInfo;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	WORD majorVersion = sysInfo.MachineVersion.GetMajor();
	WORD minorVersion = sysInfo.MachineVersion.GetMinor();
	m_machineVersion = CSimpleStringA::Format("%d.%d", majorVersion, minorVersion);
	m_terminalNo = sysInfo.strTerminalID;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("MachineType:%s, machineVersion:%s, terminalNo: %s",
		m_csMachineType.GetData(), m_machineVersion.GetData(), m_terminalNo.GetData()));

	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->LoadVendorLibName();
	return Error_Succeed;
}

int CFingerPrintFSM::Initial()
{
	LOG_FUNCTION();
	ErrorCodeEnum errDev;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	errDev = spEntityFunction->OpenConfig(Config_Root, spConfig);
	if (errDev != Error_Succeed)
	{
		SetErrPackage("Initial::OpenConfig", m_csDevSN, errDev, FingerPrint_UserErrorCode_OPEN_ROOT_FAILED_ONINIT);
		AlarmDEC();
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Open_ID).setResultCode("RTA2402")("指纹仪实体初始化时，打开root.ini文件失败");
		return 2;
	}

	spConfig->ReadConfigValue("Device.PinPad", "Version", m_version);
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", m_fwbSN);
	if (m_csMachineType.Compare("RVC.PAD", true) == 0 && m_fwbSN.IsNullOrEmpty())
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RVC.PAD without FWB");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹仪设备打开成功");
		return 0;
	}

	//TODO:device init
	int initCount = 0;
	ErrorCodeEnum err;
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	//判断是否是蓝牙多合一
	CSimpleStringA tmpVendor(""), tmpDLLVersion("");
	bool isFWB = false;
	CSimpleStringA tmpDevSN = m_fwbSN;
	GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", tmpVendor);
	GetEntityBase()->GetFunction()->GetSysVar("FWBVersion", tmpDLLVersion);

	if (tmpDLLVersion.GetLength() < 2)
		tmpDLLVersion = "8.1";
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("This is fwb device. DevSN:%s", tmpDevSN.GetData()));
		isFWB = true;
		m_csDevSN = tmpDevSN;
		VendorLibInfo tmpVendorLibInfo(GetEntityBase()->GetEntityName());
		tmpVendorLibInfo.strVendor = tmpVendor;
		CAutoArray<CSimpleStringA> dllVersions = tmpDLLVersion.Split('.');
		if (dllVersions.GetCount() >= 2) {
			tmpVendorLibInfo.strVersion = dllVersions[0];
			tmpVendorLibInfo.strBatch = dllVersions[1];
		}
		else {
			tmpVendorLibInfo.strVersion = tmpDLLVersion;
		}
		pEntity->vendorLibInfo = tmpVendorLibInfo;
	}
	BOOL triedFlag = FALSE;
	if (pEntity->vendorLibInfo.IsNotConfig()) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Not config the vendor at root.ini");
		CSimpleStringA strVendor(true);
		CSimpleStringA strVersion(true);
		CSimpleStringA strBatch(true);
		spConfig->ReadConfigValue("Device.PinPad", "Vendor", strVendor);
		spConfig->ReadConfigValue("Device.PinPad", "Version", strVersion);
		spConfig->ReadConfigValue("Device.PinPad", "Batch", strBatch);
		if (strVendor.IsNullOrEmpty() || strVersion.IsNullOrEmpty() || strBatch.IsNullOrEmpty()) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Some related node is not set, cannot continue.");
		}
		else {
			strBatch = "1";
			if (!strVendor.Compare("Hyosung", true)) {
				strVersion = "1";
			}
			else {
				if (!m_csMachineType.Compare("RVC.Stand2S", true)) {
					strVersion = "7";
					//TODO: Support new or old edition machine.
				}
				else if (!m_csMachineType.Compare("RVC.PAD", true)) {
					if (isFWB) {//蓝牙多合一
						GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", strVendor);
						strVersion = "8";
					}
					else if ((!strVendor.Compare("Nantian", true) || !strVendor.Compare("grg", true) || !strVendor.Compare("Yihua", true))
						&& !strVersion.Compare("4", true)) {
						strVersion = "4";
					}
					else
						strVersion = "1";
				}
				else if (!m_csMachineType.Compare("RVC.Desk2S", true)) {
					strVersion = "4";
					if (m_machineVersion.Compare("1.0", true)) {//低柜一体机(贵宾理财2.0&非贵宾理财2.1)
						strBatch = "20";
					}
				}
				else if (!m_csMachineType.Compare("RVC.Desk1S", true) && !m_machineVersion.Compare("1.0", true)) {//低柜一体机(厅堂自助)
					strVersion = "4";
					strBatch = "20";
				}
				else if (!m_csMachineType.Compare("RVC.CardStore", true)) {
					strVersion = "5";
				}
				else { //TODO:new machine
					strVersion = "1";
				}
			}
			VendorLibInfo tmpVendorLibInfo(GetEntityBase()->GetEntityName());
			tmpVendorLibInfo.strVendor = strVendor;
			tmpVendorLibInfo.strVersion = strVersion;
			tmpVendorLibInfo.strBatch = strBatch;
			pEntity->vendorLibInfo = tmpVendorLibInfo;
			triedFlag = !tmpVendorLibInfo.IsNotConfig();
		}
	}
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	LogWarn(Severity_Low, Error_Unexpect, FingerPrint_UserErrorCode_ROOT_INFO, m_adapterInfo.adapterFilePath.GetData());
	m_bOpened = false;
	if (pEntity->vendorLibInfo.IsNotConfig()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Not config, Allow this condition happend.");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("没有配置，将其视为指纹仪设备打开成功");
		return 0;
	}
	pEntity->InitializeVendorLogSwitch();
	err = m_hDevHelper.LoadUp(m_adapterInfo.adapterFilePath);
	if (!IS_SUCCEED(err))
	{
		if (err != Error_NotExist) { //文件存在，只是因为其他原因导致加载失败的
			LogWarn(Severity_High, Error_NotInit, FingerPrint_UserErrorCode_LOAD_ADAPTER_FAILED,
				CSimpleStringA::Format("Load library file: %s failed, GLE=%d", (LPCTSTR)m_adapterInfo.adapterFileName, GetLastError()));
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Open_ID).setResultCode("RTA2405")("加载厂商适配器失败");
			return 2;
		}
		else {
			if (!triedFlag) {//是在root.ini进行配置的，而不是程序推断的
				LogWarn(Severity_High, Error_DevLoadFileFailed, FingerPrint_UserErrorCode_VENDOR_ADAPTER_NOT_EXIST,
					CSimpleStringA::Format("library file: %s is not existed!", (LPCTSTR)m_adapterInfo.adapterFileName));
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Open_ID).setResultCode("RTA2404")("厂商适配器不存在dep中");
				return 2;
			}
			else {//程序推断出来的适配器名称，但本地不存在该文件，放弃吧
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Config programme,  Allow this condition happend.");
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("动态配置，没有该文件，放弃之");
				return 0;
			}
		}

	}
	ULLINT l_beginTime, l_endTime;
	do
	{
		l_beginTime = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->DevOpen(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		l_endTime = SP::Module::Comm::RVCGetTickCount();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(l_endTime - l_beginTime)("port: %d, baudrate: %d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		//DbgInfo("DevOpen", l_beginTime, l_endTime, err, CSimpleStringA::Format("port: %d, baudrate: %d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt()));
		if (err != Error_Succeed)
		{
			SetErrPackage("Initial::DevOpen", m_csDevSN, err, MEC_DEVAPI_FINGERPRINT_DevOpen);
			AlarmDEC();
			m_hDevHelper.TearDown();
			return 2;
		}
		m_bOpened = true;
		ToLogRootINIInfo();
	} while (false);
	ZeroMemory(m_devCatInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(m_devCatInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(m_devCatInfo.szVendor, MAX_DEV_VENDOR_LEN);

	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	err = m_hDevHelper->GetDevCategory(m_devCatInfo);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime)("GetDevCategory");
	if (err != Error_Succeed) {
		SetErrPackage("Initial::GetDevCategory", m_csDevSN, err, MEC_DEVAPI_FINGERPRINT_GetDevCategory);
		AlarmDEC();
		m_hDevHelper.TearDown();
		return 2;
	}

	m_adapterInfo.FulfillCategoryInfo(m_devCatInfo);
	m_bOpened = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FingerPrint entity open success.");
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹仪设备打开成功");
	return 0;
}

#pragma endregion

#pragma region entity exit

ErrorCodeEnum CFingerPrintFSM::OnExit()
{
	CSimpleStringA tmpDevSN("");
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("This is fwb device, DevSN:%s", tmpDevSN.GetData());
		return Error_Succeed;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("This is normal device.");
		if (m_hDevHelper != nullptr)
		{
			m_hDevHelper.TearDown();
			m_bOpened = false;
		}
		return Error_Succeed;
	}
}

#pragma endregion

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

#pragma region register interface - not use anymore in uos


#pragma endregion

#pragma region register interface - not use anymore in uos


#pragma endregion

#pragma region collect finger for register and match interface
//有用接口
int CFingerPrintFSM::GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFingerPrint_Req, FingerPrintService_GetFingerPrint_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Ans.reserved1.Init(10);
	if(!m_bOpened) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetFingerPrint return failed for device isn't init suc.");
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2410")("指纹扫描失败,设备还未初始化成功");
		ctx->Answer(Error_NotInit);  //maybe no vendor adapter
		return 0;
	}

	if (m_bCancelRegister) //no cancel button anymore while register
	{   //修复当扫描前已取消，需要把参数复制，否则授权实体会lost
		m_bCancelRegister = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹扫描失败,在扫描前,扫描已取消");
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2412")("指纹扫描失败,扫描已取消");
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Cancel);
		return 0;

		//ctx->Answer(Error_Cancel);
		//m_bCancelRegister = false;
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹扫描失败,在扫描前,扫描已取消");
		////DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2410")("指纹扫描失败,在扫描前,扫描已取消");
		//return 0;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("ctx->Req.times = %d", ctx->Req.times);
	//times = 10, for QueryAuthorInfo; 1-9, for Register
	if (ctx->Req.times <= 0 || ctx->Req.times > 10)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetFingerPrint, inParam is invalid:%d", ctx->Req.times);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2410")("指纹扫描失败,参数不对");
		ctx->Answer(Error_Param);
		return 0;
	}

	DWORD elapsed = 0;
	DWORD dwStart = SP::Module::Comm::RVCGetTickCount();
	DWORD dwEnd = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErr;
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	memset(lpbFeature, 0, sizeof(lpbFeature));
	int lpbLength = MAX_FEATURE_LEN;
	

	CSimpleStringA strPath;
	eErr = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	if(eErr != Error_Succeed)
	{
		delete[] lpbFeature;
		lpbFeature = NULL;
		
		SetErrPackage("GetFingerPrint::GetPath", m_csDevSN, eErr, FingerPrint_UserErrorCode_GET_DEP_PATH_FAILED_REGISTER);
		AlarmDEC();
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2410")("指纹扫描失败,获取dep路径失败");
		ctx->Answer(Error_Param);
		return 0;
	}

	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_ON, "FingerPrint warning on");
	m_bCancelRegister = false;

	CSimpleStringA fileName = CSimpleStringA::Format("finger%d.bmp", ctx->Req.times);
	strPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName.GetData());
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("<GetFingerPrint> imageName = %s", strPath.GetData());

	bool bGetFingerPrintSuc = false;
	bool bNotFindImage = false;
	bool bLenIsNotRight = false;
	bool bFeatureIsNull = false;
	bool bExit = false;
	ULLINT l_beginTime, l_endTime;
	
	while(elapsed < FINGERPRINT_GETFINGER_TIMEOUT && !m_bCancelRegister && !bGetFingerPrintSuc)
	{
		if (m_bExit)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Exit the process.");
			bExit = true;
			break;
		}
#ifdef RVC_OS_WIN
		Sleep(FINGERPRINT_SCAN_INTERNAL);
#else
		SLEEP(FINGERPRINT_SCAN_INTERNAL);
#endif
		lpbLength = MAX_FEATURE_LEN;
		l_beginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
		l_endTime = SP::Module::Comm::RVCGetTickCount();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("fileName:%s, lpbLength:%d", fileName.GetData(), lpbLength);
		//DbgInfo("Image2Feature", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("fileName:%s, lpbLength:%d", fileName.GetData(), lpbLength));

		if (eErr == Error_Succeed)
		{
#ifdef RVC_OS_WIN
			Sleep(200);//save image may be delayed some time, not must happen
			WIN32_FIND_DATA findData;
			if (FindFirstFileA((LPCTSTR)strPath, &findData) != INVALID_HANDLE_VALUE 
				&& lpbFeature != NULL && lpbLength == STANDARD_FEATURE_LEN)
			{
				ctx->Ans.imageName = fileName;
				lpbFeature[STANDARD_FEATURE_LEN] = '\0';
				ctx->Ans.feature = (LPCTSTR)lpbFeature;
				bGetFingerPrintSuc = true;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Image2Feature success.");
				break;
			}
			else if(FindFirstFileA((LPCTSTR)strPath, &findData) == INVALID_HANDLE_VALUE)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Cannot find the fingerprint image %s", fileName.GetData());
				bNotFindImage = true;
				break;
			}else if(lpbLength != STANDARD_FEATURE_LEN){
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("vendor returned feature length is not right.");
				bLenIsNotRight = true;
				break;
			}else{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Fingerprint feature is NULL.");
				bFeatureIsNull = true;
				break;
			}
#else
			SLEEP(200);
			if (ExistsFile(strPath)
				&& lpbFeature != NULL && lpbLength == STANDARD_FEATURE_LEN)
			{
				ctx->Ans.imageName = fileName;
				lpbFeature[STANDARD_FEATURE_LEN] = '\0';
				ctx->Ans.feature = (LPCTSTR)lpbFeature;
				bGetFingerPrintSuc = true;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Image2Feature success.");
				break;
			}
			else if (!ExistsFile(strPath))
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Cannot find the fingerprint image %s", fileName.GetData());
				bNotFindImage = true;
				break;
			}else if(lpbLength != STANDARD_FEATURE_LEN){
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("vendor returned feature length is not right.");
				bLenIsNotRight = true;
				break;
			}else{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Fingerprint feature is NULL.");
				bFeatureIsNull = true;
				break;
			}
#endif
		}else{
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("Invoke routine 'Image2Feature' failed which returned 0x%x(%s) while GetFingerPrint.", eErr, devErrInfo.szErrMsg);
		}
		dwEnd = SP::Module::Comm::RVCGetTickCount();
		elapsed = dwEnd - dwStart;
	}

	LogEvent(Severity_Middle, LOG_EVT_FINGERPRINT_GREEN_OFF, "FingerPrint warning off");
	m_bExit = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("elapse = %d", elapsed);

	bool bIsRegister = false;
	bIsRegister = (ctx->Req.times == 10) ? false : true;

	if (bGetFingerPrintSuc){
		ctx->Ans.reserved1[0] = 1;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID)("指纹仪扫描成功");
		ctx->Answer(Error_Succeed);
	}
	else if(m_bCancelRegister){
		m_bCancelRegister = false;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹扫描失败,扫描已取消");
		//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2412")("指纹扫描失败,扫描已取消");
		ctx->Ans.reserved1[0] = 3;
		ctx->Answer(Error_Succeed);
	}
	else if(elapsed >= FINGERPRINT_SCAN_TIMEOUT){
		m_bCancelRegister = false;
		ctx->Ans.reserved1[0] = 2;
		if (bIsRegister) {
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_Registe_Timeout, "register timeout");
		}else {
			LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_Match_Timeout, "match timeout");
		}
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2411")("指纹扫描失败,扫描超时");
		ctx->Answer(Error_Succeed);
	}
	//else if(m_bCancelRegister){
	//	m_bCancelRegister = false;
	//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2412")();
	//	ctx->Ans.reserved1[0] = 3;
	//	ctx->Answer(Error_Succeed);
	//}
	else{
		if(bNotFindImage){
			ctx->Ans.reserved1[0] = 7;
			if(bIsRegister){
				LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER, "not find fingerprint image in dep while register");
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_REGISTER);
			}
			else{
				if (PageType_Other == m_iInWhatPage) {
					LogError(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH, "not find fingerprint image in dep while match");
				}
				else {
					LogWarn(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH, "not find fingerprint image in dep while match");
				}
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_NO_IMAGE_IN_DEP_MATCH);
			}
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2416")("指纹扫描失败,采集接口调用成功，但未在dep中找到图片文件");
		}else if(bFeatureIsNull){
			ctx->Ans.reserved1[0] = 4;
			if(bIsRegister){
				LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER, "fingerprint feature is null while register");
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETFEATURE_FAILED_REGISTER);
			}else{
				if (PageType_Other == m_iInWhatPage) {
					LogError(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH, "fingerprint feature is null while match");
				}
				else {
					LogWarn(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH, "fingerprint feature is null while match");
				}
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_GETFEATURE_FAILED_MATCH);
			}
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2413")("指纹扫描失败,采集接口调用成功，但返回的特征值为空");
		}else if(bLenIsNotRight){
			ctx->Ans.reserved1[0] = 5;
			if(bIsRegister){
				LogWarn(Severity_Middle, Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT, "fingerprint feature len is not right while register");
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT);
			}else{
				if (PageType_Other == m_iInWhatPage) {
					LogError(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH, "fingerprint feature len is not right while match");
				}
				else {
					LogWarn(Severity_High, Error_Unexpect, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH, "fingerprint feature len is not right while match");
				}
				ctx->Answer(Error_Succeed, FingerPrint_UserErrorCode_FEATURELEN_ISNOTRIGHT_MATCH);
			}
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2414")("指纹扫描失败,返回的指纹特征长度错误");
		}else if(bExit){
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_REGISTER_FAILED, "Exit to homepage when register.");
			//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(FingerPrint_Scan_ID).setResultCode("RTA2415")("指纹扫描失败,手动Exit退出业务");
			ctx->Ans.reserved1[0] = 6;
			ctx->Answer(Error_Succeed);
		}
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return 0;
}

#pragma endregion

#pragma region generate template
//有用接口
int CFingerPrintFSM::GenerateTemplate(SpReqAnsContext<FingerPrintService_GenerateTemplate_Req, FingerPrintService_GenerateTemplate_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	
	if(!m_bOpened) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GenerateTemplate return failed for device isn't init suc.");
		ctx->Answer(Error_NotInit);  //maybe no vendor adapter
		return 0;
	}
	//可以去掉？？？
	if (m_bCancelRegister) //no cancel button anymore while register
	{
		ctx->Answer(Error_Cancel);
		m_bCancelRegister = false;
		return 0;
	}

	ErrorCodeEnum errCode;
	LPBYTE lpbTemplate = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;

	std::vector<CSimpleStringA> imagePaths;
	CSimpleStringA strPath;
	m_pEntity->GetFunction()->GetPath("Dep", strPath);

	for (int i = 0; i < ctx->Req.FingerIDList.GetCount(); ++i)
	{
		//char buf[8];
		//ZeroMemory(buf, 8);
		//_itoa(ctx->Req.FingerIDList[i], buf, 10);
		//CSimpleStringA tempStr = strPath + "\\" + "finger" + CSimpleStringA(buf) + ".bmp";
		CSimpleStringA tempStr = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "finger%d.bmp", strPath.GetData(), ctx->Req.FingerIDList[i]);
		imagePaths.push_back(tempStr);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("imageName:%s", imagePaths[i].GetData());
#ifdef RVC_OS_WIN		
		WIN32_FIND_DATA findData;
		if (FindFirstFileA((LPCTSTR)imagePaths[i], &findData) == INVALID_HANDLE_VALUE)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("image <%s> not exist.", imagePaths[i].GetData());
			DeleteBmp(BmpImage);
			ctx->Answer(Error_NoTarget);
			return 0;
		}
#else
		if (!ExistsFile(imagePaths[i]))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("image <%s> not exist.", imagePaths[i].GetData());
			DeleteBmp(BmpImage);
			ctx->Answer(Error_NoTarget);
			return 0;
		}
#endif		
	}

	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->Image2Template(imagePaths[0], imagePaths[1], imagePaths[2], lpbTemplate, lpbLength);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Template").setCostTime(l_endTime - l_beginTime)("lpbLength:%d", lpbLength);
	//DbgInfo("Image2Template", l_beginTime, l_endTime, errCode, CSimpleStringA::Format("lpbLength:%d", lpbLength));

	if (Error_Succeed == errCode)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Invoke routine 'Image2Template' success , template length is %d", lpbLength);
		if (lpbTemplate != NULL && lpbLength == STANDARD_FEATURE_LEN) {
			lpbTemplate[lpbLength] = '\0';
			ctx->Ans.templateFeature = (LPCTSTR)lpbTemplate;
		}
		else {
			CSimpleStringA errMsg = CSimpleStringA::Format("template is NULL or template length is not right(%d)", lpbLength);
			LogWarn(Severity_Middle, Error_Hardware, FingerPrint_UserErrorCode_REGISTER_FAILED, errMsg.GetData());
			errCode = Error_Unexpect;
		}
	}
	else {
		SetErrPackage("GenerateTemplate::Image2Template", m_csDevSN, errCode, MEC_DEVAPI_FINGERPRINT_Image2Template);
		AlarmDEC();
		errCode = Error_Unexpect;
	}

	DeleteBmp(BmpImage);
	if (errCode == Error_Succeed) {
		//DbgInfo("Image2Template success.");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(FingerPrint_Generate_Template_ID)("指纹仪模板生成成功");
		ctx->Answer(Error_Succeed);
	}
	else {
		SetErrPackage("generate template failed", m_csDevSN, Error_Unexpect, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
		AlarmDEC();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("指纹仪模板生成失败");
		ctx->Answer(errCode, FingerPrint_UserErrorCode_GETTEMPLATE_FAILED);
	}

	delete[] lpbTemplate;
	lpbTemplate = NULL;
	return 0;
}

#pragma endregion

#pragma region match - old interface


#pragma endregion

#pragma region common function

ErrorCodeEnum CFingerPrintFSM::GetDevCatInfo(DevCategoryInfo& devInfo)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("DevCatgoryInfo len:%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), strlen(m_devCatInfo.szVendor));
#ifdef RVC_OS_WIN
	strncpy_s(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN > strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN-1);
	strncpy_s(devInfo.szType, m_devCatInfo.szType, (MAX_DEV_TYPE_LEN > strlen(m_devCatInfo.szType)) ? strlen(m_devCatInfo.szType) : MAX_DEV_TYPE_LEN-1);
	strncpy_s(devInfo.szVendor, m_devCatInfo.szVendor, (MAX_DEV_VENDOR_LEN > strlen(m_devCatInfo.szVendor)) ? strlen(m_devCatInfo.szVendor) : MAX_DEV_VENDOR_LEN-1);
#else
	strncpy(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN > strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN-1);
	strncpy(devInfo.szType, m_devCatInfo.szType, (MAX_DEV_TYPE_LEN > strlen(m_devCatInfo.szType)) ? strlen(m_devCatInfo.szType) : MAX_DEV_TYPE_LEN-1);
	strncpy(devInfo.szVendor, m_devCatInfo.szVendor, (MAX_DEV_VENDOR_LEN > strlen(m_devCatInfo.szVendor)) ? strlen(m_devCatInfo.szVendor) : MAX_DEV_VENDOR_LEN-1);
#endif // RVC_OS_WIN

	return Error_Succeed;
}

ErrorCodeEnum CFingerPrintFSM::GetDevState(int& state)
{
	ErrorCodeEnum errCode;
	state = 0;
	if (!m_bOpened) {
		return Error_Succeed;
	}
	CSimpleStringA fileName = "testFinger.bmp";
	LPBYTE lpbFeature = new BYTE[MAX_FEATURE_LEN];
	int lpbLength = MAX_FEATURE_LEN;
	ULLINT l_beginTime, l_endTime;
	l_beginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
	l_endTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("GetDevState:%d",state);

	if (errCode == Error_Succeed)
	{
		state = 1;
		DeleteBmp(TestImage);
	}
	delete[] lpbFeature;
	lpbFeature = NULL;
	return Error_Succeed;
}

void CFingerPrintFSM::DeleteBmp(int type)
{
	if ((type & BmpImage) == BmpImage)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to delete fingerprint images...");
		CSimpleStringA imageName;
		DeleteFileIfExisted("finger.bmp");
		for (int i = 1; i <= 10; ++i) {
			imageName = CSimpleString::Format("finger%d.bmp", i);
			DeleteFileIfExisted(imageName.GetData());
		}
	}
	if ((type & TestImage) == TestImage)
	{
		DeleteFileIfExisted("testFinger.bmp");
	}
}

ErrorCodeEnum CFingerPrintFSM::DeleteFileIfExisted(const char* fileName)
{
	if (strlen(fileName) == 0 || strchr(fileName, (int)'*') != NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Invalid or empty filename(%s)", fileName);
		return Error_Param;
	}
	CSimpleStringA strPath, strObjPath;
	ErrorCodeEnum errCode = m_pEntity->GetFunction()->GetPath("Dep", strPath);
	strObjPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName);
#ifdef RVC_OS_WIN
	WIN32_FIND_DATA findData;
	if (FindFirstFileA((LPCTSTR)strObjPath, &findData) != INVALID_HANDLE_VALUE)
	{
		if (DeleteFileA((LPCTSTR)strObjPath) != 0)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFile(%s) failed LastError(%s).", strObjPath.GetData(), GetLastError());
			return Error_Unexpect;
		}
	}
	if (GetLastError() == ERROR_FILE_NOT_FOUND)
	{
		return Error_Succeed;
	}
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFle(%s) Unexpect GetLastError(%s).", strObjPath.GetData(), GetLastError());
	return Error_Unexpect;
#else
	if (ExistsFileA(strObjPath))
	{
		if (RemoveFileA(strObjPath))
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("DeleteFile(%s) success.", strObjPath.GetData());
			return Error_Succeed;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("DeleteFile(%s) failed LastError(%d).", strObjPath.GetData(), errno);
			return Error_Unexpect;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("file %s not exist.", fileName);
		return Error_Succeed;
	}
#endif
}


int CFingerPrintFSM::ProcFWBReConn()
{
	if (m_hDevHelper != nullptr)
	{
		if (GetDevInitFlag()) {
			m_bOpened = false;
		}
		m_hDevHelper.TearDown();
	}
	return 0;
}

#pragma endregion