scbc_repos/SATHelper/SATHelper/Global.cpp

#include "stdafx.h"
#include "Global.h"
#include <tchar.h>
#include <direct.h>
#include <SetupAPI.h>
#include <InitGuid.h>
#include <WinIoCtl.h>
#include <hidsdi.h>
#pragma comment(lib, "Hid.lib")
#pragma comment(lib, "SetupAPI.lib")


// 枚举所有USB设备;
DEFINE_GUID(GUID_DEVINTERFACE_USB_DEVICE, 0xA5DCBF10L, 0x6530, 0x11D2, 0x90, 0x1F, 0x00, 0xC0, 0x4F, 0xB9, 0x51, 0xED);
#define	GUID_CLASS_USB_DEVICE	GUID_DEVINTERFACE_USB_DEVICE  

DEFINE_GUID(GUID_DEVINTERFACE_USB_HUB, 0xf18a0e88, 0xc30c, 0x11d0, 0x88, 0x15, 0x00, 0xa0, 0xc9, 0x06, 0xbe, 0xd8);
#define	GUID_CLASS_USB_HUB	GUID_DEVINTERFACE_USB_HUB

namespace Global
{
	//////////////////////////////////////////////////////////////////////////
	// 全局变量;
	HINSTANCE g_hLanguageDLL = NULL;
	TCHAR g_szCurModuleDir[MAX_PATH] = { 0 };
	TCHAR g_szCurModulePath[MAX_PATH] = { 0 };
	TCHAR g_szFna[MAX_PATH] = { 0 };
	TCHAR g_szConfig[MAX_PATH] = { 0 };
	TCHAR g_szResuorceCfg[MAX_PATH] = { 0 };
	STConfig g_Config;
	TCHAR g_szPython27Dir[MAX_PATH] = {0};
	ULONGLONG g_ulWaitTime = 15000;
	int g_nSysZoomRatio = 100;
	TCHAR g_szVersion[MAX_PATH] = _T("5.50.20200921");
	BaiduCfg g_bdcfg;
	RsRunCfg g_rscfg;

	//////////////////////////////////////////////////////////////////////////
	// 全局函数;
	/************************************************************************/
	/*  函数：WriteTextLog[7/28/2009 Jeff];
	/*  描述：写文本日志;
	/*  参数：;
	/*  	[IN] ：;
	/*  返回：void;
	/*  注意：;
	/*  示例：;
	/*
	/*  修改：;
	/*  日期：;
	/*  内容：;
	/************************************************************************/
	void WriteTextLog(const TCHAR* format, ...)
	{
		// 解析出日志路径;
		TCHAR szlogpath[MAX_PATH] = { 0 };
		_stprintf_s(szlogpath, _T("%s%s.txt"), g_szCurModuleDir, g_szFna);
		// 打开或创建文件;
		FILE* fp = NULL;
		//if (_taccess(szlogpath, 0) != -1)
#ifndef UNICODE
		if (_access(szlogpath, 0) != -1)
#else
		if (_taccess(szlogpath, 0) != -1)
#endif
		{// 存在;
			if (0 == _tfopen_s(&fp, szlogpath, _T("a+")))
				// 移动到末尾;
				fseek(fp, 0, SEEK_END);
		}
		else
		{// 不存在;
			_tfopen_s(&fp, szlogpath, _T("w+"));
		}

		if (fp == NULL)
			return;

		// 格式化前设置语言区域;
		TCHAR* old_locale = _tcsdup(_tsetlocale(LC_CTYPE, NULL));
		_tsetlocale(LC_CTYPE, _T("chs"));//设定中文;

		// 格式化日志内容;
		va_list		args = NULL;
		int			len = 0;
		TCHAR* buffer = NULL;
		va_start(args, format);
		// _vscprintf doesn't count. terminating '\0'
		len = _vsctprintf(format, args) + 1;
		buffer = (TCHAR*)malloc(len * sizeof(TCHAR));
		_vstprintf_s(buffer, len, format, args);
		// 将日志内容输入到文件中;
		// 获取今年年份;
		__time64_t gmt = time(NULL);// 获取当前日历时间(1900-01-01开始的Unix时间戳);
		struct tm gmtm = { 0 };
		localtime_s(&gmtm, &gmt); // 时间戳转成本地时间;
		_ftprintf(fp, _T("%04d-%02d-%02d %02d:%02d:%02d %s\n"), gmtm.tm_year + 1990, gmtm.tm_mon + 1, gmtm.tm_mday, gmtm.tm_hour, gmtm.tm_min, gmtm.tm_sec, buffer);

		// 关闭文件，释放资源并设置回原语言区域;
		free(buffer);
		fclose(fp);
		_tsetlocale(LC_CTYPE, old_locale);
		free(old_locale);//还原区域设定;
	}

