myvtm/Module/mod_MaintainWatcher/ConsoleFSM.cpp

#include "stdafx2.h"
#include "ConsoleFSM.h"
#include "windows.h"
#include "..\EventCode.h"
#include "MaintainWatcher_server_g.h"
#include "tlhelp32.h"

#define OP_START_ENTITY		1
#define OP_STOP_ENTITY		0

#define USB_NONE    0
#define USB_INSERT  1
#define USB_PULLOUT 2

#pragma comment(lib, "setupapi.lib")
#include "Dbt.h"
#include <stdio.h>
#include <stdlib.h>
#include <setupapi.h> 

HANDLE	hDetectMutex = NULL;//only one functioning detector in a single OS 
HWND	hDetectWnd	 = NULL;
HANDLE  hDetectThread = NULL;
HDEVNOTIFY hDevNotify = NULL;
DWORD g_USBStatus = USB_NONE; //USB状态值，0：无状态；1：USB插入；2：USB拔出 
BOOL g_FindUsbHdset = FALSE;
BOOL g_FindUsbCamera = FALSE;
BOOL g_FindEwsCamera = FALSE;
char g_UsbHdsetName[MAX_PATH] = {0};
char g_UsbCameraName[MAX_PATH] = {0};
char g_UkeyName[MAX_PATH] = {0};
BOOL g_FindKey = FALSE;
BOOL g_FindUkey = FALSE;
BOOL g_bErrStatus = FALSE; //是否处于错误状态 0：不在；1：在
BOOL g_bWorkingStatus = FALSE; //上一个状态是否处于业务状态，0：不处于；1：处于
//string g_UsbCameraName;
BOOL g_HasVerifyTask = FALSE;
USBKEY_INFO g_USBKeyInfo; //Ukey信息
int g_nSurveillanceRecordAllowed;//是否使用广角摄像头，0：不使用；1：使用
CSimpleStringA g_strEwsCameraID;//广角摄像头设备示例ID

using namespace MaintainWatcher;
class ConsoleFSM;

#define MAX_MEDIA_DEVICE_NUM 10 //最大的音视频设备个数
#define USB_IMAGE_DEVICE  L"{6BDD1FC6-810F-11D0-BEC7-08002BE2092F}" //Audio and video devices 类GUID
#define USB_MEDIA_DEVICE  L"{4D36E96C-E325-11CE-BFC1-08002BE10318}" //Cameras and scanners 类GUID
#define NEWUSB_IMAGE_DEVICE  L"{CA3E7AB9-B4C3-4AE6-8251-579EF933890F}" //新增一类摄像头GUID，add zl 20190428


#define  DETECT_TEMPLATE_MW21 "USB\\VID_04B4&PID_1234"   //MW21  SmartCardReader
#define  DETECT_TEMPLATE_GD31 "USB\\VID_096E&PID_0005"   //GD31  SmartCardReader
#define  DETECT_TEMPLATE_GD33 "USB\\VID_096E&PID_A010"   //GD33  HIDClass
#define  DETECT_TEMPLATE_MW23 "USB\\VID_1483&PID_C007"   //MW23  HIDClass
#define  DETECT_TEMPLATE_GD35 "USB\\VID_05E3&PID_0723"   //GD35

#define  DETECT_TEMPLATE_TDR61_1 "USB\\VID_1780&PID_0490"   //TDR61
#define  DETECT_TEMPLATE_TDR61_2 "USB\\VID_1780&PID_0491"   //TDR61
#define  DETECT_TEMPLATE_TDR61_3 "USB\\VID_1780&PID_0492"   //TDR61
#define  DETECT_TEMPLATE_TDR61_4 "USB\\VID_1780&PID_0493"   //TDR61
#define  DETECT_TEMPLATE_FT62  "USB\\VID_096E&PID_0708"  //FT62
#define  DETECT_TEMPLATE_WD63  "USB\\VID_163C&PID_0704"     //WD63

// 增加三种新的OTP KEY类型 add by wr 20130731
#define  DETECT_TEMPLATE_TDR81  "USB\\VID_1780&PID_049A"   //TDR81
#define  DETECT_TEMPLATE_FT82  "USB\\VID_096E&PID_0310"    //FT82
#define  DETECT_TEMPLATE_WD83  "USB\\VID_163C&PID_0708"    //WD83

// 增加三种新的NFC KEY类型 add by wr 20150618
#define  DETECT_TEMPLATE_TDR91  "USB\\VID_1780&PID_049B"    //TDR91
#define  DETECT_TEMPLATE_WDC92  "USB\\VID_1EA8&PID_C005"    //WDC92
#define  DETECT_TEMPLATE_WD93  "USB\\VID_163C&PID_0709"    //WD93

// 增加三种新的一代KEY类型 add by wr 20160322
#define  DETECT_TEMPLATE_FT24  "USB\\VID_096E&PID_031B"    //FT24
// add by wr 20160328
#define  DETECT_TEMPLATE_WD25  "USB\\VID_163C&PID_070A"    //WD25

#define UKEY_NUMBER 19
string g_UkeyIDList[UKEY_NUMBER]=
{DETECT_TEMPLATE_MW21,
DETECT_TEMPLATE_GD31,
DETECT_TEMPLATE_GD33,
DETECT_TEMPLATE_MW23,
DETECT_TEMPLATE_GD35,
DETECT_TEMPLATE_TDR61_1,
DETECT_TEMPLATE_TDR61_2,
DETECT_TEMPLATE_TDR61_3,
DETECT_TEMPLATE_TDR61_4,
DETECT_TEMPLATE_FT62,
DETECT_TEMPLATE_WD63,
DETECT_TEMPLATE_TDR81,
DETECT_TEMPLATE_FT82,
DETECT_TEMPLATE_WD83,
DETECT_TEMPLATE_TDR91,
DETECT_TEMPLATE_WDC92,
DETECT_TEMPLATE_WD93,
DETECT_TEMPLATE_FT24,
DETECT_TEMPLATE_WD25};

typedef struct 
{
	char cDeviceName[MAX_PATH];
}DEVICE_INFO, *PDEVICE_INFO;

DEVICE_INFO g_FixedAudioDeviceName[MAX_MEDIA_DEVICE_NUM] = {0};
DEVICE_INFO g_FixedImageDeviceName[MAX_MEDIA_DEVICE_NUM] = {0};
unsigned int g_FixedAudioDeviceNum = 0;
unsigned int g_FixedImageDeviceNum = 0;

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

DWORD FindSubStr(const char* source, const char* target)
{    
	unsigned int i,j; 

	if (strlen(source) < strlen(target))
	{
		return -1;
	}

	if (1 == strlen(source) 
		&& 1== strlen(target)
		&& source[0] == target[0])
	{
		return 0;
	}

	for (i = 0;i<=strlen(source)-strlen(target);i++)    
	{        
		if (source[i]==target[0])        
		{            
			for (j = 1;j<=strlen(target);j++)            
			{                
				if (source[i+j]!=target[j])                    
					break;            
			}

			if ((j == strlen(target))
				|| (j == strlen(target)+1))
			{                
				return i;                       
			} 

			j = 0;        
		}    
	}    

	return -1;
}

//判断当前设备是否是内置音频设备，说明：实体启动时检测到得音频设备都认为是内置音频设备
BOOL IsFixedMediaDevice(const char* pDeviceName)
{
	int nCount = g_FixedAudioDeviceNum;
	for (int i=0; i<nCount; i++)
	{
		if (0 == strcmp(g_FixedAudioDeviceName[i].cDeviceName, pDeviceName))
		{
			return TRUE;
		}
	}

	return FALSE;
}

BOOL IsFixedImageDevice(const char* pDeviceName)
{
	int nCount = g_FixedImageDeviceNum;
	for (int i=0; i<nCount; i++)
	{
		if (0 == strcmp(g_FixedImageDeviceName[i].cDeviceName, pDeviceName))
		{
			return TRUE;
		}
	}

	return FALSE;
}

//判断是否是高拍仪
bool 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;
}

//获取耳机个数
unsigned int GetMediaDeviceNum()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	unsigned int nDeviceNum = 0;
	GUID mediaGuid = *StrToGUID(L"{4D36E96C-E325-11CE-BFC1-08002BE10318}");//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&mediaGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return 0;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				nDeviceNum++;
				DeviceIndex++;
				Dbg("第[%d]个音视频设备，设备名[%s]",nDeviceNum, szName);
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					nDeviceNum++;
					DeviceIndex++;
					Dbg("第[%d]个音视频设备，设备描述名[%s]",nDeviceNum, szName);
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return nDeviceNum;
}

//获取摄像头个数
//unsigned int GetImageDeviceNum()
//{
//	DWORD dwErrCode = ERROR_SUCCESS;
//	unsigned int nDeviceNum = 0;
//	GUID devcieGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices
//
//	HDEVINFO hDev = SetupDiGetClassDevs(&devcieGuid, NULL, NULL, DIGCF_PRESENT);
//	if(INVALID_HANDLE_VALUE == hDev)
//	{
//		dwErrCode = GetLastError();
//		return 0;
//	}
//
//	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))
//	{
//		char szBuf[MAX_PATH] = {0};
//		int wImageIdx = 0;
//		short wItem = 0;
//		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
//		{
//			DeviceIndex++;
//			continue;
//		}
//
//		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
//		{
//			char szName[MAX_PATH] = {0};		
//
//			//先获取获取设备名
//			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_HARDWAREID, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
//			{
//				nDeviceNum++;
//				DeviceIndex++;
//				Dbg("第[%d]个摄像头，设备名[%s]",nDeviceNum, szName);
//				continue;
//			}
//			else
//			{
//				//如果无法获取设备名，则获取设备描述名
//				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//				{
//					nDeviceNum++;
//					DeviceIndex++;
//					Dbg("第[%d]个摄像头，设备描述名[%s]",nDeviceNum, szName);
//					continue;
//				}
//			}	
//		}
//
//		DeviceIndex++;
//	}
//
//	SetupDiDestroyClassImageList(&_spImageData);
//
//	if(hDev)
//	{
//		SetupDiDestroyDeviceInfoList(hDev);
//	}
//
//	return nDeviceNum;
//}

unsigned int GetImageDeviceNum()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	unsigned int nDeviceNum = 0;
	GUID devcieGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&devcieGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return 0;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};		

			//先获取获取设备名
			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_HARDWAREID, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
			{
				nDeviceNum++;
				DeviceIndex++;
				Dbg("第[%d]个摄像头，设备名[%s]",nDeviceNum, szName);
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					nDeviceNum++;
					DeviceIndex++;
					Dbg("第[%d]个摄像头，设备描述名[%s]",nDeviceNum, szName);
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	//add by zl 20190510,增加新一类外界摄像头支持
	devcieGuid = *StrToGUID(NEWUSB_IMAGE_DEVICE);//Audio and video devices

	hDev = SetupDiGetClassDevs(&devcieGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return 0;
	}
	
	ZeroMemory(&_spImageData,sizeof(SP_CLASSIMAGELIST_DATA));
	_spImageData.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
	SetupDiGetClassImageList(&_spImageData);

	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	
	DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};		

			//先获取获取设备名
			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_HARDWAREID, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
			{
				nDeviceNum++;
				DeviceIndex++;
				Dbg("第[%d]个摄像头，设备名[%s]",nDeviceNum, szName);
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					nDeviceNum++;
					DeviceIndex++;
					Dbg("第[%d]个摄像头，设备描述名[%s]",nDeviceNum, szName);
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}


	return nDeviceNum;
}

//获取高拍仪个数
unsigned int GetPortableScannerNum()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	unsigned int nDeviceNum = 0;
	GUID devcieGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&devcieGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return 0;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};		

			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{				
				BOOL bUpstair = FALSE;
				if (IsPortableScannerDetected(szName, bUpstair))
				{				
					nDeviceNum++;
					DeviceIndex++;
					Dbg("第[%d]个高拍仪，FRIENDLYNAME[%s]",nDeviceNum, szName);
					continue;
				}											
			}					
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return nDeviceNum;
}

//查找USB耳机
BOOL FindNewMediaDevice(char** pDeviceName)
{
	if (NULL == pDeviceName)
	{
		return FALSE;
	}

	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID mediaGuid = *StrToGUID(L"{4D36E96C-E325-11CE-BFC1-08002BE10318}");//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&mediaGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};
	
			//先获取获取设备名
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				if (IsFixedMediaDevice(szName))
				{
					//如果是内置音频设备则继续找下一个
					DeviceIndex++;
					continue;
				}
				memcpy((void*)g_UsbHdsetName, szName, MAX_PATH);
				memcpy(*pDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				break;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					if (IsFixedMediaDevice(szName))
					{
						//如果是内置音频设备则继续找下一个
						DeviceIndex++;
						continue;
					}
					memcpy((void*)g_UsbHdsetName, szName, MAX_PATH);
					memcpy(*pDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					break;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找摄像头
//BOOL FindNewImageDevice(char** pDeviceName)
//{
//	if (NULL == pDeviceName)
//	{
//		return FALSE;
//	}
//
//	DWORD dwErrCode = ERROR_SUCCESS;
//	BOOL bFind = FALSE;
//	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices
//
//	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
//	if(INVALID_HANDLE_VALUE == hDev)
//	{
//		dwErrCode = GetLastError();
//		return FALSE;
//	}
//
//	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))
//	{
//		char szBuf[MAX_PATH] = {0};
//		int wImageIdx = 0;
//		short wItem = 0;
//		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
//		{
//			DeviceIndex++;
//			continue;
//		}
//
//		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
//		{
//			char szName[MAX_PATH] = {0};
//			char szFriendlyName[MAX_PATH] = {0};
//
//			//add by zl 20171109 如果是高拍仪，直接返回不处理
//			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szFriendlyName, MAX_PATH - 1, 0))
//			{
//				BOOL bUpstair = FALSE;
//				if (IsPortableScannerDetected(szFriendlyName, bUpstair))
//				{
//					DeviceIndex++;
//					continue;
//				}
//			}
//
//			//先获取获取设备名
//			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
//			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//			{
//				if (IsFixedImageDevice(szName))
//				{
//					//如果是内置音频设备则继续找下一个
//					DeviceIndex++;
//					continue;
//				}
//
//				memset((void*)g_UsbCameraName, 0, MAX_PATH);
//				memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
//				memcpy(*pDeviceName, szName, MAX_PATH);
//				bFind = TRUE;
//				break;
//			}
//			else
//			{
//				//如果无法获取设备名，则获取设备描述名
//				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//				{
//					if (IsFixedImageDevice(szName))
//					{
//						//如果是内置音频设备则继续找下一个
//						DeviceIndex++;
//						continue;
//					}
//					memset((void*)g_UsbCameraName, 0, MAX_PATH);
//					memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
//					memcpy(*pDeviceName, szName, MAX_PATH);
//					bFind = TRUE;
//					break;
//				}
//			}	
//		}
//
//		DeviceIndex++;
//	}
//
//	SetupDiDestroyClassImageList(&_spImageData);
//
//	if(hDev)
//	{
//		SetupDiDestroyDeviceInfoList(hDev);
//	}
//
//	return bFind;
//}

//查找新的广角摄像头
BOOL FindNewImageDevice(char** pDeviceName)
{
	if (NULL == pDeviceName)
	{
		return FALSE;
	}

	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};
			char szFriendlyName[MAX_PATH] = {0};

			//add by zl 20171109 如果是高拍仪，直接返回不处理
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szFriendlyName, MAX_PATH - 1, 0))
			{
				BOOL bUpstair = FALSE;
				if (IsPortableScannerDetected(szFriendlyName, bUpstair))
				{
					DeviceIndex++;
					continue;
				}
			}

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				if (IsFixedImageDevice(szName))
				{
					//如果是内置音频设备则继续找下一个
					DeviceIndex++;
					continue;
				}

				memset((void*)g_UsbCameraName, 0, MAX_PATH);
				memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
				memcpy(*pDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				break;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					if (IsFixedImageDevice(szName))
					{
						//如果是内置音频设备则继续找下一个
						DeviceIndex++;
						continue;
					}
					memset((void*)g_UsbCameraName, 0, MAX_PATH);
					memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
					memcpy(*pDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					break;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	if (bFind)
	{
		return TRUE;
	}

	//add by zl 20190510,增加新一类外界摄像头支持
	deviceGuid = *StrToGUID(NEWUSB_IMAGE_DEVICE);//Audio and video devices

	hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	ZeroMemory(&_spImageData, sizeof(SP_CLASSIMAGELIST_DATA));
	_spImageData.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
	SetupDiGetClassImageList(&_spImageData);

	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};
			char szFriendlyName[MAX_PATH] = {0};

			//add by zl 20171109 如果是高拍仪，直接返回不处理
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szFriendlyName, MAX_PATH - 1, 0))
			{
				BOOL bUpstair = FALSE;
				if (IsPortableScannerDetected(szFriendlyName, bUpstair))
				{
					DeviceIndex++;
					continue;
				}
			}

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				if (IsFixedImageDevice(szName))
				{
					//如果是内置音频设备则继续找下一个
					DeviceIndex++;
					continue;
				}

				memset((void*)g_UsbCameraName, 0, MAX_PATH);
				memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
				memcpy(*pDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				break;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					if (IsFixedImageDevice(szName))
					{
						//如果是内置音频设备则继续找下一个
						DeviceIndex++;
						continue;
					}
					memset((void*)g_UsbCameraName, 0, MAX_PATH);
					memcpy((void*)g_UsbCameraName, szName, MAX_PATH);
					memcpy(*pDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					break;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找新的广角摄像头
BOOL FindNewEwsCamera()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				if (IsFixedImageDevice(szName))
				{
					//如果是内置音频设备则继续找下一个
					DeviceIndex++;
					continue;
				}

				if (0 == _stricmp(szName, g_strEwsCameraID.GetData()))
				{
					bFind = TRUE;
					break;
				}
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					if (IsFixedImageDevice(szName))
					{
						//如果是内置音频设备则继续找下一个
						DeviceIndex++;
						continue;
					}

					if (0 == _stricmp(szName, g_strEwsCameraID.GetData()))
					{
						bFind = TRUE;
						break;
					}
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找指定的USB耳机
BOOL FindMyMediaDevice(const char* pDeviceName)
{
	if (NULL == pDeviceName)
	{
		return FALSE;
	}

	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID mediaGuid = *StrToGUID(L"{4D36E96C-E325-11CE-BFC1-08002BE10318}");//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&mediaGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				if (0 == strcmp(pDeviceName, (const char*)szName))
				{
					bFind = TRUE;	
				}		
				
				break;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					if (0 == strcmp(pDeviceName, (const char*)szName))
					{
						bFind = TRUE;	
					}

					break;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找指定的摄像头
BOOL FindMyImageDevice(const char* pDeviceName)
{
	if (NULL == pDeviceName)
	{
		Dbg("pDeviceName is null");
		return FALSE;
	}

	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		Dbg("SetupDiGetClassDevs failed");
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			Dbg("SetupDiGetDeviceRegistryPropertyA failed");
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				Dbg("DeviceInstanceId[%s]",szName);
				if (0 == strcmp(pDeviceName, (const char*)szName))
				{
					bFind = TRUE;
					break;
				}					
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					Dbg("SPDRP_DEVICEDESC[%s]",szName);
					if (0 == strcmp(pDeviceName, (const char*)szName))
					{
						bFind = TRUE;
						break;
					}					
				}
				else
				{
					Dbg("找不到此设备示例ID和设备描述名");
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	if (bFind)
	{
		return TRUE;
	}

	//add by zl 20190510,增加新一类外界摄像头支持
	deviceGuid = *StrToGUID(NEWUSB_IMAGE_DEVICE);//Audio and video devices

	hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		Dbg("SetupDiGetClassDevs failed");
		dwErrCode = GetLastError();
		return FALSE;
	}

	ZeroMemory(&_spImageData, sizeof(SP_CLASSIMAGELIST_DATA));
	_spImageData.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
	SetupDiGetClassImageList(&_spImageData);

	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			Dbg("SetupDiGetDeviceRegistryPropertyA failed");
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				Dbg("DeviceInstanceId[%s]",szName);
				if (0 == strcmp(pDeviceName, (const char*)szName))
				{
					bFind = TRUE;
					break;
				}					
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					Dbg("SPDRP_DEVICEDESC[%s]",szName);
					if (0 == strcmp(pDeviceName, (const char*)szName))
					{
						bFind = TRUE;
						break;
					}					
				}
				else
				{
					Dbg("找不到此设备示例ID和设备描述名");
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找内置音频设备
BOOL FindFixedMediaDevice()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID mediaGuid = *StrToGUID(L"{4D36E96C-E325-11CE-BFC1-08002BE10318}");//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&mediaGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				g_FixedAudioDeviceNum++;
				memcpy((void*)g_FixedAudioDeviceName[g_FixedAudioDeviceNum-1].cDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				DeviceIndex++;
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					g_FixedAudioDeviceNum++;
					memcpy((void*)g_FixedAudioDeviceName[g_FixedAudioDeviceNum-1].cDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					DeviceIndex++;
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找内置摄像头
BOOL FindFixedImageDevice()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices

	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	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))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				g_FixedImageDeviceNum++;
				memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				DeviceIndex++;
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					g_FixedImageDeviceNum++;
					memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					DeviceIndex++;
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	//add by zl 20190510,增加新一类外界摄像头支持
	deviceGuid = *StrToGUID(NEWUSB_IMAGE_DEVICE);//Audio and video devices

	hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		dwErrCode = GetLastError();
		return FALSE;
	}

	ZeroMemory(&_spImageData, sizeof(SP_CLASSIMAGELIST_DATA));
	_spImageData.cbSize = sizeof(SP_CLASSIMAGELIST_DATA);
	SetupDiGetClassImageList(&_spImageData);

	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
		{
			DeviceIndex++;
			continue;
		}

		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
		{
			char szName[MAX_PATH] = {0};

			//先获取获取设备名
			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
				//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
			{
				g_FixedImageDeviceNum++;
				memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
				bFind = TRUE;
				DeviceIndex++;
				continue;
			}
			else
			{
				//如果无法获取设备名，则获取设备描述名
				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
				{
					g_FixedImageDeviceNum++;
					memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
					bFind = TRUE;
					DeviceIndex++;
					continue;
				}
			}	
		}

		DeviceIndex++;
	}

	SetupDiDestroyClassImageList(&_spImageData);

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//BOOL FindFixedImageDevice()
//{
//	DWORD dwErrCode = ERROR_SUCCESS;
//	BOOL bFind = FALSE;
//	GUID deviceGuid = *StrToGUID(USB_IMAGE_DEVICE);//Audio and video devices
//
//	HDEVINFO hDev = SetupDiGetClassDevs(&deviceGuid, NULL, NULL, DIGCF_PRESENT);
//	if(INVALID_HANDLE_VALUE == hDev)
//	{
//		dwErrCode = GetLastError();
//		return FALSE;
//	}
//
//	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))
//	{
//		char szBuf[MAX_PATH] = {0};
//		int wImageIdx = 0;
//		short wItem = 0;
//		if (!SetupDiGetDeviceRegistryPropertyA(hDev, &DevInfo, SPDRP_CLASS, NULL, (PBYTE)szBuf, MAX_PATH, 0))
//		{
//			DeviceIndex++;
//			continue;
//		}
//
//		if (SetupDiGetClassImageIndex(&_spImageData, &DevInfo.ClassGuid, &wImageIdx))
//		{
//			char szName[MAX_PATH] = {0};
//
//			//先获取获取设备名
//			if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
//			//if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_FRIENDLYNAME, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//			{
//				g_FixedImageDeviceNum++;
//				memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
//				bFind = TRUE;
//				DeviceIndex++;
//				continue;
//			}
//			else
//			{
//				//如果无法获取设备名，则获取设备描述名
//				if (SetupDiGetDeviceRegistryProperty(hDev,&DevInfo, SPDRP_DEVICEDESC, NULL, (PBYTE)szName, MAX_PATH - 1, 0))
//				{
//					g_FixedImageDeviceNum++;
//					memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum-1].cDeviceName, szName, MAX_PATH);
//					bFind = TRUE;
//					DeviceIndex++;
//					continue;
//				}
//			}	
//		}
//
//		DeviceIndex++;
//	}
//
//	SetupDiDestroyClassImageList(&_spImageData);
//
//	if(hDev)
//	{
//		SetupDiDestroyDeviceInfoList(hDev);
//	}
//
//	return bFind;
//}

//查找被拔出的摄像头
BOOL FindOutputImageDevice(char* pDeviceName)
{
	if (NULL == pDeviceName)
	{
		return FALSE;
	}

	for (unsigned int i=0; i<g_FixedImageDeviceNum; i++)
	{
		if (FindMyImageDevice(g_FixedImageDeviceName[i].cDeviceName))
		{
			continue;
		}
		else
		{
			memcpy(pDeviceName,g_FixedImageDeviceName[i].cDeviceName,MAX_PATH);
			return TRUE;
		}
	}

	return FALSE;
}

//检测是否插入专业版UKEY
BOOL FindUkey()
{
	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;
	HDEVINFO hDev = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		Dbg("SetupDiGetClassDevs failed");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_UKEY,
			GetOutPutStr("%s%d","SetupDiGetClassDevs",hDev).c_str());
		dwErrCode = GetLastError();
		return FALSE;
	}

	SP_DEVINFO_DATA DevInfo;
	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DWORD DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		char szName[MAX_PATH] = {0};

		//获取获取设备示例ID
		if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
		{
			//Dbg("DeviceInstanceId[%s]",szName);
			for (int i=0; i<UKEY_NUMBER; i++)
			{
				if (-1 != FindSubStr(szName, g_UkeyIDList[i].c_str()))
				{
					Dbg("find UKey[%s]",g_UkeyIDList[i].c_str());
					string DebugInfoStr = "find u key,id is" + g_UkeyIDList[i] + ".";
					memset((void*)g_UkeyName, 0, MAX_PATH);
					memcpy((void*)g_UkeyName, szName, MAX_PATH);

					if(hDev)
					{
						SetupDiDestroyDeviceInfoList(hDev);
					}

					return TRUE;
				}
			}		
		}
		else
		{			
			Dbg("找不到此USB设备的实例ID");
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_UKEY_GET_INSTANCEID,
				GetOutPutStr("%s%s", "SetupDiGetDeviceInstanceId", "False").c_str());
		}	

		DeviceIndex++;
	}

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