	void WriteTextLogEx(int nType, const TCHAR* format, ...)
	{
		// 解析出日志路径;
		TCHAR szlogpath[MAX_PATH] = { 0 };
		_stprintf_s(szlogpath, _T("%s%s-%d.txt"), g_szCurModuleDir, g_szFna, nType);
		// 打开或创建文件;
		FILE* fp = NULL;
		//if (_taccess(szlogpath, 0) != -1)
#ifndef UNICODE
		if (_access(szlogpath, 0) != -1)
#else
		if (_taccess(szlogpath, 0) != -1)
#endif
		{// 存在;
			if (0 == _tfopen_s(&fp, szlogpath, _T("a+")))
				// 移动到末尾;
				fseek(fp, 0, SEEK_END);
		}
		else
		{// 不存在;
			_tfopen_s(&fp, szlogpath, _T("w+"));
		}

		if (fp == NULL)
			return;

		// 格式化前设置语言区域;
		TCHAR* old_locale = _tcsdup(_tsetlocale(LC_CTYPE, NULL));
		_tsetlocale(LC_CTYPE, _T("chs"));//设定中文;

		// 格式化日志内容;
		va_list		args = NULL;
		int			len = 0;
		TCHAR* buffer = NULL;
		va_start(args, format);
		// _vscprintf doesn't count. terminating '\0'
		len = _vsctprintf(format, args) + 1;
		buffer = (TCHAR*)malloc(len * sizeof(TCHAR));
		_vstprintf_s(buffer, len, format, args);
		// 将日志内容输入到文件中;
		// 获取今年年份;
		__time64_t gmt = time(NULL);// 获取当前日历时间(1900-01-01开始的Unix时间戳);
		struct tm gmtm = { 0 };
		localtime_s(&gmtm, &gmt); // 时间戳转成本地时间;
		_ftprintf(fp, _T("%04d-%02d-%02d %02d:%02d:%02d %s\n"), gmtm.tm_year + 1990, gmtm.tm_mon + 1, gmtm.tm_mday, gmtm.tm_hour, gmtm.tm_min, gmtm.tm_sec, buffer);

		// 关闭文件，释放资源并设置回原语言区域;
		free(buffer);
		fclose(fp);
		_tsetlocale(LC_CTYPE, old_locale);
		free(old_locale);//还原区域设定;
	}

	int ReadReg(char* path, char* key, char* value)
	{
		HKEY hKey;
		int ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0, KEY_QUERY_VALUE, &hKey);
		if (ret != ERROR_SUCCESS)
		{
			return 1;
		}

		//读取KEY
		DWORD dwType = REG_SZ; //数据类型
		DWORD cbData = 256;
		ret = RegQueryValueEx(hKey, key, NULL, &dwType, (LPBYTE)value, &cbData);
		if (ret != ERROR_SUCCESS)
		{
			RegCloseKey(hKey);
			return 1;
		}
		RegCloseKey(hKey);