//查找指定的专业版UKEY
BOOL FindTheUkey(const char* pUkeyID)
{
	if (NULL == pUkeyID)
	{
		Dbg("pUkeyID is null");
		LogWarn(Severity_Low,Error_Unexpect,ERR_MAINTAINWATCHER_THE_UKEY,
			GetOutPutStr("%s%s", "pUkeyID", "NULL").c_str());
		return FALSE;
	}
	DWORD dwErrCode = ERROR_SUCCESS;
	BOOL bFind = FALSE;

	HDEVINFO hDev = SetupDiGetClassDevs(NULL, NULL, NULL, DIGCF_PRESENT|DIGCF_ALLCLASSES);
	if(INVALID_HANDLE_VALUE == hDev)
	{
		Dbg("SetupDiGetClassDevs failed");
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_THE_UKEY, 
			GetOutPutStr("%s%d", "SetupDiGetClassDevs", hDev).c_str());
		dwErrCode = GetLastError();
		return FALSE;
	}

	SP_DEVINFO_DATA DevInfo;
	ZeroMemory(&DevInfo, sizeof(SP_DEVINFO_DATA));
	DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
	DWORD DeviceIndex = 0;

	while(SetupDiEnumDeviceInfo(hDev, DeviceIndex, &DevInfo))
	{
		char szBuf[MAX_PATH] = {0};
		int wImageIdx = 0;
		short wItem = 0;
		char szName[MAX_PATH] = {0};

		//获取获取设备示例ID
		if(SetupDiGetDeviceInstanceId(hDev,&DevInfo,szName,MAX_PATH - 1,NULL))
		{
			//Dbg("DeviceInstanceId[%s]",szName);
			if (-1 != FindSubStr(szName, pUkeyID))
			{
				Dbg("find the UKey[%s]",pUkeyID);
				bFind = TRUE;
				break;
			}	
		}
		else
		{			
			Dbg("找不到此USB设备的实例ID");
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_THE_UKEY_GET_INSTANCEID,
				GetOutPutStr("%s%s", "SetupDiGetDeviceInstanceId", "False").c_str());
		}	

		DeviceIndex++;
	}

	if(hDev)
	{
		SetupDiDestroyDeviceInfoList(hDev);
	}

	return bFind;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int i = 0;
	unsigned int uiDeviceNum = 0;
	unsigned int uiCameraNum = 0;
	char szMessage[128] = {0};	
	char* pName = new char[MAX_PATH];
	char* pAudioName = new char[MAX_PATH];
	memset(pName, 0, MAX_PATH);
	memset(pAudioName, 0, MAX_PATH);
	sprintf(szMessage, "message=%d\n", message);
	OutputDebugString(szMessage);

	switch (message) 
	{
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	case WM_DEVICECHANGE:
		{
			switch(wParam)
			{
			case DBT_DEVICEARRIVAL:
				{
					Sleep(1000);
					g_USBStatus = USB_INSERT;
					LogEvent(Severity_Middle, EVENT_USB_INSERT, "USB insert");
					Dbg("检测到USB设备插入.");
					
					//把广角摄像头当做一个内置摄像头
					if (1 == g_nSurveillanceRecordAllowed)
					{
						//
						if (g_strEwsCameraID.GetLength() < 1)
						{
							Dbg("Root.ini没有配置广角摄像头实例ID!");	
						}
						else if (!g_FindEwsCamera)
						{	
							if (FindNewEwsCamera())
							{
								g_FindEwsCamera = TRUE;
								LogEvent(Severity_Middle, EVENT_USB_CAMERA_INPUT,  g_strEwsCameraID.GetData());
								Dbg("广角摄像头:[%s]插入", g_strEwsCameraID);

								memcpy((void*)g_FixedImageDeviceName[g_FixedImageDeviceNum].cDeviceName, g_strEwsCameraID.GetData(), g_strEwsCameraID.GetLength());
								g_FixedImageDeviceNum++;
								break;
							}																					
						}
					}


					//TODO:当前摄像头个数小于2时（只是两个内置摄像头），处于异常，要求重启框架
					uiCameraNum = GetImageDeviceNum();
					if (uiCameraNum > g_FixedImageDeviceNum + 1)
					{
						//add by zl 20171109 获取高拍仪个数，允许同时插入普通外接摄像头和高拍仪，且支持同时插入多个高拍仪
						int nPortableScannerNum = GetPortableScannerNum();
						int nNewScannerNum = uiCameraNum - g_FixedImageDeviceNum - nPortableScannerNum;
						if (nNewScannerNum > 1)
						{
							//如果当前找到的摄像头个数>实体启动时找到的摄像头个数+高拍仪个数+1
							//说明系统识别到了非USB接口的摄像头，不支持处理这种异常情况
							//打印当前找到的摄像头名称和个数
							Dbg("系统识别[%d]个外接摄像头，系统只支持1个,请全部拔出，并重新插入唯一设备!",uiCameraNum-g_FixedImageDeviceNum-nPortableScannerNum);
							LogEvent(Severity_Middle, EVENT_USB_CAMERA_NOT_ONLY, "Not only");
							//MessageBox(0,"系统识别多个外接摄像头，系统只支持1个,请全部拔出，并重新插入唯一设备!",NULL,0);
							break;
						}
						else if (0 == nNewScannerNum)
						{
							//如果只插入高拍仪，不处理直接返回
							break;
						}
					}
					else if (uiCameraNum < g_FixedImageDeviceNum)
					{
						//实体启动时插入了非USB外接摄像头，在此刻插入USB摄像头之前已经拔出
						//此情况此处不做特殊处理，在拔出设备时，会刷新内置摄像头列表
						Dbg("系统识别[%d]个摄像头，少于内置摄像头个数[%d]!",uiDeviceNum, g_FixedAudioDeviceNum);		
					}

					if (!g_FindUsbCamera)
					{						
						if (FindNewImageDevice(&pName))
						{
							g_FindUsbCamera = TRUE;
							LogEvent(Severity_Middle, EVENT_USB_CAMERA_INPUT, pName);
							Dbg("摄像头:[%s]插入",pName);
							//找到摄像头后，不再查找音频设备
							break;
						}
					}									
				}
				break;
			case DBT_DEVICEREMOVECOMPLETE:
				{
					Sleep(100);
					g_USBStatus = USB_PULLOUT;
					LogEvent(Severity_Middle, EVENT_USB_OUTPUT, "USB output");
					Dbg("检测到USB设备拔出.");

					//广角摄像头当做内置摄像头处理
					if (g_FindEwsCamera)
					{
						if (!FindMyImageDevice(g_strEwsCameraID.GetData()))
						{
							g_FindEwsCamera = FALSE;
							LogEvent(Severity_Middle, EVENT_USB_CAMERA_OUTPUT, g_strEwsCameraID.GetData());
							Dbg("广角摄像头:[%s]拔出\n",g_strEwsCameraID);

							//从内置摄像头列表中去掉广角摄像头													
							DEVICE_INFO newFixedImageDeviceName[MAX_MEDIA_DEVICE_NUM] = {0};
							int newCount = 0;
							for (unsigned int i=0;i<g_FixedImageDeviceNum;i++)
							{								
								if (-1 == FindSubStr(g_FixedImageDeviceName[i].cDeviceName,g_strEwsCameraID.GetData()))
								{
									memcpy((void*)newFixedImageDeviceName[newCount].cDeviceName, g_FixedImageDeviceName[i].cDeviceName, MAX_PATH);
									newCount++;
								}

								memset(g_FixedImageDeviceName[i].cDeviceName, 0, MAX_PATH);
							}

							Dbg("拔出广角摄像头，刷新后的内置摄像头列表:");
							for (unsigned int i=0;i<newCount;i++)
							{
								memcpy((void*)g_FixedImageDeviceName[i].cDeviceName, newFixedImageDeviceName[i].cDeviceName, MAX_PATH);
								Dbg("内置摄像头:[%s]",g_FixedImageDeviceName[i].cDeviceName);
							}

							g_FixedImageDeviceNum--;
							break;
						}
					}

					uiCameraNum = GetImageDeviceNum();
					if (uiCameraNum < g_FixedImageDeviceNum)
					{
						//如果当前的音频设备个数小于实体启动时发现的摄像头个数
						//则认为实体启动时已经插入外接的摄像头，此时已经拔出，需刷新内置摄像头列表
						Dbg("当前识别到的摄像头个数[%d]小于实体启动时识别到的摄像头个数[%d]",uiCameraNum, g_FixedImageDeviceNum);
						Dbg("说明实体启动时已经插入了外接的摄像头，此时拔出该外接摄像头。准备刷新内置摄像头列表");

						//找到被拔出的这个摄像头
						char* poutName = new char[MAX_PATH];
						memset(poutName, 0, MAX_PATH);
						if(FindOutputImageDevice(poutName))
						{
							LogEvent(Severity_Middle, EVENT_USB_CAMERA_OUTPUT, poutName);
							Dbg("摄像头:[%s]拔出\n",poutName);
						}

						if (NULL != poutName)
						{
							delete poutName;
							poutName = NULL;
						}

						//清空
						g_FixedImageDeviceNum = 0;						
						for (i=0; i<MAX_MEDIA_DEVICE_NUM; i++)
						{
							memset((void*)g_FixedImageDeviceName[i].cDeviceName, 0, MAX_PATH);
						}

						//刷新
						if (!FindFixedImageDevice())
						{							
							break;
						}
						else
						{
							Dbg("刷新后的内置摄像头列表:");
							for (unsigned int i=0;i<g_FixedImageDeviceNum;i++)
							{
								Dbg("内置摄像头:[%s]",g_FixedImageDeviceName[i].cDeviceName);
							}
						}
					}
					else if (uiCameraNum > g_FixedImageDeviceNum)
					{
						//add by zl 20171109 获取高拍仪个数，允许同时插入普通外接摄像头和高拍仪，且支持同时插入多个高拍仪
						int nPortableScannerNum = GetPortableScannerNum();
						int nScannerNum = uiCameraNum - g_FixedImageDeviceNum - nPortableScannerNum;
						if (nScannerNum > 1)
						{
							//如果当前的摄像头个数大于实体启动时发现的摄像头个数
							//则认为实体启动后，系统自动识别到新的非USB摄像头
							//此情况此处不做特殊处理，在下一次插入USB设备时，会弹出错误提示
							//int nInNum = uiCameraNum - g_FixedImageDeviceNum;
							Dbg("系统仍识别[%d]个外接摄像头!",nScannerNum);	
							break;//add by zl 20160705,电子钥匙插拔时，会进入此处
						}					
					}
					else
					{
						Dbg("g_FixedImageDeviceNum=uiCameraNum");
					}

					if (g_FindUsbCamera)
					{
						if (!FindMyImageDevice(g_UsbCameraName))
						{
							g_FindUsbCamera = FALSE;

							LogEvent(Severity_Middle, EVENT_USB_CAMERA_OUTPUT, g_UsbCameraName);
							Dbg("摄像头:[%s]拔出\n",g_UsbCameraName);
						}
					}				
				}
				break;
			}
		}
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}

	if (NULL != pName)
	{
		delete pName;
	}

	return 0;
}

DWORD WINAPI DetectThreadFunc(LPVOID ready)
{
	char	szClassName[256]	= {'c','g','b',0};
	SYSTEMTIME st;
	GetLocalTime(&st);
	srand(GetTickCount());
	sprintf_s((char *)&(szClassName[3]),250,"%d%d%d%d%d%d",rand(),rand(),st.wMinute,st.wSecond,st.wMilliseconds,GetTickCount());

	MSG msg;

	WNDCLASSEX wcex = {0};

	wcex.cbSize = sizeof(WNDCLASSEX); 
	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= (WNDPROC)WndProc;
	wcex.lpszClassName	= szClassName;/*"GDB_DETECT_WINDOW";*/

	ATOM a = RegisterClassEx(&wcex);

	if (a == 0)
	{
		//WRITE_INFORMATION_LOG("Error::DetectThreadFun!!!RegisterClassEx!!!!!!!!!!!!!!Start--%d--",GetLastError());
	}
	else
	{
		//WRITE_INFORMATION_LOG("DetectThreadFunc!!!RegisterClassEx!!!!!!!!!!!!!Start--%d--",GetLastError());
	}


	hDetectWnd = CreateWindow(szClassName, "", WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, NULL, NULL);

	HideCaret(hDetectWnd);
	SetEvent((HANDLE)ready);

	if(hDetectWnd)
	{
		while (GetMessage(&msg, NULL, 0, 0)) 
		{
			if (!TranslateAccelerator(msg.hwnd, NULL, &msg)) 
			{
				TranslateMessage(&msg);
				DispatchMessage(&msg);
			}
		}
	}

	return 0;
}

bool RegisterDetector()
{
	hDetectMutex = CreateMutex(0, TRUE, "CMBDETECTOR");

	if (hDetectMutex == NULL)
	{
		//WRITE_INFORMATION_LOG("CreateMutex fail %08x.\n", GetLastError());
		return false;
	}

	if (GetLastError() == ERROR_ALREADY_EXISTS)
	{
		CloseHandle(hDetectMutex);
		hDetectMutex = NULL;
		////WRITE_INFORMATION_LOG("Detector exists.\n");
		return false;
	}

	DWORD ThreadId;
	HANDLE ready = CreateEvent(0,0,0,0);
	hDetectThread = CreateThread(NULL,0,DetectThreadFunc,ready,0,&ThreadId);

	WaitForSingleObject(ready,-1);

	if (hDetectWnd == NULL)
	{
		//WRITE_INFORMATION_LOG("Create window fail %08x.\n", GetLastError());
		CloseHandle(hDetectMutex);
		hDetectMutex = NULL;
		return false;
	}

	DEV_BROADCAST_DEVICEINTERFACE devBroadcastDevIF = {0};
	devBroadcastDevIF.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
	devBroadcastDevIF.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
	devBroadcastDevIF.dbcc_reserved = 0;
	devBroadcastDevIF.dbcc_classguid = *StrToGUID(L"{A5DCBF10-6530-11D2-901F-00C04FB951ED}");
	//devBroadcastDevIF.dbcc_classguid = *StrToGUID(L"{4D36E96C-E325-11CE-BFC1-08002BE10318}");

	DWORD flag = DEVICE_NOTIFY_WINDOW_HANDLE;

	//if (!g_IsWin2K)
	//{
	//	flag |= DEVICE_NOTIFY_ALL_INTERFACE_CLASSES;
	//}

	hDevNotify = RegisterDeviceNotification( 
		hDetectWnd,
		&devBroadcastDevIF,
		flag
		);

	if (hDevNotify == NULL)
	{
		SendMessage(hDetectWnd,WM_CLOSE,0,0);
		if (hDetectThread)
		{
			WaitForSingleObject(hDetectThread,-1);
		}
		hDetectThread = NULL;
		hDetectWnd = NULL;

		//WRITE_INFORMATION_LOG("RegisterDeviceNotification fail %08x.\n", GetLastError());
		CloseHandle(hDetectMutex);
		hDetectMutex = NULL;
		return false;
	}

	//WRITE_INFORMATION_LOG("RegisterDeviceNotification succeed.\n");
	return true;
}

void InitializeDetector(PVOID pWnd)
{
	RegisterDetector();
}

void UninitializeDetector(PVOID pWnd)
{
	if (hDevNotify)
	{
		UnregisterDeviceNotification(hDevNotify);
		hDevNotify = NULL;
	}

	if (hDetectWnd)
	{
		SendMessage(hDetectWnd,WM_CLOSE,0,0);
		if (hDetectThread)
		{
			WaitForSingleObject(hDetectThread,-1);
		}
		hDetectThread = NULL;
		hDetectWnd = NULL;
	}

	if (hDetectMutex)
	{
		CloseHandle(hDetectMutex);
		hDetectMutex = NULL;
	}
}

struct callback_entry : public IReleasable
{
	virtual ~callback_entry() {}
	CSimpleStringA EntityName;
	union {
		void *pRawData;
		int state;
	};
	int op;
	ErrorCodeEnum ErrorResult;
};

struct GuidUSBTask : public ITaskSp
{
	ConsoleFSM* fsm;

	GuidUSBTask(ConsoleFSM* f) : fsm(f) {}

	void Process()
	{	
		USBKEY_INFO info;
		unsigned count = 0;
		DWORD dwRet = DONGLE_SUCCESS;
		BOOL bRet = FALSE;

		while (1)
		{
			if (USB_INSERT == g_USBStatus)
			{					
				memset(&g_USBKeyInfo, 0, sizeof(DONGLE_INFO));			
				dwRet = FindUsbKey(&g_USBKeyInfo, &count);
				if (dwRet == DONGLE_SUCCESS)
				{
					if (!g_FindKey)
					{
						g_FindKey = TRUE;
						fsm->PostEventFIFO(new FSMEvent(USER_EVT_JMP_UKEYINSERT));		
					}
				}

				//如果是大机，检测是否专业版Ukey插入
				if (!g_FindUkey)
				{
					if (FindUkey())
					{
						g_FindUkey = TRUE;
						LogEvent(Severity_Middle, EVENT_UKEY_INSERT, "Ukey insert");
						
						TheUkeyInsert e ={};
						SpSendBroadcast(fsm->GetFunction(), eMsg_TheUkeyInsert, eMsgSig_TheUkeyInsert, e);
						Dbg("UKey[%s]插入",g_UkeyName);
					}
				}

				g_USBStatus = 0;
			}
			else if (USB_PULLOUT == g_USBStatus)
			{				
				memset(&info, 0, sizeof(DONGLE_INFO));			
				dwRet = FindUsbKey(&info, &count);
				if (dwRet != DONGLE_SUCCESS)
				{
					if (g_FindKey)
					{
						g_FindKey = FALSE;
						fsm->PostEventFIFO(new FSMEvent(USER_EVT_JMP_UKEYPULLOUT));		
					}												
				}

				//检测是否专业版Ukey拔出
				if (g_FindUkey)
				{
					if (!FindTheUkey(g_UkeyName))
					{
						g_FindUkey = FALSE;
						LogEvent(Severity_Middle, EVENT_UKEY_OUTPUT, "Ukey output");

						TheUkeyPullOut e ={};
						SpSendBroadcast(fsm->GetFunction(), eMsg_TheUkeyPullOut, eMsgSig_TheUkeyPullOut, e);
						Dbg("UKey[%s]拔出",g_UkeyName);
						//如果是大机，拔出Ukey，关闭Gpio
						if (0 != strcmp(fsm->m_strMachineType.GetData(), MACHINETYPE_PAD))
						{
							bRet = fsm->OpenGpio(FALSE);
						}					
					}
				}

				g_USBStatus = 0;
			}

			Sleep(50);
		}
	}
};

struct GuidVerifyTask : public ITaskSp
{
	ConsoleFSM* fsm;

	GuidVerifyTask(ConsoleFSM* f) : fsm(f) {}

	void Process()
	{
		while(1)
		{
			if (fsm->m_bVerifyPwd)
			{
				fsm->m_bVerifyPwd = FALSE;
				//fsm->PostEventLIFO(new FSMEvent(USER_EVT_JMP_RELEASE));
			}

			Sleep(100);
		}
	}
};

ConsoleFSM::ConsoleFSM() : m_pConnection(NULL)
{	
	m_Handle = 0;
	g_FindKey = FALSE;
	g_FindUkey = FALSE;
	g_bWorkingStatus = FALSE;
	m_bVerifySuccess = FALSE;
	m_nUkeyStatus = 0;
	m_nCheckTerminalNo = 0;
	m_nCheckMaintainTask = 0;
	m_nVerifyBlackList = 1;
	g_nSurveillanceRecordAllowed = 0;
	g_strEwsCameraID = "";
	m_strUIstate = "";
	m_nSRState = 0;
	m_strPwd.Clear();
	m_errcode = 0;
	m_bMenu = FALSE;
	g_bErrStatus = FALSE;
	m_bAns = FALSE;
	m_bVerifyPwd = FALSE;
	m_bInputpwdDlg = FALSE;
	g_HasVerifyTask = FALSE;

	memset(m_TaskStatus,'D',1);//初始状态设置为D
	memset(m_USBKeyInitTime,0,20);
	
	m_RecordNum = 0;
	memset(&g_USBKeyInfo, 0, sizeof(DONGLE_INFO));

	m_pCardIssuerService = NULL;
	m_pDeviceControlService = NULL;

	for (int i=0; i<128; i++)
	{
		m_TaskRecords[i] = new TaskRecord();
		memset(m_TaskRecords[i]->startTime, 0, 20);
		memset(m_TaskRecords[i]->endTime, 0, 20);
		m_TaskRecords[i]->strWarningId = "";
	}

	InitializeCriticalSection(&cs);
}

ConsoleFSM::~ConsoleFSM()
{
	for (int i=0; i<128; i++)
	{
		delete m_TaskRecords[i];
	}

	DeleteCriticalSection(&cs);
}

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

void ConsoleFSM::OnSysVarEvent( const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName )
{
}

ErrorCodeEnum ConsoleFSM::OnInit()
{
	ErrorCodeEnum Error;
	Error = LoadServerConfig();
	if (Error != Error_Succeed) 
	{
		LOG_TRACE("load MaintainWatcher.ini failed!");
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_READ_CONFIG,
			GetOutPutStr("%s%08X%s%s", "LoadServerConfig", Error,"File","MaintainWatcher.ini").c_str());
	}

	Error = LoadRootConfig();
	if (Error != Error_Succeed) 
	{
		LOG_TRACE("load root.ini failed!");
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_READ_CONFIG,
			GetOutPutStr("%s%08X%s%s", "LoadRootConfig", Error, "File", "root.ini").c_str());
		return Error;
	}

	Error = LoadCenterConfig();
	if (Error != Error_Succeed) 
	{
		//没有读到CenterSetting.ini中的CheckTerMinalNo项，不返回错误，默认为不校验终端ID
		LOG_TRACE("load CenterSetting.ini failed!");
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_READ_CONFIG,
			GetOutPutStr("%s%08X%s%s", "LoadCenterConfig", Error, "File", "CenterSetting.ini").c_str());
		//return Error;
	}	

	Error = SetRunConfig();
	if (Error_Succeed != Error) 
	{
		LOG_TRACE("set runcfg MaintainWatcher.ini failed!");
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_READ_CONFIG,
			GetOutPutStr("%s%08X%s%s", "SetRunConfig", Error, "File", "MaintainWatcher.ini").c_str());
	}

	if (Error == Error_Succeed) 
	{
		AddStateHooker(this);
	}
	
	//获取终端号
	CSystemStaticInfo si;
	m_pEntity->GetFunction()->GetSystemStaticInfo(si);
	m_strTerminalId = si.strTerminalID;
	Dbg("Get TerminalId=%s from root.ini",m_strTerminalId.c_str());
	//创建证书目录
	DWORD dwAttr=GetFileAttributes(CERT_DIR);  
	if(dwAttr==0xFFFFFFFF)  //目录不存在则创建   
	{
		if(!CreateDirectory(CERT_DIR,NULL))
		{
			Dbg("Create cert dir failed!");
			LogWarn(Severity_Low,Error_Unexpect,ERR_MAINTAINWATCHER_CREATE_DIR,
				GetOutPutStr("%s%s%s%s", "CreateDirectory", "False", "Dir", CERT_DIR).c_str());
		}
	}
	

	//创建文件目录
	char path[MAX_PATH];
	GetSystemDirectory(path,MAX_PATH);	

	string strRvcPath = path;
	strRvcPath += ":\\RVC"; 
	dwAttr=GetFileAttributes("C:\\RVC");  
	if(dwAttr==0xFFFFFFFF)  //目录不存在则创建   
	{
		if(!CreateDirectory("C:\\RVC",NULL))
		{
			Dbg("Create C:\\RVC failed!");
			LogWarn(Severity_Low,Error_Unexpect,ERR_MAINTAINWATCHER_CREATE_DIR,
				GetOutPutStr("%s%s%s%s", "CreateDirectory", "False", "Dir", "C:\\RVC").c_str());
		}
	}

	string strCertPath = path;
	strCertPath += ":\\RVC\\UKey";
	dwAttr=GetFileAttributes("C:\\RVC\\Ukey"); 
	if(dwAttr==0xFFFFFFFF)  //目录不存在则创建   
	{
		if(!CreateDirectory("C:\\RVC\\Ukey",NULL))
		{
			Dbg("Create C:\\RVC\\Ukey failed!");
			LogWarn(Severity_Low,Error_Unexpect, ERR_MAINTAINWATCHER_CREATE_DIR,
				GetOutPutStr("%s%s%s%s", "CreateDirectory", "False", "Dir", "C:\\RVC\\Ukey").c_str());
		}
	}

	GuidUSBTask* task2 = new GuidUSBTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task2);

	if (1)
	{
		FindFixedImageDevice();
		Dbg("找到[%d]个摄像头 at OnInit",g_FixedImageDeviceNum);
		for (unsigned int i=0;i<g_FixedImageDeviceNum;i++)
		{
			Dbg("摄像头:[%s]",g_FixedImageDeviceName[i].cDeviceName);
		}

		if (FindNewEwsCamera())
		{
			g_FindEwsCamera = TRUE;
			LogEvent(Severity_Middle, EVENT_USB_CAMERA_INPUT,  g_strEwsCameraID.GetData());
			Dbg("实体启动时，广角摄像头:[%s]插入", g_strEwsCameraID);
		}	

		//启动USB监控
		InitializeDetector(NULL);
	}

	//下载根证书和CA证书	
	Dbg("开始下载基本证书");
	DownloadCerts();

	Dbg("开始下载黑名单");
	DownloadCertBlackList();
	//......
	return Error;
}

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

void ConsoleFSM::DownloadCerts()
{
	//下载根证书和CA证书
	if (!m_pConnection) 
	{
		m_pConnection = new CAConnection(m_pEntity, this);
		if (!m_pConnection->ConnectFromCentralSetting())
		{
			Dbg("connect server fail,config or Servers Error!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_DOWNLOAD_CERT, 
				GetOutPutStr("%s%s", "ConnectFromCentralSetting", "False").c_str());
		}
	}

	if (m_pConnection->IsConnectionOK())
	{
		EnterCriticalSection(&cs);
		m_pConnection->SendVersionReq();
		Dbg("send cert req success");
		LeaveCriticalSection(&cs);
	} 
	else
	{
		Dbg("connect to CA server failed, can not download CA cert!");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_DOWNLOAD_CERT, 
			GetOutPutStr("%s%s", "IsConnectionOK", "False").c_str());
	}
}

void ConsoleFSM::DownloadCertBlackList()
{
	if (!m_pConnection) 
	{
		m_pConnection = new CAConnection(m_pEntity, this);
		if (!m_pConnection->ConnectFromCentralSetting())
		{
			Dbg("connect server fail,config or Servers Error!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_DOWBLOAD_CERT_BLACKLIST,
				GetOutPutStr("%s%s", "ConnectFromCentralSetting", "False").c_str());
		}
	}

	if (m_pConnection->IsConnectionOK())
	{
		EnterCriticalSection(&cs);
		m_pConnection->SendCertBlackListReq();
		Dbg("Ask cert blackList req success");
		LeaveCriticalSection(&cs);
	} 
	else
	{
		Dbg("connect to CA server failed, can not download cert blackList!");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_DOWBLOAD_CERT_BLACKLIST, 
			GetOutPutStr("%s%s", "IsConnectionOK", "False").c_str());
	}
}

BOOL ConsoleFSM::GetMenuStatus()
{
	//判断终端是否在业务界面首页，不在首页不弹出客户经理登录框				 
	ErrorCodeEnum Error = GetEntityBase()->GetFunction()->GetSysVar("UIState",m_strUIstate);
	if (Error_NotExist == Error) 
	{
		Dbg("UIState is not exist, errcode=%d!", Error);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHERGET_UISTATE,
			GetOutPutStr("%s%08X%s%s", "GetSysVar", Error,"UIState", m_strUIstate).c_str());

		m_bMenu = TRUE;
		return m_bMenu;
	}
	else if (Error_Succeed != Error)
	{
		Dbg("Get UIState failed, errcode=%d!", Error);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHERGET_UISTATE,
			GetOutPutStr("%s%08X%s%s", "GetSysVar", Error, "UIState", m_strUIstate).c_str());
		m_bMenu = TRUE;
		return m_bMenu;
	}	
	else
	{
		//Dbg("Get UIState success, m_strUIstate=%s!", m_strUIstate);
		if ((-1 != FindSubStr(m_strUIstate, "M"))
			|| (-1 != FindSubStr(m_strUIstate, "A"))
			|| (-1 != FindSubStr(m_strUIstate, "T"))
			|| (-1 != FindSubStr(m_strUIstate, "X")))
		{
			//界面状态UIState。定义当前交互层所处的交互模式。有8种状态：目录浏览M、随机广告A、目标广告T、业务填单F、交易确认C、业务提交S、请求回报R、暂停响应Z。初始状态为M。
			//M、A、T三种状态都认为在首页
			Dbg("首页状态!");
			m_bMenu = TRUE;
		}
		else
		{
			//不在首页
			Dbg("非首页状态!");
			m_bMenu = FALSE;
		}

		return m_bMenu;
	}
}

DWORD ConsoleFSM::VerifyUser(const char* pcPIN)
{
	if (NULL == pcPIN)
	{
		return INPUT_NULL_ERR;
	}

	USBKEY_INFO info;
	unsigned count = 0;
	DWORD dwRet = 0;
	DONGLE_HANDLE hHandle;
	CSimpleStringA errNum;

	//找锁
	dwRet = FindUsbKey(&info, &count);
	if (DONGLE_SUCCESS != dwRet)
	{	
		errNum.Format("0x%08X", dwRet); 
		Dbg("没有检测到电子钥匙, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect,ERR_MAINTAINWATCHER_EKEY_VERIFY,
			GetOutPutStr("%s%08X", "FindUsbKey", dwRet).c_str());
		//MessageBoxA(NULL,(LPCSTR)("没有检测到电子钥匙，请插入电子钥匙!"),NULL,0);
		return dwRet;
	}

	Dbg("检测到[%d]把电子钥匙！",count);

	//打开锁
	dwRet = OpenUsbKey(&hHandle,0);
	if (DONGLE_SUCCESS != dwRet)
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("无法打开电子钥匙, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_EKEY_VERIFY,
			GetOutPutStr("%s%08X", "OpenUsbKey", dwRet).c_str());
		return dwRet;
	}

	m_Handle = hHandle;
	Dbg("打开电子钥匙成功！");

	//验证开发商PIN码
	char PIN[9] = {0};
	memcpy(PIN, pcPIN, 8);
	char* upPIN =  _tcsupr(PIN);
	dwRet = VerifyAdminPIN(hHandle, upPIN);
	if (DONGLE_SUCCESS != dwRet)
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("电子钥匙密码错误, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_EKEY_VERIFY,
			GetOutPutStr("%s%08X", "VerifyAdminPIN", dwRet).c_str());
		return dwRet;
	}
	else
	{
		Dbg("验证电子钥匙密码成功！");
	}

	//读取根证书
	int rootCertLen = 0;
	dwRet = GetRootCaCertificateLength(hHandle, &rootCertLen);
	if (DONGLE_SUCCESS == dwRet)
	{
		Dbg("获取根证书长度成功！");

		BYTE* rootCertContent = new BYTE[rootCertLen];
		if (NULL == rootCertContent)
		{
			return NEW_MEM_ERR;
		}
		memset(rootCertContent,0,rootCertLen);

		dwRet = ReadRootCaCertificate(hHandle, rootCertContent, rootCertLen);
		if (DONGLE_SUCCESS == dwRet)
		{
			Dbg("读根根证书成功！");
			FILE* fp = fopen(ROOT_CERT_PATH, "w");
			fwrite(rootCertContent, 1, rootCertLen, fp);
			fclose(fp);
			delete rootCertContent;
		}	
		else
		{
			errNum.Format("0x%08X", dwRet); 
			Dbg("读根证书失败, errcode=%s", errNum);
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_ROOT_CERT,
				GetOutPutStr("%s%08X", "ReadRootCaCertificate", dwRet).c_str());
			delete rootCertContent;
			return dwRet;
		}
	}
	else
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("获取根证书长度失败, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_ROOT_CERT,
			GetOutPutStr("%s%08X", "GetRootCaCertificateLength", dwRet).c_str());
		return dwRet;
	}

	//读取分行CA证书
	int subCaCertLen = 0;
	dwRet = GetSubCaCertificateLength(hHandle, &subCaCertLen);
	if (DONGLE_SUCCESS == dwRet)
	{
		Dbg("获取分行CA证书长度成功！");

		BYTE* subCaCertContent = new BYTE[subCaCertLen];
		if (NULL == subCaCertContent)
		{
			return NEW_MEM_ERR;
		}

		memset(subCaCertContent,0,subCaCertLen);
		dwRet = ReadSubCaCertificate(hHandle, subCaCertContent, subCaCertLen);
		if (DONGLE_SUCCESS == dwRet)
		{
			Dbg("读根分行CA证书成功！");
			FILE* fp = fopen(CA_CERT_PATH, "w");
			fwrite(subCaCertContent, 1, subCaCertLen, fp);
			fclose(fp);
			delete subCaCertContent;
		}	
		else
		{
			errNum.Format("0x%08X", dwRet); 
			Dbg("读分行CA证书失败, errcode=%s", errNum);
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_BRANCH_CERT,
				GetOutPutStr("%s%08X", "ReadSubCaCertificate", dwRet).c_str());
			delete subCaCertContent;
			return dwRet;
		}
	}
	else
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("获取分行CA证书长度失败, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_BRANCH_CERT,
			GetOutPutStr("%s%08X", "GetSubCaCertificateLength", dwRet).c_str());
		return dwRet;
	}

	//读取Ukey中的用户证书
	int userCertLen = 0;
	dwRet = GetUserCertificateLength(hHandle, &userCertLen);
	if (DONGLE_SUCCESS == dwRet)
	{
		Dbg("获取用户证书长度成功！");

		BYTE* userCertContent = new BYTE[userCertLen];
		if (NULL == userCertContent)
		{
			return NEW_MEM_ERR;
		}
		memset(userCertContent,0,userCertLen);

		dwRet = ReadUserCertificate(hHandle, userCertContent, userCertLen);
		if (DONGLE_SUCCESS == dwRet)
		{
			Dbg("读取用户证书成功！");
			FILE* fp = fopen(USER_CERT_PATH, "w");
			fwrite(userCertContent, 1, userCertLen, fp);
			fclose(fp);
			delete userCertContent;
		}	
		else
		{
			errNum.Format("0x%08X", dwRet); 
			Dbg("读用户证书失败, errcode=%s", errNum);
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_USER_CERT,
				GetOutPutStr("%s%08X", "ReadUserCertificate", dwRet).c_str());
			delete userCertContent;
			return dwRet;
		}
	}
	else
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("获取用户证书长度失败, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_USER_CERT,
			GetOutPutStr("%s%08X", "GetUserCertificateLength", dwRet).c_str());
		return dwRet;
	}

	//获取证书认证类型
	char cVerifyType[32] = {0};
	bool bRet = GetVerifyTypeFromCert(USER_CERT_PATH, FORMAT_PEM, cVerifyType);
	if (!bRet)
	{
		Dbg("获取证书类型失败!");
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_USER_CERT,
			GetOutPutStr("%s%s", "GetVerifyTypeFromCert", "False").c_str());
		return GET_CERT_CERTTYPE_ERR;
	}

	//判断认证类型
	Dbg("电子钥匙类型：%s（Framework：框架认证，System：系统认证, admin:超级认证）", cVerifyType);
	//删除此处判断，分行维护电子钥匙也能进入框架维护，add by zl80170228
	/*if ((0 != strncmp(cVerifyType, "Framework", 9))
	&& (0 != strncmp(cVerifyType, "admin", 5)))
	{
	Dbg("电子钥匙认证类型不具备框架认证权限!");
	return GET_NO_FRAMEWORK_PERMIT_ERR;
	}*/	

	//验证用户证书
	dwRet = VerifyUserCert(ROOT_CERT_PATH, CA_CERT_PATH, USER_CERT_PATH, NULL, FORMAT_PEM);
	if (DONGLE_SUCCESS != dwRet)
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("验证用户证书失败, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_USER_CERT_VERIFY,
			GetOutPutStr("%s%08X", "VerifyUserCert", dwRet).c_str());
		return dwRet;
	}

	Dbg("验证用户证书成功！");

	dwRet = VerifyTerminalInfo();
	if (DONGLE_SUCCESS != dwRet)
	{
		errNum.Format("0x%08X", dwRet); 
		Dbg("验证任务信息失败, errcode=%s", errNum);
		LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_TERMINAL_VERIFY,
			GetOutPutStr("%s%08X", "VerifyTerminalInfo", dwRet).c_str());
		return dwRet;
	}

	//校验证书时间，给出续期提醒，过期前15天开始提醒
	dwRet = CheckCertVaildity();
	if (SUCCESS != dwRet && OVERTTIMER_WAR != dwRet)
	{
		Dbg("CheckCertVaildity failed!");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CERT_VERIFY, 
			GetOutPutStr("%s%08X", "CheckCertVaildity", dwRet).c_str());
	}

	return dwRet;
}