		return 0;
	}

	BOOL Python27Dir()
	{
		HKEY hKey;
		int ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("SOFTWARE\\WOW6432Node\\Python\\PythonCore\\2.7\\InstallPath"), 0, KEY_QUERY_VALUE, &hKey);
		if (ret != ERROR_SUCCESS)
			return FALSE;

		//读取KEY
 		DWORD dwType = REG_SZ; //数据类型
 		DWORD cbData = 256;
 		ret = RegQueryValueEx(hKey, _T(""), NULL, &dwType, (LPBYTE)g_szPython27Dir, &cbData);
 		if (ret != ERROR_SUCCESS)
 		{
 			RegCloseKey(hKey);
 			return FALSE;
 		}
 		RegCloseKey(hKey);

		return TRUE;
	}

	// 通过注册表查找系统当前串口信息;
	BOOL GetSysSerialPort(std::vector<std::string>& vtports)
	{
		HKEY hKey;
		LSTATUS lReg = 0;
		DWORD dwMaxValLen = 0;
		DWORD dwValNum = 0;
		lReg = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "HARDWARE\\DEVICEMAP\\SERIALCOMM", 0, KEY_QUERY_VALUE, &hKey);
		if (lReg != ERROR_SUCCESS)
		{
			//LOG4C((LOG_WARN, "Open Registry Error"));
			return FALSE;
		}

		lReg = RegQueryInfoKeyA(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &dwValNum, &dwMaxValLen, NULL, NULL, NULL);
		if (lReg != ERROR_SUCCESS)
		{
			//LOG4C((LOG_WARN, "Getting Key Info Error"));
			return FALSE;
		}

		if (vtports.size())
		{
			vtports.clear();
		}

		LPSTR lpValName, lpComNum;
		DWORD dwValName, dwValSize = 6;
		for (DWORD i = 0; i < dwValNum; i++)
		{
			dwValName = dwMaxValLen + 1;
			dwValSize = 6;
			lpValName = (LPSTR)VirtualAlloc(NULL, dwValName, MEM_COMMIT, PAGE_READWRITE);
			lReg = RegEnumValueA(hKey, i, lpValName, &dwValName, NULL, NULL, NULL, NULL);
			if ((lReg != ERROR_SUCCESS) && (lReg != ERROR_NO_MORE_ITEMS))
			{
				//LOG4C((LOG_WARN, "Enum  Registry  Error or No More Items"));
				continue;
			}
			lpComNum = (LPSTR)VirtualAlloc(NULL, 6, MEM_COMMIT, PAGE_READWRITE);
			lReg = RegQueryValueExA(hKey, lpValName, NULL, NULL, (LPBYTE)lpComNum, &dwValSize);
			if (lReg != ERROR_SUCCESS)
			{
				//LOG4C((LOG_WARN, "Can not get the name of the port"));
				continue;
			}

			vtports.push_back(lpComNum);
			VirtualFree(lpValName, 0, MEM_RELEASE);
			VirtualFree(lpComNum, 0, MEM_RELEASE);
		}

		return TRUE;
	}

	// 读取配置文件-预留;
	void GetConfig()
	{
		// Python27安装目录;
		Python27Dir();

		TCHAR szConfigpath[MAX_PATH] = { 0 };
		_stprintf_s(szConfigpath, _T("%s%s.ini"), g_szCurModuleDir, g_szFna);
		_tcscpy_s(g_szConfig, szConfigpath);

		TCHAR szValue[MAX_PATH] = { 0 };
		g_Config.nLanguage = GetPrivateProfileInt(_T("SATHelper"), _T("Language"), 0, szConfigpath);
		g_Config.bSVNRealTimeUpdate = GetPrivateProfileInt(_T("SATHelper"), _T("SVNRealTimeUpdate"), 0, szConfigpath);
		// 读取配置内容;
		g_Config.enableTW = GetPrivateProfileInt(_T("SATHelper"), _T("enableTW"), 0, szConfigpath);
		g_Config.useTW = GetPrivateProfileInt(_T("SATHelper"), _T("useTW"), 0, szConfigpath);
		g_Config.useUB530 = GetPrivateProfileInt(_T("SATHelper"), _T("useUB530"), 1, szConfigpath);


		GetPrivateProfileString(_T("SATHelper"), _T("MIInitBat"), NULL, szValue, MAX_PATH, szConfigpath);
		if (_tcslen(szValue) == 0)
		{
			WritePrivateProfileString(_T("SATHelper"), _T("MIInitBat"), _T("D:\\SAT\\tools\\atx-init\\atx-init_mi.bat"), szConfigpath);
			_stprintf_s(szValue, _T("D:\\SAT\\tools\\atx-init\\atx-init_mi.bat"));
		}
		g_Config.strMIInitBat = szValue;

		GetPrivateProfileString(_T("SATHelper"), _T("SCBCInitBat"), NULL, szValue, MAX_PATH, szConfigpath);
		if (_tcslen(szValue) == 0)
		{
			WritePrivateProfileString(_T("SATHelper"), _T("SCBCInitBat"), _T("D:\\SAT\\tools\\atx-init\\atx-init_scbc.bat"), szConfigpath);
			_stprintf_s(szValue, _T("D:\\SAT\\tools\\atx-init\\atx-init_scbc.bat"));
		}
		g_Config.strSCBCInitBat = szValue;

		// svn更新地址;
		GetPrivateProfileString(_T("SATHelper"), _T("SVNUpdateUrl"), NULL, szValue, MAX_PATH, szConfigpath);
		if (_tcslen(szValue) == 0)
		{
			WritePrivateProfileString(_T("SATHelper"), _T("SVNUpdateUrl"), _T("http://10.126.16.60:8580/btc_execute_se/ajaxInteractiveManage!getSvnVersion.action"), szConfigpath);
			_stprintf_s(szValue, _T("http://10.126.16.60:8580/btc_execute_se/ajaxInteractiveManage!getSvnVersion.action"));
		}
		g_Config.svnUpdateUrl = szValue;

		g_Config.bGenerics = GetPrivateProfileInt(_T("ir-device"), _T("generics"), 0, szConfigpath);
		if (PathFileExists(g_szPython27Dir))
		{
			g_Config.redratpath = g_szPython27Dir;
			g_Config.redratpath.append("Tools\\RedRatHub-V4.28\\RedRatHubCmd.exe");
			_stprintf_s(g_szResuorceCfg, _T("%sLib\\site-packages\\ssat_sdk\\config\\resource_run.cfg"), g_szPython27Dir);
		}
		else
		{
			GetPrivateProfileString(_T("ir-device"), _T("redratpath"), NULL, szValue, MAX_PATH, szConfigpath);
			g_Config.redratpath = szValue;
			memset(szValue, 0, MAX_PATH);
		}

		GetPrivateProfileString(_T("ir-device"), _T("signal"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.signaldir = szValue;
		memset(szValue, 0, MAX_PATH);

		GetPrivateProfileString(_T("ir-device"), _T("use-signal"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.use_signal = szValue;
		memset(szValue, 0, MAX_PATH);

		// Service;
		g_Config.bAutoLogin = GetPrivateProfileInt(_T("SATService"), _T("AutoLogin"), 0, szConfigpath);

		GetPrivateProfileString(_T("SATService"), _T("UserName"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strSATUserName = szValue;
		memset(szValue, 0, MAX_PATH);

		GetPrivateProfileString(_T("SATService"), _T("Password"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strSATPassword = szValue;
		memset(szValue, 0, MAX_PATH);		

		GetPrivateProfileString(_T("SATService"), _T("Actuator"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strActuator = szValue;
		memset(szValue, 0, MAX_PATH);

		GetPrivateProfileString(_T("SATService"), _T("ServiceIP"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strServiceIP = szValue;
		memset(szValue, 0, MAX_PATH);

		GetPrivateProfileString(_T("SATService"), _T("ServicePort"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strServicePort = szValue;
		memset(szValue, 0, MAX_PATH);

		// 是否开启SATHelper自动重连功能;
		g_Config.bAutoReconnect = GetPrivateProfileInt(_T("UB530"), _T("AutoReconnect"),  0, szConfigpath);

		// 重连周期：分钟为单位;
		g_Config.nReconnectCycle = GetPrivateProfileInt(_T("UB530"), _T("ReconnectCycle"), 60, szConfigpath);

		//////////////////////////////////////////////////////////////////////////
		GetPrivateProfileString(_T("TestWizard"), _T("xmlpath"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.twSignaldir = szValue;
		memset(szValue, 0, MAX_PATH);

		GetPrivateProfileString(_T("TestWizard"), _T("useSignal"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.twUseSignal = szValue;
		memset(szValue, 0, MAX_PATH);

		g_Config.twPort = GetPrivateProfileInt(_T("TestWizard"), _T("Com"), 0, szConfigpath);

		// u盘切换;
		g_Config.usbPort = GetPrivateProfileInt(_T("UsbSwitch"), _T("Com"), 0, szConfigpath);
		g_Config.enableUSB = GetPrivateProfileInt(_T("SATHelper"), _T("enableUSB"), 0, szConfigpath);
		g_Config.nPowerLanIndex = GetPrivateProfileInt(_T("PowerCtrl"), _T("LanIndex"), 0, szConfigpath);

		// 电视串口;
		g_Config.tvPort = GetPrivateProfileInt(_T("SATHelper"), _T("TVPort"), 0, szConfigpath);
		g_Config.enableTVPort = GetPrivateProfileInt(_T("SATHelper"), _T("enableTVPort"), 0, szConfigpath);

		g_Config.bRememberFTPInfo = GetPrivateProfileInt(_T("SATHelper"), _T("rememberFTPInfo"), 0, szConfigpath);
		GetPrivateProfileString(_T("SATHelper"), _T("ftp_user"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strFtpUser = szValue;
		GetPrivateProfileString(_T("SATHelper"), _T("ftp_password"), NULL, szValue, MAX_PATH, szConfigpath);
		g_Config.strFtpPassword = szValue;

		// 测试精灵端口控制类型：开关、切换;
		g_Config.nTWPortControltype = GetPrivateProfileInt(_T("TestWizard"), _T("PortControltype"), 0, szConfigpath);
	}

	BOOL GetOrientation(IN Image* pImg)
	{
		if (pImg == NULL) return FALSE;

		UINT totalBufferSize;
		UINT numProperties;
		pImg->GetPropertySize(&totalBufferSize, &numProperties);
		// Allocate the buffer that will receive the property items.
		PropertyItem* pAllItems = (PropertyItem*)malloc(totalBufferSize);
		// Fill the buffer.
		pImg->GetAllPropertyItems(totalBufferSize, numProperties, pAllItems);
		// Print the id data member of each property item.
		for (UINT j = 0; j < numProperties; ++j)
		{
			if (PropertyTagOrientation == pAllItems[j].id)
			{
				short* ptrLong = (short*)(pAllItems[j].value);
				int ret = (int)*ptrLong;
				free(pAllItems);
				return ret;
			}
		}
		free(pAllItems);

		return TRUE;
	}


	/************************************************************************/
	/*
	函数:GetEncoderClsid
	描述:获取GDI+支持的图像格式编码器种类,以及所有种类编码器信息;
	参数:
	IN:  format 要获取的图像格式;
	OUT: pClsid 返回符合条件的图像编码器信息;
	返回:成功返回编码器索引,否则返回-1;
	*/
	/************************************************************************/
	int GetEncoderClsid(IN CONST WCHAR* format, OUT CLSID* pClsid)
	{
		// GDI+支持的图像编码器数量;
		UINT  numEncoders = 0;
		// GDI+所有图像格式编码器详细信息所需要的空间大小;
		UINT  nSize = 0;

		ImageCodecInfo* pImageCodecInfo = NULL;

		// 2.获取GDI+支持的所有图像格式编码器详细信息所需要的空间大小;
		GetImageEncodersSize(&numEncoders, &nSize);
		if (nSize == 0)
			return -1;

		//3.为ImageCodecInfo数组分配足额空间;
		pImageCodecInfo = (ImageCodecInfo*)(malloc(nSize));
		if (pImageCodecInfo == NULL)
			return -1;

		//4.获取所有的图像编码器信息;
		GetImageEncoders(numEncoders, nSize, pImageCodecInfo);

		//5.查找符合的图像编码器的Clsid;
		for (UINT i = 0; i < numEncoders; ++i)
		{
			if (wcscmp(pImageCodecInfo[i].MimeType, format) == 0)
			{
				*pClsid = pImageCodecInfo[i].Clsid;
				free(pImageCodecInfo);
				return i;  // Success
			}
		}

		//6.释放步骤3分配的内存;
		free(pImageCodecInfo);

		return -1;
	}


	BOOL LoadImgFromFile(IN Image** pImg, LPCTSTR lpPath)
	{
		if (!PathFileExists(lpPath))
			return FALSE;

		if (*pImg)
			delete* pImg;

		*pImg = NULL;

#ifdef UNICODE
		* pImg = Image::FromFile(lpPath);
#else
		BSTR strtmp = _bstr_t(lpPath);
		*pImg = Image::FromFile(strtmp, TRUE);
		SysFreeString(strtmp);
#endif

		return (*pImg ? TRUE : FALSE);
	}

	BOOL LoadImgFromBuffer(IN Image** pImg, IN BYTE* pBuffer, IN CONST INT& nBufLen)
	{
		if (pBuffer == NULL)
			return FALSE;

		if (*pImg)
			delete* pImg;

		*pImg = NULL;
		HGLOBAL hMemery = GlobalAlloc(GMEM_MOVEABLE, nBufLen);
		if (hMemery == NULL)
			return FALSE;

		BYTE* pMem = (BYTE*)GlobalLock(hMemery);
		memcpy(pMem, pBuffer, nBufLen);

		IStream* pstream = NULL;
		CreateStreamOnHGlobal(hMemery, TRUE, &pstream);
		*pImg = Image::FromStream(pstream);
		GlobalUnlock(hMemery);
		pstream->Release();

		return (*pImg ? TRUE : FALSE);
	}

	// 先以只读方式从文件中读取二进制流出来，可以做到不独占文件;
	BOOL LoadImgFromBuffer(IN Image** pImg, LPCTSTR lpPath)
	{
		if (!PathFileExists(lpPath))
			return FALSE;

		if (*pImg)
			delete* pImg;
		*pImg = NULL;

		return LoadImgFromFile(pImg, lpPath);

		CFile fp;
		CFileException e;
		BOOL bRet = FALSE;
		if (fp.Open(lpPath, CFile::modeRead, &e))
		{
			DWORD dwLength = (DWORD)fp.GetLength();
			BYTE* pData = new BYTE[dwLength];

			fp.Read(pData, dwLength);
			fp.Close();

			bRet = LoadImgFromBuffer(pImg, pData, dwLength);

			if (pData)
				delete[]pData;
		}

		return bRet;
	}

	/************************************************************************/
	/*  函数：LoadImgFromResource[9/21/2016 IT];
	/*  描述：从资源中加载;
	/*  参数：;
	/*  	[IN] ：;
	/*  	[OUT] ：;
	/*  	[IN/OUT] ：;
	/*  返回：void;
	/*  注意：;
	/*  示例：;
	/*
	/*  修改：;
	/*  日期：;
	/*  内容：;
	/************************************************************************/
	Image* LoadImgFromResource(IN HMODULE hModule, IN LPCTSTR lpName, IN LPCTSTR lpType)
	{
		HGLOBAL	hGlobal = NULL;
		HRSRC	hSource = NULL;
		LPVOID  lpBuffer = NULL;
		DWORD   dwSize = 0;
		// 1.定位我们的自定义资源，这里因为我们是从本模块定位资源，所以将句柄简单地置为NULL即可
		hSource = FindResource(hModule, lpName, lpType);
		if (hSource == NULL)
		{
			_tprintf(_T("载入资源失败:%s"), lpName);
			return NULL;
		}

		// 2.获取资源的大小;
		dwSize = (UINT)SizeofResource(NULL, hSource);

		// 3.加载资源;
		hGlobal = LoadResource(NULL, hSource);
		if (hGlobal == NULL)
		{
			_tprintf(_T("载入资源失败:%s"), lpName);
			return NULL;
		}

		// 4.锁定资源,获取buffer;
		lpBuffer = LockResource(hGlobal);
		if (lpBuffer == NULL)
		{
			_tprintf(_T("载入资源失败:%s"), lpName);
			return NULL;
		}

		// lpFileFullName需要先判断文件是否存在??不需要;
		Image* pImg = NULL;
		LoadImgFromBuffer(&pImg, (BYTE*)lpBuffer, dwSize);

		UnlockResource(hGlobal);
		FreeResource(hGlobal);

		return pImg;
	}

	BOOL SaveImgByRotate(LPCTSTR lpszFileName, BYTE* pBuffer, const INT& nBufLen, BOOL bHoriontal, BOOL bVertically)
	{
		Image* pImg = NULL;
		HGLOBAL hMemery = GlobalAlloc(GMEM_MOVEABLE, nBufLen);
		if (hMemery == NULL)
			return FALSE;

		BYTE* pMem = NULL;
		pMem = (BYTE*)GlobalLock(hMemery);
		if (pMem == NULL)
			return FALSE;
		memcpy(pMem, pBuffer, nBufLen);

		IStream* pstream = NULL;
		HRESULT hr = CreateStreamOnHGlobal(hMemery, TRUE, &pstream);
		if (pstream == NULL)
			return FALSE;
		pImg = Image::FromStream(pstream);
		GlobalUnlock(hMemery);
		pstream->Release();

		if (bHoriontal && !bVertically)
			pImg->RotateFlip(RotateNoneFlipX);// 水平翻转;
		else if (bHoriontal && bVertically)
			pImg->RotateFlip(Rotate180FlipNone);// 270度;
		else if (!bHoriontal && bVertically)
			pImg->RotateFlip(Rotate180FlipX);// 垂直翻转;

		CString strNewfile = lpszFileName;
		// 需要判断路径是否存在,不存在创建目录;
		int nIndex = strNewfile.ReverseFind(_T('\\'));
		if (nIndex == -1)
			return FALSE;

		if (!PathFileExists(strNewfile.Left(nIndex)))
		{
			// 如果文件夹不存在,创建;
			SHCreateDirectoryEx(NULL, strNewfile.Left(nIndex), NULL);
		}

		nIndex = strNewfile.ReverseFind(_T('.'));
		if (nIndex == -1)
			return FALSE;

		Status stat = GenericError;
		CLSID encoderClsid = { 0 };
		BSTR newfile = strNewfile.AllocSysString();

		strNewfile = strNewfile.Mid(nIndex + 1);
		if (strNewfile.CompareNoCase(_T("bmp")) == 0)
		{
			GetEncoderClsid(L"image/bmp", &encoderClsid);
			stat = pImg->Save(newfile, &encoderClsid, NULL);
		}
		else if (strNewfile.CompareNoCase(_T("png")) == 0)
		{
			GetEncoderClsid(L"image/png", &encoderClsid);
			stat = pImg->Save(newfile, &encoderClsid, NULL);
		}
		else// if ( strNewfile.CompareNoCase(_T("jpeg")) == 0 )
		{
			GetEncoderClsid(L"image/jpeg", &encoderClsid);

			EncoderParameters encoderParameters;
			encoderParameters.Count = 1;
			encoderParameters.Parameter[0].Guid = EncoderQuality;
			encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
			encoderParameters.Parameter[0].NumberOfValues = 1;
			// Save the image as a JPEG with quality level 100.
			ULONG uQuality = 100;
			encoderParameters.Parameter[0].Value = &uQuality;
			stat = pImg->Save(newfile, &encoderClsid, &encoderParameters);
		}

		if (pImg)
			delete pImg;
		pImg = NULL;

		SysFreeString(newfile);

		return stat == Ok ? TRUE : FALSE;
	}


	void MKDIR(LPCTSTR dir)
	{
		//////////////////////////////////////////////////////////////////////////
		// 创建目录;
		int nleft = 0;
		int nIndex = -1;
		TString strdir = dir;

		if (strdir.at(strdir.size() - 1) != _T('\\'))
			strdir.append(_T("\\"));

		// 共享路径和硬盘盘符;
		if (_tcscmp(strdir.substr(0, 2).c_str(), _T("\\\\")) == 0)
			nleft = strdir.find_first_of(_T("\\"), 2) + 1;	// 去除共享主机名;
		else if (strdir.at(2) == _T('\\'))
			nleft = 3;

		do
		{
			nIndex = strdir.substr(nleft, -1).find_first_of(_T("\\"));

			if (nIndex != TString::npos)
			{
				if (_tmkdir(strdir.substr(0, nIndex + nleft).c_str()) == -1 && (errno != EEXIST))
				{
					WriteTextLog(_T("创建目录失败：%s，错误码：%d"), strdir.substr(0, nIndex + nleft).c_str(), errno);
					break;
				}

				nleft += nIndex + 1;
			}
		} while (nIndex != -1);
	}

	// hModule 模块句柄 NULL表示当前模块;
	bool GetVersion(OUT WORD* pdwFileVersion, OUT WORD* pdwProductVerion)
	{
		TCHAR szFilePath[MAX_PATH] = { 0 };
		DWORD dwRet = GetModuleFileName(NULL, szFilePath, MAX_PATH);
		if (dwRet == 0)
			return false;

		VS_FIXEDFILEINFO* pVi = NULL;
		DWORD dwHandle = 0;
		int size = GetFileVersionInfoSize(szFilePath, &dwHandle);
		if (size > 0)
		{
			BYTE* buffer = new BYTE[size];
			memset(buffer, 0, size);

			if (GetFileVersionInfo(szFilePath, dwHandle, size, buffer))
			{
				if (VerQueryValue(buffer, _T("\\"), (LPVOID*)&pVi, (PUINT)&size))
				{
					pdwFileVersion[0] = HIWORD(pVi->dwFileVersionMS);
					pdwFileVersion[1] = LOWORD(pVi->dwFileVersionMS);
					pdwFileVersion[2] = HIWORD(pVi->dwFileVersionLS);
					pdwFileVersion[3] = LOWORD(pVi->dwFileVersionLS);

					pdwProductVerion[0] = HIWORD(pVi->dwProductVersionMS);
					pdwProductVerion[1] = LOWORD(pVi->dwProductVersionMS);
					pdwProductVerion[2] = HIWORD(pVi->dwProductVersionLS);
					pdwProductVerion[3] = LOWORD(pVi->dwProductVersionLS);

					delete[]buffer;
					return true;
				}
			}

			delete[]buffer;
		}

		return false;
	}

	void GetSysZoomRatio()
	{
		// Get desktop dc
		HDC desktopDc = GetDC(NULL);
		int horizontalDPI = GetDeviceCaps(desktopDc, LOGPIXELSX);
		int verticalDPI = GetDeviceCaps(desktopDc, LOGPIXELSY);

		switch ( horizontalDPI )
		{
		case 96:
			g_nSysZoomRatio = 100;		// 100%缩放布局;
			break;
		case 120:
			g_nSysZoomRatio = 125;		// 125%缩放布局;
			break;
		case 144:
			g_nSysZoomRatio = 150;		// 150%缩放布局;
			break;
		case 192:
			g_nSysZoomRatio = 200;		// 200%缩放布局;
			break;
		default:
			break;
		}

#if 0
		// Get native resolution
		int horizontalResolution = GetDeviceCaps(desktopDc, HORZRES);
		int verticalResolution = GetDeviceCaps(desktopDc, VERTRES);

		// 获取窗口当前显示的监视器
		// 使用桌面的句柄.
		HWND hWnd = GetDesktopWindow();
		HMONITOR hMonitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);

		// 获取监视器逻辑宽度与高度
		MONITORINFOEX miex;
		miex.cbSize = sizeof(miex);
		GetMonitorInfo(hMonitor, &miex);
		int cxLogical = (miex.rcMonitor.right - miex.rcMonitor.left);
		int cyLogical = (miex.rcMonitor.bottom - miex.rcMonitor.top);

		// 获取监视器物理宽度与高度
		DEVMODE dm;
		dm.dmSize = sizeof(dm);
		dm.dmDriverExtra = 0;
		EnumDisplaySettings(miex.szDevice, ENUM_CURRENT_SETTINGS, &dm);
		int cxPhysical = dm.dmPelsWidth;
		int cyPhysical = dm.dmPelsHeight;

		// 缩放比例计算  实际上使用任何一个即可
		double horzScale = ((double)cxPhysical / (double)cxLogical);
		double vertScale = ((double)cyPhysical / (double)cyLogical);
		assert(horzScale == vertScale); // 宽或高这个缩放值应该是相等的
#endif
	}

	//枚举所有usb设备 
	BOOL EnumUSBDevice(OUT char acDevPath[MAX_PATH][MAX_PATH], OUT int& nDevNum)
	{
		//入参检测  
		nDevNum = 0;
		if (NULL == acDevPath)
			return FALSE;

		ZeroMemory(acDevPath, sizeof(acDevPath));
		BOOL                                bRet = FALSE;
		SP_DEVICE_INTERFACE_DATA            DeviceInterfaceData;            // 保存设备接口信息  
		DWORD                               dwRequiredSize = 0;             // 得到详细信息时需要的内存大小  
		PSP_INTERFACE_DEVICE_DETAIL_DATA    pDeviceDetailData = NULL;       // 详细信息  
		HDEVINFO                            hDeviceInfo;                    // 设备信息集合的指针      
		GUID                                InterfaceGUID = GUID_CLASS_USB_DEVICE;
		DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

		// 枚举设备   
		int i = 0;
		hDeviceInfo = SetupDiGetClassDevs(&InterfaceGUID, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
		if (hDeviceInfo == INVALID_HANDLE_VALUE)
			return FALSE;

		while (1)
		{
			bRet = SetupDiEnumDeviceInterfaces(hDeviceInfo, NULL, &InterfaceGUID, i++, &DeviceInterfaceData);
			if (!bRet)
				break;

			// 下面需要得到Interface的详细信息  
			// 先得到详细信息需要的内存大小  
			bRet = SetupDiGetDeviceInterfaceDetail(hDeviceInfo, &DeviceInterfaceData, NULL, 0, &dwRequiredSize, NULL);
			if (bRet)
				break;

			// 为详细信息分配内存  
			if (pDeviceDetailData)
			{
				free(pDeviceDetailData);
				pDeviceDetailData = NULL;
			}
			pDeviceDetailData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc(dwRequiredSize);
			if (pDeviceDetailData == NULL)
				break;

			// 得到Interface的详细信息  
			pDeviceDetailData->cbSize = sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
			SP_DEVINFO_DATA DeviceInfoData;
			DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
			bRet = SetupDiGetDeviceInterfaceDetail(hDeviceInfo, &DeviceInterfaceData, pDeviceDetailData, dwRequiredSize, &dwRequiredSize,&DeviceInfoData);
			if (!bRet)
				break;
			strcpy_s(acDevPath[nDevNum], pDeviceDetailData->DevicePath);
			nDevNum++;
		}
		if (pDeviceDetailData)
		{
			free(pDeviceDetailData);
			pDeviceDetailData = NULL;
		}
		SetupDiDestroyDeviceInfoList(hDeviceInfo);
		return TRUE;
	}

	INT EnumUSBDevice(CONST GUID* pClassGuid)
	{
		HDEVINFO hDevInfo;
		DWORD MemberIndex, RequiredSize;
		SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
		PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData;
		INT nTotal = 0;
		INT nNICKind = 0;
		HIDD_ATTRIBUTES   attributes;

		// 获取设备信息集;
		hDevInfo = SetupDiGetClassDevs(pClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
		if (hDevInfo == INVALID_HANDLE_VALUE)
		{
			return -1;
		}

		//g_vtMac.clear();
		// 枚举设备信息集中所有设备;
		DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
		for (MemberIndex = 0; SetupDiEnumDeviceInterfaces(hDevInfo, NULL, pClassGuid, MemberIndex, &DeviceInterfaceData); MemberIndex++)
		{
			// 获取接收缓冲区大小，函数返回值为FALSE，GetLastError()=ERROR_INSUFFICIENT_BUFFER;
			SetupDiGetDeviceInterfaceDetail(hDevInfo, &DeviceInterfaceData, NULL, 0, &RequiredSize, NULL);

			// 申请接收缓冲区;
			DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(RequiredSize);
			if (DeviceInterfaceDetailData == NULL)
				continue;
			DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

			// 获取设备细节信息;
			if (SetupDiGetDeviceInterfaceDetail(hDevInfo, &DeviceInterfaceData, DeviceInterfaceDetailData, RequiredSize, NULL, NULL))
			{
				HANDLE hDeviceFile;
				BOOL isOK = FALSE;
				// 不保留swd调试网卡,root系统网卡.只保留usb和pci
				if (_tcsnicmp(DeviceInterfaceDetailData->DevicePath + 4, TEXT("pci"), 3) != 0 && _tcsnicmp(DeviceInterfaceDetailData->DevicePath + 4, TEXT("usb"), 3) != 0)
				{
					free(DeviceInterfaceDetailData);
					DeviceInterfaceDetailData = NULL;
					continue;
				}

				//MacAddress tagMacAddress;
				//tagMacAddress.nNICKind = NIC_PCI;
				//_stprintf_s(tagMacAddress.szNICKind, _T("%s"), _T("NIC_PCI"));

				// 获取设备句柄;
				hDeviceFile = CreateFile(DeviceInterfaceDetailData->DevicePath,
					0,
					FILE_SHARE_READ | FILE_SHARE_WRITE,
					NULL,
					OPEN_EXISTING,
					0,
					NULL);

				if (hDeviceFile != INVALID_HANDLE_VALUE)
				{
					//   获取   attributes   以便得到Vendor   ID   和   Product   ID 
					HidD_GetAttributes(hDeviceFile, &attributes);

					ULONG dwID;
					BYTE ucData[512];
					DWORD dwByteRet;

					// 获取原生MAC地址;
					STORAGE_PROPERTY_QUERY Query; // 查询输入参数
					// 设置查询参数
					Query.PropertyId = StorageDeviceProperty;
					Query.QueryType = PropertyStandardQuery;
					dwID = OID_802_3_PERMANENT_ADDRESS;
					isOK = DeviceIoControl(hDeviceFile, IOCTL_STORAGE_QUERY_PROPERTY, &Query, sizeof(STORAGE_PROPERTY_QUERY), ucData, sizeof(ucData), &dwByteRet, NULL);
					if (isOK)
					{
						++nTotal;
						PSTORAGE_DEVICE_DESCRIPTOR pDevDesc;
						pDevDesc = (PSTORAGE_DEVICE_DESCRIPTOR)ucData;
						//_stprintf_s(tagMacAddress.szDevicePath, _T("%s"), DeviceInterfaceDetailData->DevicePath);
						//memset(tagMacAddress.szMacAddress, 0, sizeof(TCHAR) * MAX_PATH);
						// 将字节数组转换成16进制字符串;
						for (DWORD i = 0; i < dwByteRet; i++)
						{
							//_stprintf_s(&tagMacAddress.szMacAddress[i * 3], MAX_PATH - (i * 3), (i != dwByteRet - 1) ? _T("%02X-") : _T("%02X"), ucData[i]);
						}

						//WriteTextLog(SAT_NOR, _T("类型=%d, 路径=%s, MAC=%s, NICKind=%s"), tagMacAddress.nNICKind, tagMacAddress.szDevicePath, tagMacAddress.szMacAddress, tagMacAddress.szNICKind);
						//g_vtMac.push_back(tagMacAddress);
					}
					CloseHandle(hDeviceFile);
				}
			}

			free(DeviceInterfaceDetailData);
			DeviceInterfaceDetailData = NULL;
		}

		SetupDiDestroyDeviceInfoList(hDevInfo);

		return nTotal;
	}
}