DWORD ConsoleFSM::VerifyOther()
{
	Dbg("enter VerifyOther");
	m_bVerifyPwd = TRUE;	
	
	((0 == m_errcode) || (OVERTTIMER_WAR == m_errcode))? PostEventLIFO(new FSMEvent(USER_EVT_JMP_PWDSUCCESS)):PostEventLIFO(new FSMEvent(USER_EVT_JMP_PWDERR));
	
	return 0;
}


BOOL CALLBACK spEnumWindowsProc(HWND hwnd,LPARAM lParam)
{
	char title[300] = {0};

	SendMessage(hwnd,WM_GETTEXT,256,(LPARAM)title);
	if (_stricmp(title, "密码") == 0)
	{
		SendMessage(hwnd, WM_CLOSE, 0,0);
		return FALSE;
	}

	return TRUE;
}

time_t Str2Timet(const string& ATime, const string& AFormat="%d-%d-%d")  
{  
	struct tm tm_Temp;  
	time_t time_Ret;  
	try 
	{
		int i = sscanf(ATime.c_str(), AFormat.c_str(),// "%d/%d/%d %d:%d:%d" ,       
			&(tm_Temp.tm_year),   
			&(tm_Temp.tm_mon),   
			&(tm_Temp.tm_mday),  
			&(tm_Temp.tm_hour),  
			&(tm_Temp.tm_min),  
			&(tm_Temp.tm_sec),  
			&(tm_Temp.tm_wday),  
			&(tm_Temp.tm_yday));  

		tm_Temp.tm_year -= 1900;  
		tm_Temp.tm_mon --;  
		tm_Temp.tm_hour=0;  
		tm_Temp.tm_min=0;  
		tm_Temp.tm_sec=0;  
		tm_Temp.tm_isdst = 0;
		time_Ret = mktime(&tm_Temp);  
		return time_Ret;  
	} catch(...) {
		return 0;
	}
} 
string Timet2Str(const time_t &ATime_t, const string& AFormat="%d-%02d-%02d")
{
	char chRet[15];
	string sRet;
	struct tm *p;
	try
	{
		p = localtime(&ATime_t);
		p->tm_year = p->tm_year + 1900;
		p->tm_mon = p->tm_mon + 1;
		sprintf(chRet, AFormat.c_str(),
			p->tm_year, p->tm_mon, p->tm_mday);
		sRet = chRet;
		return sRet;
	} catch(...) {
		return "";
	}
}
time_t NowTime()
{
	time_t t_Now = time(0);
	struct tm* tm_Now = localtime(&t_Now);
	tm_Now->tm_hour =0;
	tm_Now->tm_min = 0;
	tm_Now->tm_sec = 0;
	return  mktime(tm_Now);  
}

BOOL ConsoleFSM::GetTaskStatus(const char* pTaskID)
{
	//获取任务状态
	if (!m_pConnection) 
	{
		m_pConnection = new CAConnection(m_pEntity, this);
		if (NULL == m_pConnection)
		{
			Dbg("new CAConnection failed!");
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT,
				GetOutPutStr("%s%s", "CAConnection", "NULL").c_str());
			return FALSE;
		}

		if (!m_pConnection->ConnectFromCentralSetting())
		{
			Dbg("connect server fail,config or Servers Error!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT, 
				GetOutPutStr("%s%s", "ConnectFromCentralSetting", "False").c_str());
			return FALSE;
		}
	}

	if (m_pConnection->IsConnectionOK())
	{
		EnterCriticalSection(&cs);
		m_pConnection->SendTaskReq(pTaskID);		
		LeaveCriticalSection(&cs);
	} 
	else
	{
		Dbg("connect to CA server failed, can not get <TaskID=%s> status!", pTaskID);
		
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT, 
			GetOutPutStr("%s%s%s%s", "IsConnectionOK", "False","GetTaskStatus",pTaskID).c_str());
		return FALSE;
	}

	return TRUE;
}

//校验电子钥匙生命周期，超过3年提示更新硬件
BOOL ConsoleFSM::CheckUSBKeyLife(const char* pUSBKeyID)
{
	//获取任务状态
	if (!m_pConnection) 
	{
		m_pConnection = new CAConnection(m_pEntity, this);
		if (NULL == m_pConnection)
		{
			Dbg("new CAConnection failed!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT, 
				GetOutPutStr("%s%s%s%s", "CAConnection", "NULL","CheckUSBKeyLife", pUSBKeyID).c_str());
			return FALSE;
		}

		if (!m_pConnection->ConnectFromCentralSetting())
		{
			Dbg("connect server fail,config or Servers Error!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT, 
				GetOutPutStr("%s%s%s%s", "ConnectFromCentralSetting", "False", "CheckUSBKeyLife", pUSBKeyID).c_str());
			return FALSE;
		}
	}

	if (m_pConnection->IsConnectionOK())
	{
		EnterCriticalSection(&cs);
		m_pConnection->SendUSBKeyInfoReq(pUSBKeyID);		
		LeaveCriticalSection(&cs);
	} 
	else
	{
		Dbg("connect to CA server failed, can not get <USBKeyID=%s> info!", pUSBKeyID);

		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CA_CONNECT,
			GetOutPutStr("%s%s%s%s", "IsConnectionOK", "False", "CheckUSBKeyLife", pUSBKeyID).c_str());
		return FALSE;
	}

	
	time_t tNow = NowTime();

	Dbg("电子钥匙第一次初始化时间[%s]", m_USBKeyInitTime);
	time_t tUSBKeyInitTime = Str2Timet(m_USBKeyInitTime, "%4d%2d%2d%2d%2d%2d");

	if (tUSBKeyInitTime >= tNow)
	{
		
		string strNow = Timet2Str(tNow);
		Dbg("电子钥匙第一次初始化时间[%s]大于机器当前时间[%s], 请确认当前VTM的系统时间是否正确！", m_USBKeyInitTime, strNow.c_str());
		CString msg;
		msg.Format(_T("电子钥匙第一次初始化时间[%s]大于机器当前时间[%s], 请确认当前VTM的系统时间是否正确！"),  m_USBKeyInitTime, strNow.c_str());
		::MessageBox(NULL,msg, "提示",0);
		return FALSE;
	}
	else
	{
		UINT nRestSecond = tNow - tUSBKeyInitTime;
		UINT nRestDay = nRestSecond/(60*60*24);
		if (nRestDay >= 365*3)
		{
			CString msg;
			msg.Format(_T("电子钥匙硬件已超过使用期限(最长3年)，剩余有效天数[%d]，请及时更换新电子钥匙!"), nRestDay);
			::MessageBox(NULL,msg, "提示",0);
			Dbg("电子钥匙硬件已超过使用期限(最长3年)，剩余有效天数[%d]，请及时更换新电子钥匙!", nRestDay);
			return TRUE;
		}
		
	}

	return TRUE;
}

//在线校验任务状态
BOOL ConsoleFSM::VerifyTaskStatus(const char* pTaskID)
{
	//查询任务状态
	BOOL bRet = GetTaskStatus(pTaskID);
	//此处不判断返回值，如果获取不成功，则认为终端处于离线状态，返回任务状态校验成功
	/*if (!bRet)
	{
		return FALSE;
	}*/

	Dbg("<TaskID=%s> status is <%c>!", pTaskID, m_TaskStatus[0]);
	
	if ('C' == m_TaskStatus[0])
	{
		Dbg("<TaskID=%s> is been closed!", pTaskID);
		m_TaskStatus[0] = 'D';
		return FALSE;
	}

	return TRUE;
}

DWORD ConsoleFSM::VerifyTerminalInfo()
{
	//获取用户信息，用于写入日志
	BOOL bRet = GetUserInfo();
	if (!bRet)
	{
		Dbg("GetUserInfo failed");
		return GET_USERINFO_ERR;
	}

	string strUserType = "";
	int nUserType = atoi(m_strUserType.c_str());

	if (1 == m_nVerifyBlackList)
	{
		char ukeyID[100];
		memset(ukeyID, 0, sizeof(ukeyID));
		m_strKeyHID.copy(ukeyID, m_strKeyHID.length(), 0);
		if (IsCertInBlack(ukeyID))
		{
			Dbg("CertUkeyID is in black List");
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_EKEY_VERIFY,
				GetOutPutStr("%s%s", "IsCertInBlack", "True").c_str());
			//MessageBox(0,"当前电子钥匙已被禁用，请更换其他电子钥匙！",NULL,0);
			return IN_BLACKLIST_ERR;
		}
		else
		{
			Dbg("CertUkeyID is not in black List");
		}
	}

	//只有维护和物料类型的电子钥匙需要验证终端任务信息
	if (((USER_TYPE_MATERIAL_MANAGER == nUserType)&&(1 == m_nCheckTerminalNo))//物料管理类型电子钥匙是否校验任务，通过集中配置CheckTerminalNo开关控制
		||((USER_TYPE_MAINTAIN == nUserType)&&(1 == m_nCheckMaintainTask)))//维护类型电子钥匙是否校验任务，通过集中配置CheckMaintainTask开关控制
	{
		bRet = FALSE;

		//兼容支持清机任务的卡机号认证
		if((USER_TYPE_MATERIAL_MANAGER == nUserType)
			&&(0 == strcmp(m_strMachineType.GetData(), MACHINETYPE_PAD)))
		{
			//获取卡箱号
			bRet = GetIssuerNum();
			if (!bRet)
			{
				Dbg("GetIssuerNum failed");
				LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_GET_CARDISSUER_SN,
					GetOutPutStr("%s%s", "GetIssuerNum", "False").c_str());
				return GET_ISSUERNUM_ERR;
			}
			else
			{
				Dbg("GetIssuerNum succeed");
			}

			//如果是Pad做物料维护，校验卡箱号
			DWORD dwRet = VerifyCardIssuerSN();
			if (SUCCESS != dwRet)
			{
				Dbg("VerifyCardIssuerSN failed");
				LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_CARDISSUER_SN_VERIFY,
					GetOutPutStr("%s%d", "VerifyCardIssuerSN", dwRet).c_str());
				return dwRet;
			}
			else
			{
				Dbg("VerifyCardIssuerSN succeed");
			}		
		}
		else
		{
			//校验操作权限(终端ID)
			DWORD dwRet = VerifyTerminalNo();
			if (SUCCESS != dwRet)
			{
				Dbg("VerifyTerminalNo failed");
				LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_TERMINAL_TASK_VERIFY,
					GetOutPutStr("%s%d", "VerifyCardIssuerSN", dwRet).c_str());
				return dwRet;
			}
		}	

		//获取用户类型
		char cUserType[3] = {0};
		bRet = GetUserTypeFromCert(USER_CERT_PATH, FORMAT_PEM, cUserType);
		if (!bRet)
		{
			Dbg("GetUserTypeFromCert err!");
			LogWarn(Severity_Middle,Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_TYPE_FROM_CERT,
				GetOutPutStr("%s%s", "GetUserTypeFromCert", "False").c_str());
			return GET_USERINFO_ERR;
		}

		//发送验证通过事件
		UkeyVerify e = {};
		UkeyVerifyEx ex = {};	
		char cUserInfo[2048] = {0};
		char cUserID[17] = {0};
		char cOfficeID[9] = {0};
		int nUserType = atoi(cUserType);

		//改成广播方式发送事件		
		bRet = GetUserIDFromCert(USER_CERT_PATH, FORMAT_PEM, cUserID);
		if (bRet)
		{
			e.AgentId = cUserID;
		}
		else
		{
			Dbg("GetUserIDFromCert failed!");
			e.AgentId = "";	
		}
		SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerify, eMsgSig_UkeyVerify, e);
		Dbg("AgentId=%s", e.AgentId);

		//遵循向前兼容原则，新增一个广播消息 modify by zl 20140918		
		bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);
		if (bRet)
		{
			string strUserInfo = cUserInfo;
			strUserInfo += "UserType=";
			strUserInfo += cUserType;
			strUserInfo += ";";
			memcpy(cUserInfo, strUserInfo.c_str(), strUserInfo.length());

			ex.UserInfo = cUserInfo;
		}
		else
		{
			Dbg("GetUserInfoFromCert failed!");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_INFO_FROM_CERT, 
				GetOutPutStr("%s%s", "GetUserInfoFromCert", "False").c_str());
			ex.UserInfo = "";
		}
		SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerifyEx, eMsgSig_UkeyVerifyEx, ex);
		Dbg("UserInfo=%s", ex.UserInfo);

		Dbg("%s has right to operator %s", m_strUserID.c_str(), m_strTerminalId.c_str());
	}	

	switch (nUserType)
	{
	case 0: 	//维护
		strUserType = "Maintian";
		break;
	case 1:     //物料管理
		strUserType = "MaterialManager";
		break;
	case 2:		//业务
		strUserType = "Business";
		break;
	case 3:		//Agent3
		strUserType = "Agent3";
		break;  
	default:
		strUserType = "unknown";
		Dbg("userType=%d is wrong",nUserType);
		break;
	}

	//只有维护类型电子钥匙写日志；频繁操作会导致日志写满，报错
	//物料管理和维护类电子钥匙日志上传方式待业务流程讨论清楚后，再写日志
	if (0)
	{
		if (0 == nUserType)
		{
			//写操作日志
			//操作起始时间
			time_t rawtime;
			struct tm * timeinfo;
			time(&rawtime);
			timeinfo = localtime(&rawtime);
			sprintf(m_StartTime, "%4d-%02d-%02d %02d:%02d:%02d",1900+timeinfo->tm_year, 1+timeinfo->tm_mon,timeinfo->tm_mday,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);

			//拼装日志记录
			string logRecord = "";
			logRecord += m_strTerminalId;
			logRecord += "@";
			logRecord += m_strUserID;
			logRecord += "@";
			logRecord += strUserType;
			logRecord += "@";
			logRecord += m_StartTime;
			logRecord += "@";
			logRecord += m_StartTime;	
			logRecord += ";";

			Dbg("WriteLogFile ,logRecord=%s",logRecord.c_str());
			DWORD dwRet = WriteLogFile(m_Handle, (BYTE*)logRecord.c_str(), logRecord.length());
			if (DONGLE_SUCCESS == dwRet)
			{
				Dbg("WriteLogFile success");
			}
			else
			{
				Dbg("WriteLogFile failed,errcode=0x%08X",dwRet);
				//MessageBox(0,"操作日志记录已满,请先登录作业平台上传操作日志！",NULL,0);
				return LOG_FULL_ERR;
			}
		}
	}
	
	return DONGLE_SUCCESS;
}

DWORD ConsoleFSM::VerifyTerminalNo()
{
	//校验终端操作权限
	Dbg("start to verify terminal nubmer");

	//获取电子钥匙中的授权终端列表
	//终端列表格式：任务号1，终端号1，有效开始时间，有效结束时间@任务号2，终端号2，有效开始时间，有效结束时间@任务号3，终端号3，有效开始时间，有效结束时间@
	char readDeviceList[4096] = {0};
	DWORD dwRet = GetAuthorizedDevices(m_Handle, readDeviceList);
	if (DONGLE_SUCCESS != dwRet)
	{
		Dbg("GetAuthorizedDevices failed,Return: 0x%08X",dwRet);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_AUTHER_DEVICES_LIST,
			GetOutPutStr("%s%08X", "GetAuthorizedDevices", dwRet).c_str());
		if (0xF000000F == dwRet)
		{
			Dbg("电子钥匙未下载设备的操作权限，请先下载!");
		}
		return TERMINAL_NO_TASK;
	}

	string strDeviceList = readDeviceList;
	int nLastPos = strDeviceList.find_last_of("@");
	if (-1 == nLastPos)
	{
		Dbg("find '@' in device list failed, DeviceList=%s", readDeviceList);
		return TERMINAL_AUTHORIZED_ERR;
	}

	string strNewDeviceList = strDeviceList.substr(0, nLastPos+1);
	Dbg("GetAuthorizedDevices success, DeviceList=%s", strNewDeviceList.c_str());

	//校验终端号
	BOOL bOverTime = FALSE;
	BOOL bNoBeginValid = FALSE;

	unsigned int nDeviceListLen = strNewDeviceList.length();	
	while (nDeviceListLen >= 0)
	{
		DWORD dwPos = FindSubStr(strNewDeviceList.c_str(), m_strTerminalId.c_str());
		if (-1 == dwPos)
		{
			Dbg("current TerminalNo=%s , can't find it in authorized device list=%s", m_strTerminalId.c_str(), strNewDeviceList.c_str());
			if (bOverTime)
			{
				//如果一个终端ID存在多个授权记录，且同时存在过期和未生效的记录，则报过期错误
				//MessageBoxA(NULL, "设备授权已过期，请确认授权时间!",NULL,0);
				Dbg("设备授权已过期，请确认授权时间!");
				return TERMINAL_AUTHORIZED_OVERTIME_ERR;
			}
			else if (bNoBeginValid)
			{
				//MessageBoxA(NULL, "设备授权未开始生效，请确认授权时间!",NULL,0);
				Dbg("设备授权未开始生效，请确认授权时间!");
				return TERMINAL_AUTHORIZED_NOTBEGIN_ERR;
			}
			else
			{
				//MessageBoxA(NULL, "电子钥匙不具备此设备操作授权，请确认是否已授权!",NULL,0);
				Dbg("电子钥匙不具备此设备操作授权，请确认是否已授权!");
				return TERMINAL_AUTHORIZED_ERR;
			}		
		}
		else
		{
			//兼容带任务ID和不带任务ID的操作任务
			int nSubCnt = 0;//分割符(",")的个数
			int nFirstRecordEndPos = strNewDeviceList.find_first_of("@");
			if(-1 != nFirstRecordEndPos)
			{
				string firstRecord = strNewDeviceList.substr(0, nFirstRecordEndPos+1);
				int nfirstSubEndPos = firstRecord.find_first_of(",");
				while (-1 != nfirstSubEndPos)
				{
					nSubCnt++;
					firstRecord = firstRecord.substr(nfirstSubEndPos+1, firstRecord.length()-nfirstSubEndPos-1);
					nfirstSubEndPos = firstRecord.find_first_of(",");
				}

				Dbg("找到[%d]个分隔符", nSubCnt);

				if (3==nSubCnt)
				{
					Dbg("任务包含TaskID");
					//获取任务ID长度
					string rest = strNewDeviceList.substr(0, dwPos);
					int restEndPos = rest.find_last_of("@");
					int nTaskIDLen = 0;
					if (-1 != restEndPos)
					{
						nTaskIDLen = dwPos - restEndPos - 1 -1;
					}
					else
					{
						nTaskIDLen = dwPos - 1;
					}

					//校验任务ID、终端号和准入时间
					string strRest = strNewDeviceList.substr(0, dwPos-nTaskIDLen-1);
					string strNew = strNewDeviceList.substr(dwPos-nTaskIDLen-1, strNewDeviceList.length()-strRest.length());
					unsigned int nEndPos = strNew.find_first_of("@");
					string strRecord = strNew.substr(0, nEndPos+1);	

					//获取任务ID
					unsigned int nRecordLen = strRecord.length();
					int nPos = strRecord.find_first_of(",");
					string strTaskId = strRecord.substr(0, nPos);		
					string strTemp = strRecord.substr(nPos+1, nRecordLen-nPos-1);

					//获取任务状态
					if (!VerifyTaskStatus(strTaskId.c_str()))
					{
						strNewDeviceList = strNewDeviceList.substr(dwPos-nTaskIDLen-1+nRecordLen, strNewDeviceList.length()-dwPos+nTaskIDLen-1-nRecordLen);
						nDeviceListLen -= (dwPos-nTaskIDLen-1 + nRecordLen);
						continue;
					}

					//获取终端号
					nRecordLen = strTemp.length();
					nPos = strTemp.find_first_of(",");
					string strDeviceId = strTemp.substr(0, nPos);
					strTemp = strTemp.substr(nPos+1, nRecordLen-nPos-1);

					//获取有效时间
					unsigned int nStartTimeEndPos = strTemp.find_first_of(",");
					string strStartTime = strTemp.substr(0, nStartTimeEndPos);	
					string strEndTime = strTemp.substr(nStartTimeEndPos+1,strTemp.length()-strStartTime.length()-2);

					if ((strStartTime.length() <=1) || (strEndTime.length() <= 1))
					{
						Dbg("此任务中设备授权有效期格式错误");
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}

					time_t tNow = NowTime();
					string strNowTime = Timet2Str(tNow);
					time_t tStartTime = Str2Timet(strStartTime);
					time_t tEndTime = Str2Timet(strEndTime);
					Dbg("current time=%s , TaskRecord=%s", strNowTime.c_str(), strRecord.c_str());

					if (tEndTime < tNow)
					{
						Dbg("此任务中的设备授权已过期");
						bOverTime = TRUE;
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}
					else if (tStartTime > tNow)
					{
						Dbg("此任务中的设备授权未开始生效");
						bNoBeginValid = TRUE;
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}
					else
					{
						Dbg("找到当前设备有效授权任务");
						return SUCCESS;
					}
				}
				else if (2==nSubCnt)
				{
					Dbg("任务不包含TaskID");

					//只校验终端号和准入时间
					string strRest = strNewDeviceList.substr(0, dwPos);
					string strNew = strNewDeviceList.substr(dwPos, strNewDeviceList.length()-strRest.length());
					unsigned int nEndPos = strNew.find_first_of("@");
					string strRecord = strNew.substr(0, nEndPos+1);	

					//获取终端号
					unsigned int nRecordLen = strRecord.length();
					int nPos = strRecord.find_first_of(",");
					string strDeviceId = strRecord.substr(0, nPos);		
					string strTemp = strRecord.substr(nPos+1, nRecordLen-nPos-1);

					//获取有效时间
					unsigned int nStartTimeEndPos = strTemp.find_first_of(",");
					string strStartTime = strTemp.substr(0, nStartTimeEndPos);	
					string strEndTime = strTemp.substr(nStartTimeEndPos+1,strTemp.length()-strStartTime.length()-2);

					if ((strStartTime.length() <=1) || (strEndTime.length() <= 1))
					{
						Dbg("此任务中设备授权有效期格式错误");
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}

					time_t tNow = NowTime();
					string strNowTime = Timet2Str(tNow);
					time_t tStartTime = Str2Timet(strStartTime);
					time_t tEndTime = Str2Timet(strEndTime);
					Dbg("current time=%s , TaskRecord=%s", strNowTime.c_str(), strRecord.c_str());

					if (tEndTime < tNow)
					{
						Dbg("此任务中的设备授权已过期");
						bOverTime = TRUE;
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}
					else if (tStartTime > tNow)
					{
						Dbg("此任务中的设备授权未开始生效");
						bNoBeginValid = TRUE;
						strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
						nDeviceListLen -= (dwPos + nRecordLen);
						continue;
					}
					else
					{
						Dbg("找到当前设备有效授权任务");
						return SUCCESS;
					}
				}
				else
				{
					//异常
					//MessageBoxA(NULL, "设备授权格式错误，请联系技术人员!",NULL,0);
					Dbg("设备授权格式错误，请联系技术人员!");
				}
			}				
		}
	}

	return SUCCESS;
}

DWORD ConsoleFSM::VerifyCardIssuerSN()
{
	//校验终端操作权限
	Dbg("start to verify card issuer sn");

	//获取电子钥匙中的授权终端列表
	//终端列表格式：任务号1，终端号1，有效开始时间，有效结束时间@任务号2，终端号2，有效开始时间，有效结束时间@任务号3，终端号3，有效开始时间，有效结束时间@
	char readDeviceList[4096] = {0};
	DWORD dwRet = GetAuthorizedDevices(m_Handle, readDeviceList);
	if (DONGLE_SUCCESS != dwRet)
	{

		Dbg("GetAuthorizedDevices failed,Return: 0x%08X",dwRet);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_AUTHER_DEVICES_LIST,
			GetOutPutStr("%s%08X", "GetAuthorizedDevices", dwRet).c_str());
		if (0xF000000F == dwRet)
		{
			//MessageBoxA(NULL, "电子钥匙未下载设备的操作权限，请先下载!",NULL,0);
			Dbg("电子钥匙未下载设备的操作权限，请先下载!");
		}
		return TERMINAL_NO_TASK;
	}

	string strDeviceList = readDeviceList;
	int nLastPos = strDeviceList.find_last_of("@");
	if (-1 == nLastPos)
	{
		Dbg("find '@' in device list failed, DeviceList=%s", readDeviceList);
		return TERMINAL_AUTHORIZED_ERR;
	}

	string strNewDeviceList = strDeviceList.substr(0, nLastPos+1);
	Dbg("GetAuthorizedDevices success, DeviceList=%s", strNewDeviceList.c_str());

	//校验终端号
	BOOL bOverTime = FALSE;
	BOOL bNoBeginValid = FALSE;

	unsigned int nDeviceListLen = strNewDeviceList.length();	
	while (nDeviceListLen >= 0)
	{
		DWORD dwPos = FindSubStr(strNewDeviceList.c_str(), m_CardIssuerSN.GetData());
		if (-1 == dwPos)
		{
			Dbg("current CardIssuerSN=%s , can't find it in authorized device list=%s", m_CardIssuerSN.GetData(), strNewDeviceList.c_str());
			if (bOverTime)
			{
				//如果一个终端ID存在多个授权记录，且同时存在过期和未生效的记录，则报过期错误
				Dbg("设备授权已过期，请确认授权时间!");
				return TERMINAL_AUTHORIZED_OVERTIME_ERR;
			}
			else if (bNoBeginValid)
			{
				Dbg("设备授权未开始生效，请确认授权时间!");
				return TERMINAL_AUTHORIZED_NOTBEGIN_ERR;
			}
			else
			{
				Dbg("电子钥匙不具备此设备操作授权，请确认是否已授权!");
				return TERMINAL_AUTHORIZED_ERR;
			}		
		}
		else
		{
			//校验任务号、卡机号和准入时间
			string strRest = strNewDeviceList.substr(0, dwPos-17);
			string strNew = strNewDeviceList.substr(dwPos-17, strNewDeviceList.length()-strRest.length());
			unsigned int nEndPos = strNew.find_first_of("@");
			string strRecord = strNew.substr(0, nEndPos+1);

			//获取任务ID
			unsigned int nRecordLen = strRecord.length();
			int nPos = strRecord.find_first_of(",");
			string strTaskId = strRecord.substr(0, nPos);		
			string strTemp = strRecord.substr(nPos+1, nRecordLen-nPos-1);
			//获取任务状态
			if(16 != strTaskId.length())
			{
				Dbg("<TaskId=%s>任务ID的长度不等于16，格式错误!",strTaskId.c_str());
				strNewDeviceList = strNewDeviceList.substr(dwPos-17+nRecordLen, strNewDeviceList.length()-dwPos+17-nRecordLen);
				nDeviceListLen -= (dwPos-17 + nRecordLen);
				continue;
			}

			if (!VerifyTaskStatus(strTaskId.c_str()))
			{
				strNewDeviceList = strNewDeviceList.substr(dwPos-17+nRecordLen, strNewDeviceList.length()-dwPos+17-nRecordLen);
				nDeviceListLen -= (dwPos-17 + nRecordLen);
				continue;
			}

			//获取卡机号
			nRecordLen = strTemp.length();
			nPos = strTemp.find_first_of(",");
			string strDeviceId = strTemp.substr(0, nPos);
			strTemp = strTemp.substr(nPos+1, nRecordLen-nPos-1);

			//获取有效时间
			unsigned int nStartTimeEndPos = strTemp.find_first_of(",");
			string strStartTime = strTemp.substr(0, nStartTimeEndPos);	
			string strEndTime = strTemp.substr(nStartTimeEndPos+1,strTemp.length()-strStartTime.length()-2);

			if ((strStartTime.length() <=1) || (strEndTime.length() <= 1))
			{
				Dbg("此任务中设备授权有效期格式错误");
				strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
				nDeviceListLen -= (dwPos + nRecordLen);
				continue;
			}

			time_t tNow = NowTime();
			string strNowTime = Timet2Str(tNow);
			time_t tStartTime = Str2Timet(strStartTime);
			time_t tEndTime = Str2Timet(strEndTime);
			Dbg("current time=%s , TaskRecord=%s", strNowTime.c_str(), strRecord.c_str());

			if (tEndTime < tNow)
			{
				Dbg("此任务中的设备授权已过期");
				bOverTime = TRUE;
				strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
				nDeviceListLen -= (dwPos + nRecordLen);
				continue;
			}
			else if (tStartTime > tNow)
			{
				Dbg("此任务中的设备授权未开始生效");
				bNoBeginValid = TRUE;
				strNewDeviceList = strNewDeviceList.substr(dwPos+nRecordLen, strNewDeviceList.length()-dwPos-nRecordLen);
				nDeviceListLen -= (dwPos + nRecordLen);
				continue;
			}
			else
			{
				Dbg("找到当前设备有效授权任务");
				return SUCCESS;
			}		
		}
	}

	return SUCCESS;
}

DWORD ConsoleFSM::CheckCertVaildity()
{
	time_t tNow = NowTime();

	char strRootStartTime[32] = {0};
	char strRootEndTime[32] = {0};
	BOOL bRet = GetValidityFromCert(ROOT_CERT_PATH, FORMAT_PEM, strRootStartTime, strRootEndTime);
	if (!bRet)
	{
		Dbg("获取根证书有效期失败");
		return GET_CERT_VALIDITY_ERR;
	}

	Dbg("根证书有效期[%s,%s]", strRootStartTime, strRootEndTime);
	string strNewRootStartTime = "20";
	string strNewRootEndTime = "20";
	strNewRootStartTime += strRootStartTime;
	strNewRootEndTime += strRootEndTime;
	time_t tRootStartTime = Str2Timet(strNewRootStartTime.c_str(), "%4d%2d%2d%2d%2d%2d");
	time_t tRootEndTime = Str2Timet(strNewRootEndTime, "%4d%2d%2d%2d%2d%2d");

	UINT nRestSecond = tRootEndTime - tNow;
	UINT nRestDay = nRestSecond/(60*60*24);
	if (nRestDay <= 15)
	{
		/*CString msg;
		msg.Format(_T("电子钥匙即将过期，剩余有效天数[%d]，请及时续期!"), nRestDay);
		::MessageBox(NULL,msg, "提示",0);*/
		Dbg("根证书即将过期, 有效剩余天数：%d", nRestDay);
		return OVERTTIMER_WAR;
	}

	char strCaStartTime[32] = {0};
	char strCaEndTime[32] = {0};
	bRet = GetValidityFromCert(CA_CERT_PATH, FORMAT_PEM, strCaStartTime, strCaEndTime);
	if (!bRet)
	{
		Dbg("获取分行证书有效期失败");
		return GET_CERT_VALIDITY_ERR;
	}

	Dbg("分行证书有效期[%s,%s]", strCaStartTime, strCaEndTime);
	string strNewCaStartTime = "20";
	string strNewCaEndTime = "20";
	strNewCaStartTime += strCaStartTime;
	strNewCaEndTime += strCaEndTime;
	time_t tCaStartTime = Str2Timet(strNewCaStartTime.c_str(), "%4d%2d%2d%2d%2d%2d");
	time_t tCaEndTime = Str2Timet(strNewCaEndTime, "%4d%2d%2d%2d%2d%2d");

	nRestSecond = tCaEndTime - tNow;
	nRestDay = nRestSecond/(60*60*24);
	if (nRestDay <= 15)
	{
		/*CString msg;
		msg.Format(_T("电子钥匙即将过期，剩余有效天数[%d]，请及时续期!"), nRestDay);
		::MessageBox(NULL,msg, "提示",0);*/
		Dbg("分行证书即将过期, 有效剩余天数：%d", nRestDay);
		return OVERTTIMER_WAR;
	}

	char strUserStartTime[32] = {0};
	char strUserEndTime[32] = {0};
	bRet = GetValidityFromCert(USER_CERT_PATH, FORMAT_PEM, strUserStartTime, strUserEndTime);
	if (!bRet)
	{
		Dbg("获取用户证书有效期失败");
		return GET_CERT_VALIDITY_ERR;
	}

	Dbg("用户证书有效期[%s,%s]", strUserStartTime, strUserEndTime);
	string strNewUserStartTime = "20";
	string strNewUserEndTime = "20";
	strNewUserStartTime += strUserStartTime;
	strNewUserEndTime += strUserEndTime;
	time_t tUserStartTime = Str2Timet(strNewUserStartTime.c_str(), "%4d%2d%2d%2d%2d%2d");
	time_t tUserEndTime = Str2Timet(strNewUserEndTime, "%4d%2d%2d%2d%2d%2d");

	nRestSecond = tUserEndTime - tNow;
	nRestDay = nRestSecond/(60*60*24);
	if (nRestDay <= 15)
	{
		/*CString msg;
		msg.Format(_T("电子钥匙即将过期，剩余有效天数[%d]，请及时续期!"), nRestDay);
		::MessageBox(NULL,msg, "提示",0);*/
		Dbg("用户证书即将过期, 有效剩余天数：%d", nRestDay);
		return OVERTTIMER_WAR;
	}

	return SUCCESS;
}

BOOL ConsoleFSM::GetUserInfo()
{
	//电子钥匙HID
	char strUkeyHID[32] = {0};
	bool bRet = GetHIDFromCert(USER_CERT_PATH, FORMAT_PEM, strUkeyHID);
	if (!bRet)
	{
		Dbg("GetHIDFromCert failed");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_EKEY_HID, 
			GetOutPutStr("%s%s", "GetHIDFromCert", "False").c_str());

		return FALSE;
	}
	m_strKeyHID = strUkeyHID;
	Dbg("HID=%s", m_strKeyHID.c_str());

	//用户ID
	char strUserID[32] = {0};
	bRet = GetUserIDFromCert(USER_CERT_PATH, FORMAT_PEM, strUserID);
	if (!bRet)
	{
		Dbg("GetUserIDFromCert failed");
		return FALSE;
	}
	m_strUserID = strUserID;
	Dbg("userId=%s", m_strUserID.c_str());

	//用户类型
	char cUserType[3] = {0};
	bRet = GetUserTypeFromCert(USER_CERT_PATH, FORMAT_PEM, cUserType);
	if (!bRet)
	{
		Dbg("GetUserTypeFromCert failed");
		return FALSE;
	}
	m_strUserType = cUserType;
	Dbg("userType=%s", m_strUserType.c_str());

	return TRUE;
}

//获取当前连接的卡箱号
BOOL ConsoleFSM::GetIssuerNum()
{
	ErrorCodeEnum eErr = Error_Succeed;
	if (m_pCardIssuerService == NULL)
	{
		m_pCardIssuerService = new CardIssuerService_ClientBase(this->GetEntityBase());
		eErr = m_pCardIssuerService->Connect();
		if (Error_Succeed != eErr) 
		{
			Dbg("CardIssuer connected failed.");
			m_pCardIssuerService = NULL;
			return FALSE;
		}
		else
		{
			Dbg("CardIssuer connected ok.");
		}
	}

	Dbg("CardIssuer connected.");
	CardIssuerService_GetSCIInfo_Req req;
	CardIssuerService_GetSCIInfo_Ans ans;
	eErr = m_pCardIssuerService->GetSCIInfo(req, ans,5000);
	if (Error_Succeed != eErr)
	{
		Dbg("GetSCIInfo failed.");
		m_pCardIssuerService = NULL;
		return FALSE;
	}
	else
	{
		m_CardIssuerSN = ans.DevSN;
		Dbg("GetSCIInfo succeed, DevSN=[%s]", m_CardIssuerSN);
	}

	return TRUE;
}

//GPIO控制,true:打开；false：关闭
ErrorCodeEnum ConsoleFSM::OpenGpio(BOOL bOpen)
{
	ErrorCodeEnum eErr = Error_Succeed;
	if (m_pDeviceControlService == NULL)
	{
		m_pDeviceControlService = new DeviceControlService_ClientBase(this->GetEntityBase());
		eErr = m_pDeviceControlService->Connect();
		if (Error_Succeed != eErr) 
		{
			Dbg("DeviceControl connected failed.");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_DEVICECONTROL_CONNECT,
				GetOutPutStr("%s%08X", "Connect", eErr).c_str());
			m_pDeviceControlService = NULL;
			return eErr;
		}
		else
		{
			Dbg("DeviceControl connected ok.");
		}
	}

	Dbg("DeviceControl connected.");
	DeviceControlService_USB_Req req;
	DeviceControlService_USB_Ans ans;

	req.open = bOpen;
	eErr = m_pDeviceControlService->USB(req, ans,10000);
	if (Error_Succeed != eErr)
	{
		Dbg("m_pDeviceControlService->USB failed.");
		m_pDeviceControlService = NULL;
		return eErr;
	}
	else
	{
		Dbg("m_pDeviceControlService->USB succeed, bOpen[%d]", bOpen);
	}

	return eErr;
}

CSmartPointer<IEntityFunction> ConsoleFSM::GetFunction()
{
	return m_pEntity->GetFunction(); 
}
ErrorCodeEnum ConsoleFSM::SetRunConfig()
{
	char* pSap = "00000001";
	char* pTime = "493751309";
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error_Succeed == Error) 
	{
		CSimpleStringA strSAP;
		Error = spConfig->ReadConfigValue("UserInfo", "SAP", strSAP);
		if ((Error_Succeed == Error) && (strSAP.IsNullOrEmpty()))
		{
			Error = spConfig->WriteConfigValue("UserInfo", "SAP", pSap);
			Error = spConfig->WriteConfigValue("UserInfo", "Time", pTime);
		}		
	}

	return Error;
}

ErrorCodeEnum ConsoleFSM::LoadRunConfig()
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed) 
	{
		Error = spConfig->ReadConfigValueInt("Ukey", "UkeyStatus", m_nUkeyStatus);
	}

	return Error;
}

ErrorCodeEnum ConsoleFSM::LoadCenterConfig()
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_CenterSetting, spConfig);
	if (Error_Succeed == Error) 
	{
		Error = spConfig->ReadConfigValueInt("MaintainWatcher", "CheckTerMinalNo", m_nCheckTerminalNo);
		if (Error_Succeed == Error)
		{
			Dbg("get CheckTerMinalNo=%d from CenterSetting.ini", m_nCheckTerminalNo);
		} 
		else
		{
			Dbg("get CheckTerMinalNo from CenterSetting.ini failed");
		}

		Error = spConfig->ReadConfigValueInt("MaintainWatcher", "CheckMaintainTask", m_nCheckMaintainTask);
		if (Error_Succeed == Error)
		{
			Dbg("get CheckMaintainTask=%d from CenterSetting.ini", m_nCheckMaintainTask);
		} 
		else
		{
			Dbg("get CheckMaintainTask from CenterSetting.ini failed");
		}

		Error = spConfig->ReadConfigValueInt("MaintainWatcher", "Verify_BlackList", m_nVerifyBlackList);
		if (Error_Succeed == Error)
		{
			Dbg("get Verify_BlackList=%d from CenterSetting.ini", m_nVerifyBlackList);
		} 
		else
		{
			Dbg("get Verify_BlackList from CenterSetting.ini failed");
		}

		Error = spConfig->ReadConfigValueInt("InteractiveControl", "SurveillanceRecordAllowed", g_nSurveillanceRecordAllowed);
		if (Error_Succeed == Error)
		{
			Dbg("get SurveillanceRecordAllowed=%d from CenterSetting.ini", g_nSurveillanceRecordAllowed);
		} 
		else
		{
			Dbg("get SurveillanceRecordAllowed from CenterSetting.ini failed");
		}
	}

	return Error;
}

ErrorCodeEnum ConsoleFSM::LoadServerConfig()
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Software, spConfig);
	if (Error == Error_Succeed) 
	{
		Error = spConfig->ReadConfigValue("VerifyKey", "Key", m_StringVerifyKey);
		if(Error == Error_Succeed)
			Error = spConfig->ReadConfigValue("GuiConsole", "Name", m_StringConsoleName);
	}

	return Error;
}

ErrorCodeEnum ConsoleFSM::LoadRootConfig()
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spConfig);
	if (Error == Error_Succeed) 
	{
		Error = spConfig->ReadConfigValue("Terminal", "MachineType", m_strMachineType);
		if(Error == Error_Succeed)
		{
			Error = spConfig->ReadConfigValue("Terminal", "Site", m_strSite);
			if (Error != Error_Succeed)
			{
				Dbg("ReadConfigValue, get Site value failed");
			}
		}
		else
		{
			Dbg("ReadConfigValue, get MachineType value failed");
		}

		Error = spConfig->ReadConfigValue("Video", "EwsCamera", g_strEwsCameraID);
		if (Error_Succeed == Error)
		{
			Dbg("get EwsCamera=%s from root.ini", g_strEwsCameraID);
		} 
		else
		{
			Dbg("get EwsCamera from root.ini failed");
		}
	}

	return Error;
}

void ConsoleFSM::CloseConnection()
{
	if (m_bAns && m_pConnection != NULL)
	{
		m_pConnection->Close();
		m_pConnection->DecRefCount();
		m_pConnection = NULL;
		m_bAns = FALSE;

		Dbg("Close m_pConnection");
	}
}

void ConsoleFSM::s0_on_entry()
{
	//MessageBoxA(0,0,0,0);
	Dbg("s0_on_entry, starting");
	unsigned int count = 0;
	DWORD dwRet = 0;
	//状态机启动时检测电子钥匙
	dwRet = FindUsbKey(&g_USBKeyInfo, &count);
	if (dwRet == DONGLE_SUCCESS)
	{
		Dbg("when s0_on_entry,FindUsbKey success!");
		if (!g_FindKey)
		{
			g_FindKey = TRUE;
			PostEventLIFO(new FSMEvent(USER_EVT_JMP_UKEYINSERT));
		}		
	}
	else
	{	
		Dbg("when s0_on_entry,FindUsbKey Fail!");
		LogWarn(Severity_Low,Error_Unexpect, ERR_MAINTAINWATCHER_CANNOT_FIND_EKEY,
			GetOutPutStr("%s%d", "FindUsbKey", dwRet).c_str());
		if (g_FindKey)
		{
			g_FindKey = FALSE;
			PostEventLIFO(new FSMEvent(USER_EVT_JMP_UKEYPULLOUT));
			return;
		}
						
		ScheduleTimer(1, 10);
	}
}
void ConsoleFSM::s0_on_exit()
{
	CancelTimer(1);
}
unsigned int ConsoleFSM::s0_on_event( FSMEvent* event )
{
	//收到回复，释放链接
	CloseConnection();

	if (EVT_TIMER == event->iEvt)
	{
		ScheduleTimer(1, 100);
	}
	else if (USER_EVT_JMP_UKEYINSERT == event->iEvt)
	{
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_UKEYINSERT));
	}
	else if (USER_EVT_JMP_UKEYPULLOUT == event->iEvt)
	{
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_UKEYPULLOUT));
	}

	return 0;
}

void ConsoleFSM::s1_on_entry()
{
	Dbg("s1_on_entry");
	Dbg("检测到电子钥匙插入");

	//收到回复，释放链接
	CloseConnection();
		
	LogEvent(Severity_Middle, EVENT_UKEY_INSERTED, "Ukey insert!");

	UkeyInsert e = {};
	for (int i=0; i<8; i++)
	{
		string id;
		sprintf((char*)id.c_str(),"%02X", g_USBKeyInfo.m_HID[i]);
		e.UkeyID += id.c_str();
	}
	SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyInsert, eMsgSig_UkeyInsert, e);
	Dbg("UkeyID=%s", e.UkeyID);
		

	//根据是否在首页状态，决定下一个状态机状态
	//获取首页状态
	GetMenuStatus();

	if (m_bMenu)
	{
		//首页状态，进入验证流程
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_VERIFYPWD));
	}
	else
	{
		//非首页状态
		PostEventLIFO(new FSMEvent(USER_EVT_JMP_RELEASE));
	}
}
void ConsoleFSM::s1_on_exit()
{
	CancelTimer(1);
}
unsigned int ConsoleFSM::s1_on_event(FSMEvent* event)
{
	//收到回复，释放链接
	CloseConnection();

	if (event->iEvt == EVT_TIMER) 
	{
		//Dbg("Verify cert err");
	} 

	if (event->iEvt == USER_EVT_JMP_UKEYPULLOUT)
	{	
		Dbg("s1_on_event receive USER_EVT_JMP_UKEYPULLOUT");
	}

	return 0;
}

void ConsoleFSM::s2_on_entry()
{
	Dbg("s2_on_entry");
	Dbg("检测到电子钥匙拔出");

	//收到回复，释放链接
	CloseConnection();

	//处理拔出状态
	g_bWorkingStatus = FALSE;
	g_bErrStatus = FALSE;
	m_bInputpwdDlg = FALSE;
	LogEvent(Severity_Middle, EVENT_UKEY_PULLOUT, "Ukey pullout!");

	UkeyPullOut e = {};	
	SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyPullOut, eMsgSig_UkeyPullOut, e);

	PostEventLIFO(new FSMEvent(USER_EVT_JMP_RELEASE));
}
void ConsoleFSM::s2_on_exit()
{
	CancelTimer(2);
}
unsigned int ConsoleFSM::s2_on_event(FSMEvent* event)
{
	if (event->iEvt == EVT_TIMER) 
	{			
	}

	return 0;
}

void ConsoleFSM::s3_on_entry()
{
	Dbg("s3_on_entry");
	Dbg("开始启动验证线程");

	//收到回复，释放链接
	CloseConnection();
	
	//启动验证线程
	if (!g_HasVerifyTask)
	{
		Dbg("创建等待验密线程");
		GuidVerifyTask* pVerifyTask = new GuidVerifyTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pVerifyTask);

		g_HasVerifyTask = TRUE;
	}
	
	if (!m_bInputpwdDlg && g_FindKey)
	{
		//发送弹出密码输入界面
		InputPwd e = {};
		SpSendBroadcast(m_pEntity->GetFunction(), eMsg_InputPwd, eMsgSig_InputPwd, e);
		Dbg("弹出密码输入界面");
		m_bInputpwdDlg = TRUE;
	}
}
void ConsoleFSM::s3_on_exit()
{
}
unsigned int ConsoleFSM::s3_on_event(FSMEvent* event)
{
	if (USER_EVT_JMP_PWDSUCCESS == event->iEvt)
	{
		DWORD dwRet = 0;
		Dbg("revceive USER_EVT_JMP_PWDSUCCESS, m_strPwd[%s],m_errcode[%08X]",m_strPwd, m_errcode);
		if (!m_strPwd.IsNullOrEmpty() && ((0 == m_errcode) || (OVERTTIMER_WAR == m_errcode)))
		{
			//清空密码
			m_strPwd.Clear();

			if (0)
			{
				BOOL bRet = CheckUSBKeyLife(m_strKeyHID.c_str());
				if (!bRet)
				{
					Dbg("CheckUSBKeyLife failed!");
					LogWarn(Severity_Low, Error_Unexpect, ERR_MAINTAINWATCHER_CHECK_EKEY_LIFE,
						GetOutPutStr("%s%s", "CheckUSBKeyLife", "False").c_str());
				}
			}

			//获取用户类型，根据不同的用户类型发送不同的事件
			char cUserType[3] = {0};
			BOOL bRet = GetUserTypeFromCert(USER_CERT_PATH, FORMAT_PEM, cUserType);
			if (!bRet)
			{
				Dbg("GetUserTypeFromCert err!");
				LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_TYPE_FROM_CERT, 
					GetOutPutStr("%s%s%s%s", "GetUserTypeFromCert", "False","cUserType", cUserType).c_str());
				PostEventLIFO(new FSMEvent(USER_EVT_JMP_RELEASE));
				return 1;
			}

			UkeyVerify e = {};
			UkeyVerifyEx ex = {};	
			char cUserInfo[2048] = {0};
			char cUserID[17] = {0};
			char cOfficeID[9] = {0};
			int nUserType = atoi(cUserType);

			switch(nUserType)
			{
			case USER_TYPE_MAINTAIN:
				//LogEvent(Severity_Middle, EVENT_UKEY_MAINTTIAN, "维护权限!");
				LogEvent(Severity_Middle, EVENT_UKEY_LOW_LEVEL, "Start local maintance!");
				if (0 == m_nCheckMaintainTask)
				{
					bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);
					if (bRet)
					{
						string strUserInfo = cUserInfo;
						strUserInfo += "UserType=";
						strUserInfo += cUserType;
						strUserInfo += ";";
						memcpy(cUserInfo, strUserInfo.c_str(), strUserInfo.length());

						ex.UserInfo = cUserInfo;
					}
					else
					{
						Dbg("GetUserInfoFromCert failed!");
						LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_INFO_FROM_CERT, 
							GetOutPutStr("%s%s%s%s", "GetUserInfoFromCert", "False", "cUserInfo", cUserInfo).c_str());
						ex.UserInfo = "";
					}
					SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyNormalMaintain, eMsgSig_UkeyNormalMaintain, ex);
					Dbg("UserInfo=%s", ex.UserInfo);

					SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerifyEx, eMsgSig_UkeyVerifyEx, ex);
					Dbg("eMsg_UkeyVerifyEx:UserInfo=%s", ex.UserInfo);
				}
				break;

			case USER_TYPE_MATERIAL_MANAGER:
				LogEvent(Severity_Middle, EVENT_UKEY_MATERIAL_MANAGER, "物料管理权限!");
				if (0 == m_nCheckTerminalNo)
				{
					//改成广播方式发送事件 modify by zl 20140619			
					bRet = GetUserIDFromCert(USER_CERT_PATH, FORMAT_PEM, cUserID);
					if (bRet)
					{
						e.AgentId = cUserID;
					}
					else
					{
						Dbg("GetUserIDFromCert failed!");
						e.AgentId = "";	
					}
					SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerify, eMsgSig_UkeyVerify, e);
					Dbg("AgentId=%s", e.AgentId);

					//遵循向前兼容原则，新增一个广播消息 modify by zl 20140918		
					bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);
					if (bRet)
					{
						string strUserInfo = cUserInfo;
						strUserInfo += "UserType=";
						strUserInfo += cUserType;
						strUserInfo += ";";
						memcpy(cUserInfo, strUserInfo.c_str(), strUserInfo.length());

						ex.UserInfo = cUserInfo;
					}
					else
					{
						Dbg("GetUserInfoFromCert failed!");
						LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_INFO_FROM_CERT, 
							GetOutPutStr("%s%s%s%s", "GetUserInfoFromCert", "False", "cUserInfo", cUserInfo).c_str());
						ex.UserInfo = "";
					}
					SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerifyEx, eMsgSig_UkeyVerifyEx, ex);
					Dbg("UserInfo=%s", ex.UserInfo);
				}

				break;

			case USER_TYPE_CUSTOMER_MANAGER:
				LogEvent(Severity_Middle, EVENT_UKEY_CUSTOMER_MANAGER, "客户经理权限!");
				bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);
				if (bRet)
				{
					string strUserInfo = cUserInfo;
					strUserInfo += "UserType=";
					strUserInfo += cUserType;
					strUserInfo += ";";
					memcpy(cUserInfo, strUserInfo.c_str(), strUserInfo.length());

					ex.UserInfo = cUserInfo;
				}
				else
				{
					Dbg("GetUserInfoFromCert failed!");
					LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_GET_USER_INFO_FROM_CERT, 
						GetOutPutStr("%s%s%s%s", "GetUserInfoFromCert", "False", "cUserInfo", cUserInfo).c_str());
					ex.UserInfo = "";
				}
				SpSendBroadcast(m_pEntity->GetFunction(), eMsg_UkeyVerifyEx, eMsgSig_UkeyVerifyEx, ex);
				Dbg("UserInfo=%s", ex.UserInfo);

				Dbg("m_strMachineType=%s", m_strMachineType.GetData());
				break;

			case USER_TYPE_AGENT3:
				LogEvent(Severity_Middle, EVENT_UKEY_AGENT3, "Agent3用户权限!");
				break;

			case USER_TYPE_FINANCING_MANAGER:
				LogEvent(Severity_Middle, EVENT_UKEY_FINANCING_MANAGER, "理财经理权限!");
				break;

			default:
				Dbg("未知用户类型!");
				break;
			}				
		}
		else
		{
			Dbg("VerifyUser failed, errcode=0x%08X ", m_errcode);
			char tmp[100] = { 0 };
			sprintf(tmp,"VerifyUser failed, errcode=0x%08X",m_errcode);
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_EKEY_VERIFY, 
				GetOutPutStr("%s%08X", "VerifyUser", m_errcode).c_str());
			//清空密码
			m_strPwd.Clear();
			m_errcode = 0;
			g_bErrStatus = TRUE;
		}

		PostEventLIFO(new FSMEvent(USER_EVT_JMP_RELEASE));
	}
	else if (USER_EVT_JMP_PWDERR == event->iEvt)
	{
		//当验证错误且电子钥匙没有拔出时，状态机停留在s3验证状态，等待用户下一步操作
		Dbg("when verifyUser return failed, keep s3 state!");	
	}

	return 0;
}

void ConsoleFSM::s4_on_entry()
{
	Dbg("s4_on_entry, release");

	//收到回复，释放链接
	CloseConnection();

	//close电子钥匙,关闭界面
	DWORD dwRet = CloseUsbKey(m_Handle);
	if (DONGLE_SUCCESS != dwRet)
	{
		Dbg("CloseUsbKey failed,errcode= 0x%08X", dwRet);
		char tmp[100];
		sprintf(tmp, "CloseUsbKey failed,errcode= 0x%08X", dwRet);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_CLOSE_EKEY,
			GetOutPutStr("%s%d", "CloseUsbKey", dwRet).c_str());
	}

	if (AsyncStopEntity(m_StringConsoleName,NULL)==Error_Succeed)
	{
		ScheduleTimer(4, 10);
		Dbg("release console success!");
	} 
	else//if release console fail
	{
		Dbg("release console fail!");
		LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_RELEASE_CONSOLE,
			GetOutPutStr("%s%s", "AsyncStopEntity", "False").c_str());
		ScheduleTimer(4, 10);
	}
}
void ConsoleFSM::s4_on_exit()
{
	CancelTimer(4);
}
unsigned int ConsoleFSM::s4_on_event(FSMEvent* event)
{
	if (event->iEvt == EVT_TIMER) 
	{
		// goto s0
		Dbg("goto starting");
	}
	return 0;
}

ErrorCodeEnum ConsoleFSM::AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StartEntity(entity_name, cmdline, spWait);
		//if (Error == Error_Succeed) {
		//	callback_entry *entry = new callback_entry();
		//	entry->pRawData = pData;
		//	entry->EntityName = entity_name;
		//	entry->ErrorResult = Error_Unexpect;
		//	entry->op = OP_START_ENTITY;
		//	//spWait->SetCallback(this, entry);
		//}z
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum ConsoleFSM::AsyncStopEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StopEntity(entity_name, spWait);
		//if (Error == Error_Succeed) {
		//	callback_entry *entry = new callback_entry();
		//	entry->pRawData = pData;
		//	entry->EntityName = entity_name;
		//	entry->ErrorResult = Error_Unexpect;
		//	entry->op = OP_STOP_ENTITY;
		//	//spWait->SetCallback(this, entry);
		//}
		return Error;
	} 
	else 
	{
		return Error_NoPrivilege;
	}
}
static char certBlackListKey[100] = "Certificate of Black List";//伪随机化因子

/*初始化函数*/
void Black_init(unsigned char *s, unsigned char *key, unsigned long Len)
{
	int i = 0, j = 0;
	char k[256] = { 0 };
	unsigned char tmp = 0;
	for (i = 0; i < 256; i++)
	{
		s[i] = i;
		k[i] = key[i%Len];
	}
	for (i = 0; i < 256; i++)
	{
		j = (j + s[i] + k[i]) % 256;
		tmp = s[i];
		s[i] = s[j];//交换s[i]和s[j]
		s[j] = tmp;
	}
}

/*加解密*/
void Black_crypt(unsigned char*s, unsigned char*Data, unsigned long  Len)
{
	int i = 0, j = 0, t = 0;
	unsigned long k = 0;
	unsigned char tmp;
	for (k = 0; k < Len; k++)
	{
		i = (i + 1) % 256;
		j = (j + s[i]) % 256;
		tmp = s[i];
		s[i] = s[j];//交换s[x]和s[y]
		s[j] = tmp;
		t = (s[i] + s[j]) % 256;
		unsigned char tempK = Data[k] ^ s[t];
		if(0 != tempK  && '\n' != tempK)
			Data[k] ^= s[t];
	}
}

void certBlackCrypt(char *dstStr, char *srcStr)
{
	unsigned char encryptStr[256] = { 0 };
	Black_init(encryptStr, (unsigned char*)certBlackListKey, strlen(certBlackListKey));//已经完成了初始化伪随机子

	memcpy(dstStr, srcStr, strlen(srcStr) + 1);
	Black_crypt(encryptStr, (unsigned char *)dstStr, strlen(srcStr));
}

BOOL checkDirExist(TCHAR *filePath)
{
	BOOL b = CreateDirectory(filePath, NULL);
	if (b || (GetLastError() == ERROR_ALREADY_EXISTS))
	{
		return TRUE;
	}
	return FALSE;
}
BOOL checkFileExist(TCHAR *filePath, BOOL isCreate)
{
	HANDLE hFile = isCreate ? CreateFile(filePath, GENERIC_READ, 0, NULL, CREATE_ALWAYS, NULL, NULL)
		: CreateFile(filePath, GENERIC_READ, 0, NULL, OPEN_EXISTING, NULL, NULL);

	if (hFile == INVALID_HANDLE_VALUE)
		return FALSE;
	CloseHandle(hFile);
	return TRUE;
}
BOOL IsCertInBlack(char *certNo)
{
	char activePath1[1024], activePath2[1024], realActivePath[1024], dirPath[1024], blackListPath[1024];

	sprintf(activePath1, "D:\\Run\\version\\active.txt");
	sprintf(activePath2, "C:\\Run\\version\\active.txt");
	if (checkFileExist(activePath1, FALSE))
	{
		memcpy(realActivePath, activePath1, strlen(activePath1) + 1);
		sprintf(dirPath, "D:\\Run\\version");
	}
	else if (checkFileExist(activePath2, FALSE))
	{
		memcpy(realActivePath, activePath2, strlen(activePath2) + 1);
		sprintf(dirPath, "C:\\Run\\version");
	}
	else
		return FALSE;
	//read version
	char buffer[255];
	ifstream iniFile(realActivePath);
	iniFile.getline(buffer, 100);
	iniFile.close();
	sprintf(blackListPath, "%s\\%s\\cfg\\certs\\CertBlackList.txt", dirPath, buffer);
	//CertBlackList.txt文件是否存在,不存在则并未创建该文件，不进行黑名单检测
	ifstream blackFile(blackListPath);
	if (!blackFile.is_open())
		return FALSE;
	char lineBuf[200], encrpyKey[200], showMsg[200];
	while (!blackFile.eof())
	{
		blackFile.getline(lineBuf, 200);
		certBlackCrypt(encrpyKey, lineBuf);
		sprintf(showMsg, "Compare CertNo:%s to BlackKey:%s", certNo, encrpyKey);
		Dbg(showMsg);
		if (strlen(lineBuf) < 5)
			continue;
		if (!memcmp(certNo, encrpyKey, strlen(certNo) > strlen(encrpyKey) ? strlen(encrpyKey) : strlen(certNo) ))
		{
			blackFile.close();
			return TRUE;
		}
	}
	blackFile.close();
	return FALSE;
}

BOOL GetRecomenderIdFromUserInfo(char* pRecommenderId)
{
	if (NULL == pRecommenderId)
	{
		return false;
	}

	char cUserInfo[MAX_EXT_LEN] = {0};
	bool bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);
	if (!bRet)
	{
		return false;
	}

	string strUserInfo = cUserInfo;
	int len = strUserInfo.length();

	int nPos = strUserInfo.find("RecommenderOfficeID=");
	if (nPos < 0)
	{			
		return false;
	}		

	string strRecord = strUserInfo.substr(nPos, len-1);

	nPos = strRecord.find_first_of(";");
	if (nPos < 0)
	{			
		return false;
	}

	string strRecommenderOfficeIDRecord = strRecord.substr(0, nPos);
	if (strRecommenderOfficeIDRecord.length() <= 20)
	{			
		return false;
	}

	string RecommenderOfficeID = strRecommenderOfficeIDRecord.substr(20,nPos -20);

	memcpy(pRecommenderId, RecommenderOfficeID.c_str(), MAX_OFFICEID_LEN);

	return TRUE;
}

BOOL ConsoleFSM::SetRecommender()
{
	Recommender ex = {};
	char cRecommenderID[9] = {0};

	Dbg("start SetRecommender");

	//从用户证书中获取推荐人ID		
	BOOL bRet = GetRecomenderIdFromUserInfo(cRecommenderID);
	if (bRet)
	{	
		ex.OfficeID = cRecommenderID;
	}
	else
	{
		Dbg("GetUserInfoFromCert failed!");
		ex.OfficeID = "";
	}

	SpSendBroadcast(m_pEntity->GetFunction(), eMsg_Recommender, eMsgSig_Recommender, ex);
	Dbg("OfficeID=%s", ex.OfficeID);
	return TRUE;
}

void ConsoleFSM::GetEkeyStatus(int &status) {
	status = g_FindKey?1:0;
}