#IQRV #comment 高拍仪同步

Module/include/CommEntityUtil.hpp

@@ -1,26 +1,46 @@
 #ifndef RVC_MOD_COMM_ENTITY_UTIL_HPP_
 #define RVC_MOD_COMM_ENTITY_UTIL_HPP_
 
-#include "path.h"
-#include "SpBase.h"
-#include <thread>
-#include <string>
-#include <map>
-#include <chrono>
-#include "publicFunExport.h"
-
-#if defined(RVC_OS_WIN)
+#if defined(_MSC_VER)
+#include <Windows.h>
+#include <TlHelp32.h>
+#include <iphlpapi.h>
+#include <ws2tcpip.h>
+#include <Winsock2.h>
+#include <IPTypes.h>
+#include <WinInet.h>
+#include <ShlObj.h>
+#include <Pdh.h>
+
+#pragma comment(lib, "IPHLPAPI.lib")
+#pragma comment(lib, "Wininet.lib")
+#pragma comment(lib, "pdh.lib")
 #define streq stricmp
+
 #else
-#define streq strcasecmp
-#endif //RVC_OS_WIN
 
-#include "toolkit.h"
-#if defined(RVC_OS_LINUX)
 #include <net/if.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
-#endif //RVC_OS_LINUX
+#include <thread>
+#include <chrono>
+#define streq strcasecmp
+#endif //_MSC_VER
+
+#include "path.h"
+#include "toolkit.h"
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <map>
+#include "SpBase.h"
+#include "publicFunExport.h"
+
+#define MACSESION 6
+#define DIV (1024 * 1024)
+#define DAY_DIV (24 * 60 * 60)
+#define HOURS_DIV (60 * 60)
+#define MINUS_DIV (60)
 
 typedef unsigned long long ULLINT;
 typedef CAutoArray<CSimpleStringA>  NetworkAddressesList;
@@ -31,6 +51,87 @@ namespace SP
 {
 namespace Module
 {
+
+	namespace System
+	{
+
+		static BOOL GetSystemBootTime(CSmallDateTime& systemBootTime)
+		{
+#if defined(_MSC_VER)
+
+			PDH_STATUS Status;
+			HQUERY Query = NULL;
+			HCOUNTER hcElapsedTimeCount;
+			BOOL fSuc = FALSE;
+			Status = PdhOpenQuery(NULL, NULL, &Query);
+			PDH_FMT_COUNTERVALUE counterValue;
+			if (Status != ERROR_SUCCESS) {
+				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhOpenQuery failed with status 0x%x.", Status);
+				goto Cleanup;
+			}
+			Status = PdhAddCounter(Query, "\\System\\System Up Time", NULL, &hcElapsedTimeCount);
+			if (Status != ERROR_SUCCESS) {
+				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhAddCounter for SystemElapsedQuery failed with status 0x%x.", Status);
+				goto Cleanup;
+			}
+			// 查询性能监视器数据
+			Status = PdhCollectQueryData(Query);
+			if (Status != ERROR_SUCCESS) {
+				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhCollectQueryData failed with 0x%x.", Status);
+				goto Cleanup;
+			}
+			Status = PdhGetFormattedCounterValue(hcElapsedTimeCount, PDH_FMT_LARGE, NULL, &counterValue);
+			if (Status == ERROR_SUCCESS) {
+				ULONGLONG ulSinceSeconds = counterValue.largeValue;
+				ULONG days = 0, hours = 0, minutes = 0, seconds = 0;
+				days = ULONG(ulSinceSeconds / DAY_DIV);
+				ulSinceSeconds %= DAY_DIV;
+				hours = ULONG(ulSinceSeconds / HOURS_DIV);
+				ulSinceSeconds %= HOURS_DIV;
+				minutes = ULONG(ulSinceSeconds / MINUS_DIV);
+				ulSinceSeconds %= MINUS_DIV;
+				seconds = ULONG(ulSinceSeconds);
+
+				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SystemElapseTime: %u:%02u:%02u:%02u", days, hours, minutes, seconds);
+
+				FILETIME ftCurTime, ftStartTime;
+				GetSystemTimeAsFileTime(&ftCurTime);
+				ULARGE_INTEGER uliCurTime;
+				uliCurTime.HighPart = ftCurTime.dwHighDateTime;
+				uliCurTime.LowPart = ftCurTime.dwLowDateTime;
+				uliCurTime.QuadPart -= counterValue.largeValue * 1e7;
+
+				ftStartTime.dwHighDateTime = uliCurTime.HighPart;
+				ftStartTime.dwLowDateTime = uliCurTime.LowPart;
+
+				SYSTEMTIME stUTC, stLocal;
+
+				FileTimeToSystemTime(&ftStartTime, &stUTC);
+				char temp[22];
+				SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
+				sprintf_s(temp, 22, "%d-%02d-%02d %02d:%02d:%02d",
+					stLocal.wYear, stLocal.wMonth, stLocal.wDay, stLocal.wHour, stLocal.wMinute, stLocal.wSecond);
+				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OSStartTime: %s", temp);
+				systemBootTime.FromSystemTime(stLocal);
+				fSuc = TRUE;
+			}
+
+		Cleanup:
+
+			Status = PdhRemoveCounter(hcElapsedTimeCount);
+			if (Query) {
+				PdhCloseQuery(Query);
+			}
+			return fSuc;
+
+#else
+            ///*TODO(80374374@3/7/2023):  */
+            return FALSE;
+
+#endif //_MSC_VER
+		}
+	}//system
+
 namespace Comm
 {
 
@@ -123,6 +224,25 @@ struct LogErrorNotiyStruct : public LogCommNotiyStruct
     ~LogErrorNotiyStruct() {}
 };
 
+static BOOL IsFirsRunAppAfterSystemBoot(CEntityBase* pEntity)
+{
+	BOOL result(FALSE);
+	CSystemRunInfo runInfo = { 0 };
+	ErrorCodeEnum ec = pEntity->GetFunction()->GetSystemRunInfo(runInfo);
+	if (ec == Error_Succeed) {
+		CBootInfo bootInfo = { 0 };
+		CSmallDateTime dateTime;
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("systemRunInfo time: %s", (LPCTSTR)runInfo.tmStart.ToTimeString());
+		ec = pEntity->GetFunction()->GetRebootInfo(/*runInfo.tmStart*/dateTime, bootInfo);
+		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bootInfor time: %s", (LPCTSTR)bootInfo.tmStart.ToTimeString());
+		CSmallDateTime systemBootTime;
+		const BOOL bRet = System::GetSystemBootTime(systemBootTime);
+		if (bRet && systemBootTime > bootInfo.tmStart) {
+			result = TRUE;
+		}
+	}
+	return result;
+}
 
 inline
 CSimpleStringA GetCurrMachineType(CEntityBase* pEntity)
@@ -142,24 +262,16 @@ CSimpleStringA GetCurrEntityConfigPath(CEntityBase* pEntity)
     return result;
 }
 
-enum Site
-{
-	CMB_UNKNOWN,
-	CMB_LIB,       /** 行内大堂*/
-	CMB_SSB,      /** 自助网点*/
-	CMB_LSS,      /** 生活销售机*/
-	CMB_FLB,      /** 离行机器*/
-	CMB_OSB,     /** 外拓PAD*/
-	CMB_SMM     /** 商户终端*/
-};
+            enum Site
+            {
+                CMB_UNKNOWN,
+                CMB_LIB,       /** 行内大堂*/
+                CMB_FLB,      /** 离行机器*/
+            };
 
 #define SITE_ENUM_TYPE(MACRO)	\
 		MACRO(LIB)\
-		MACRO(SSB)\
-		MACRO(LSS)\
-		MACRO(FLB)\
-		MACRO(OSB)\
-		MACRO(SMM)
+		MACRO(FLB)
 
 
 #define ENUM_MAP_CONVERT(elem) \
@@ -188,17 +300,18 @@ static LPCSTR Site2Str(Site site)
 	return "Unkown";
 }
 
-enum What
-{
-	RVC_UNKNOWN,
-	RVC_Stand2S,          /** 落地式大机*/
-	RVC_PAD,                /** PAD*/
-	RVC_Desk2S,           /** 低柜双屏*/
-	RVC_IL,                    /** 简版*/
-	RVC_Desk1S,          /** 低柜一体机*/
-	RVC_CardStore,		/** 卡库*/
-	RPM_Stand1S         /** 扩展柜*/
-};
+            enum What
+            {
+                RVC_UNKNOWN,
+                RVC_Stand2S,          /** 落地式大机*/
+                RVC_PAD,                /** PAD*/
+                RVC_Desk2S,           /** 低柜双屏*/
+                RVC_IL,                    /** 简版*/
+                RVC_Desk1S,          /** 低柜一体机*/
+                RVC_CardStore,		/** 卡库*/
+                RPM_Stand1S,         /** 扩展柜*/
+                RVC_CardPrinter     /** 制卡机*/
+            };
 
 #define MACHINE_ENUM_TYPE(MACRO)	\
 		MACRO(Stand2S)\
@@ -305,8 +418,8 @@ static int StrBuf2HexBuf(char* strBuf, PBYTE* hexBuf)
 static int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len)
 {
     char* tmpStr = *strBuf;
-    int count = 0;
-    for (int i = 0; i < len; ++i) {
+	DWORD count = 0;
+    for (DWORD i = 0; i < len; ++i) {
         sprintf(tmpStr + count, "%0.2X", hexBuf[i]);
         count += 2;
     }
@@ -324,7 +437,7 @@ static DWORD GetDuration(const SYSTEMTIME& time1, const SYSTEMTIME& time2)
     SystemTimeToFileTime(&time2, (FILETIME*)&fTime2);
 
     unsigned __int64 dft = fTime2.QuadPart - fTime1.QuadPart;
-    return dft / 10000;
+    return DWORD(dft / 10000);
 
 #else
     ///**TODO(Gifur@9/3/2021): Bug 不能这样简单的实现，考虑凌晨，切换月份甚至是年份 */
@@ -346,32 +459,37 @@ static std::string formatTime(const SYSTEMTIME& time)
 
 static bool ShellExecute(const std::string& cmd, std::string& succResult, std::string& errResult)
 {
-    char buf_ps[1024];
-    char ps[1024] = { 0 };
-    char result[2049] = { 0 };
-    FILE* ptr;
-    
-    strcpy(ps, cmd.c_str());
-    succResult = errResult = "";
-
-    if ((ptr = popen(ps, "r")) != NULL) {
-        while (fgets(buf_ps, 1024, ptr) != NULL) {
-            if(strlen(result) + strlen(buf_ps) > 2048)
-                break;
-            strcat(result, buf_ps);
-        }
-        pclose(ptr);
-        const int len = strlen(result);
-        for (int i = len - 1; i >= 0 && (result[i] == '\r' || result[i] == '\n'); --i) {
-            result[i] = '\0';
-        }
-        succResult = result;
-        return true;
-    } else {
-        sprintf(result, "popen %s error: %d", ps, errno);
-        errResult = result;
-        return false;
-    }
+#if defined(_MSC_VER)
+    ///*TODO(80374374@3/7/2023):  */
+    return false;
+#else
+	char buf_ps[1024];
+	char ps[1024] = { 0 };
+	char result[2049] = { 0 };
+	FILE* ptr;
+
+	strcpy(ps, cmd.c_str());
+	succResult = errResult = "";
+
+	if ((ptr = popen(ps, "r")) != NULL) {
+		while (fgets(buf_ps, 1024, ptr) != NULL) {
+			if (strlen(result) + strlen(buf_ps) > 2048)
+				break;
+			strcat(result, buf_ps);
+		}
+		pclose(ptr);
+		const int len = strlen(result);
+		for (int i = len - 1; i >= 0 && (result[i] == '\r' || result[i] == '\n'); --i) {
+			result[i] = '\0';
+		}
+		succResult = result;
+		return true;
+	} else {
+		sprintf(result, "popen %s error: %d", ps, errno);
+		errResult = result;
+		return false;
+	}
+#endif //_MSC_VER
 }
 
 static CSimpleString generateConsumeTimeJson(CSimpleString entityName, CSimpleString startTime, int cost)
@@ -379,84 +497,248 @@ static CSimpleString generateConsumeTimeJson(CSimpleString entityName, CSimpleSt
     return CSimpleString::Format("[{\"name\":\"%s\",\"time\":\"%s\",\"cost\":%d}]", entityName.GetData(), startTime.GetData(), cost);
 }
 
-} //namespace Util
+#if defined(_MSC_VER)
+static char* ConvertUtf8ToGBK(const char* strUtf8)
+{
+	int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
+	WCHAR* wszGBK = new WCHAR[len + 1];
+	memset(wszGBK, 0, len * 2 + 2);
+	MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
+
+	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
+	char* szGBK = new char[len + 1];
+	memset(szGBK, 0, len + 1);
+	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
+	delete[] wszGBK;
+
+	return szGBK;
+}
 
-namespace Net{
+static void ConvertUtf8ToGBK(std::string& str)
+{
+	char* dst = ConvertUtf8ToGBK(str.c_str());
+	str = dst;
+	delete[] dst;
+}
 
-static ErrorCodeEnum GetINETMacAddresses(NetworkAddressesList& macList, NetworkAddressesList& ipList)
+static char* ConvertGBKToUtf8(const char* gbk, int* n)
 {
-#if defined(RVC_OS_WIN)
-    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
-    ULONG family = AF_INET;
-    ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
-    ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
-    // Make an initial call to GetAdaptersAddresses to get the 
-    // size needed into the outBufLen variable
-    if (GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen) == ERROR_BUFFER_OVERFLOW) {
-        pAddresses = static_cast<PIP_ADAPTER_ADDRESSES>(HeapAlloc(GetProcessHeap(), 0, outBufLen));
-    }
+	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
+	WCHAR* wszGBK = new WCHAR[len + 1];
+	memset(wszGBK, 0, len * 2 + 2);
+	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
+
+	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
+	char* szUtf8 = new char[len + 1];
+	memset(szUtf8, 0, len + 1);
+	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
+
+	delete[] wszGBK;
+	*n = len - 1;
+	return szUtf8;
+}
 
-    Dbg("GetAdaptersAddresses 1");
+static void ConvertGBKToUtf8(std::string& str)
+{
+	int len = 0;
+	char* dst = ConvertGBKToUtf8(str.c_str(), &len);
+	str = dst;
+	delete[] dst;
+}
+#endif //_MSC_VER
 
-    if (NULL == pAddresses) {
-        Dbg("pAddresses = NULL");
-        return Error_Unexpect;
-    }
+static std::string W2S(const std::wstring wstr)
+{
+#if defined(_MSC_VER)
+	char* str = NULL;
+	int n = ::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
+	if (n > 0) {
+		str = new char[n + 1];
+		if (str == NULL) {
+			return std::string();
+		}
+		std::memset(str, 0, sizeof(char) * (n + 1));
+		::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, &str[0], n, NULL, NULL);
+		std::string strr(str);
+		delete str;
+		return strr;
+	}
+#else
+	///*TODO(80374374@3/7/2023):  */
+#endif //_MSC_VER
+	return std::string();
+}
 
-    DWORD dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
-    Dbg("GetAdaptersAddresses 2");
+static std::wstring S2W(const std::string str)
+{
+#if defined(_MSC_VER)
+	wchar_t* wstr = NULL;
+	int n = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);
+	if (n > 0) {
+		wstr = new wchar_t[n + 1];
+		if (wstr == NULL) {
+			return std::wstring();
+		}
+		std::memset(wstr, 0, (n + 1) * sizeof(wchar_t));
+		::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, &wstr[0], n);
+		std::wstring strr(wstr);
+		delete wstr;
+		return strr;
+	}
+#else
+	///*TODO(80374374@3/7/2023):  */
+#endif //_MSC_VER
+	return std::wstring();
+}
 
-    /*		MACAddresses vAddress;*/
-    if (dwRetVal != ERROR_SUCCESS) {
-        Dbg("dwRetVal = %d", dwRetVal);
-        return Error_Unexpect;
-    }
-    PIP_ADAPTER_ADDRESSES pFirst = pAddresses;
-    while (pAddresses) {
-        if (pAddresses->FirstUnicastAddress->Address.lpSockaddr->sa_family == AF_INET &&
-            pAddresses->OperStatus == IfOperStatusUp &&
-            pAddresses->IfType != IF_TYPE_SOFTWARE_LOOPBACK) {
-            Dbg("in while if 1");
-            BYTE* pa = pAddresses->PhysicalAddress;
-            if (!pa) {
-                pAddresses = pAddresses->Next ? pAddresses->Next : NULL;
-                continue;
-            }
-            Dbg("in while if 2");
-            char bAddressBytes[MACSESION];
-            int bAddressInt[MACSESION];
-            memset(bAddressBytes, 0, MACSESION);
-            size_t nAddressSize = pAddresses->PhysicalAddressLength;
-            memcpy(bAddressBytes, pa, (nAddressSize < MACSESION ? nAddressSize : MACSESION));
-            char CommarSeperatedAddress[MACSESION * 3] = { 0 };
-            for (int i = 0; i < MACSESION; ++i) {
-                bAddressInt[i] = bAddressBytes[i];
-                bAddressInt[i] &= 0x000000ff; // avoid "ff" leading bytes when "char" is lager then 0x7f
-            }
-            Dbg("in while if 3");
-            sprintf(CommarSeperatedAddress, "%02x:%02x:%02x:%02x:%02x:%02x",
-                    bAddressInt[0],
-                    bAddressInt[1],
-                    bAddressInt[2],
-                    bAddressInt[3],
-                    bAddressInt[4],
-                    bAddressInt[5]); // Should use scl::FormatString inside 
-            CSimpleStringA tmpmac = CSimpleStringA(CommarSeperatedAddress);
-            Dbg("in while if 4");
+} //namespace Util
 
-            macList.Append(&tmpmac, 0, 1);
-            Dbg("Description : %s", pAddresses->Description);
-            Dbg("OperStatus : %d, IfType = %d, mac = %s", pAddresses->OperStatus, pAddresses->IfType, CommarSeperatedAddress);
-            sockaddr_in* sa_in = (sockaddr_in*)pAddresses->FirstUnicastAddress->Address.lpSockaddr;
-            char buf_addr[100] = { 0 };
-            CSimpleStringA tmpip = CSimpleStringA(inet_ntop(AF_INET, &(sa_in->sin_addr), buf_addr, 100));
-            ipList.Append(&tmpip, 0, 1);
-        }
-        pAddresses = pAddresses->Next ? pAddresses->Next : NULL;
-    }
-    HeapFree(GetProcessHeap(), 0, pFirst);
+namespace Net{
 
-    return Error_Succeed;
+	struct NetworkAdapterItem
+	{
+		int idx;
+		std::string friend_name;
+		std::string adapter_name;
+		std::string description;
+		std::string ip;
+		std::string mask;
+		std::string mac;
+		std::string gateway;
+		std::string dhcp;
+		bool is_physical;
+		DWORD type;
+		int operStatus;
+		bool isLocal;
+
+		NetworkAdapterItem() :idx(0), friend_name(""), adapter_name(""), description(""), ip(""), mask(""),
+			mac(""), gateway(""), dhcp(""), is_physical(true), type(0), operStatus(0), isLocal(false)
+		{
+		}
+	};
+
+static bool IsLocalAdapter(const std::string& name)
+	{
+#if defined(_MSC_VER)
+		if (name.length() <= 0) {
+			return false;
+	}
+		std::string key("SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}");
+		HKEY h_sub_key = NULL;
+		LONG ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, key.c_str(), 0, KEY_READ, &h_sub_key);
+		if (ret != 0) {
+			return false;
+		}
+		std::ostringstream str;
+		str << name << "\\Connection";
+		HKEY h_local_key = NULL;
+		ret = RegOpenKeyEx(h_sub_key, str.str().c_str(), 0, KEY_READ, &h_local_key);
+		if (0 != ret) {
+			RegCloseKey(h_sub_key);
+			return false;
+		}
+		DWORD type = REG_SZ;
+		TCHAR buf[250];
+		DWORD buf_size = 250;
+		ret = RegQueryValueEx(h_local_key, "PnPInstanceId", 0, &type, (BYTE*)(buf), &buf_size);
+		RegCloseKey(h_sub_key);
+		RegCloseKey(h_local_key);
+		if (0 != ret) {
+			return false;
+		}
+		if (0 == strnicmp(buf, "PCI", strlen("PCI")) || 0 == strnicmp(buf, "USB", strlen("USB"))) {
+			return true;
+		}
+		return false;
+#else
+		///*TODO(80374374@3/7/2023):  */
+		return true;
+#endif //_MSC_VER
+	}
+
+static ErrorCodeEnum GetINETMacAddresses(NetworkAddressesList& macList, NetworkAddressesList& ipList)
+{
+#if defined(RVC_OS_WIN)
+	PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+	ULONG family = AF_INET;
+	ULONG flags = GAA_FLAG_INCLUDE_PREFIX;
+	ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES);
+	// Make an initial call to GetAdaptersAddresses to get the 
+	// size needed into the outBufLen variable
+	if (GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen) == ERROR_BUFFER_OVERFLOW) {
+		pAddresses = static_cast<PIP_ADAPTER_ADDRESSES>(HeapAlloc(GetProcessHeap(), 0, outBufLen));
+	}
+
+	if (NULL == pAddresses) {
+		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pAddresses = NULL");
+		return Error_Unexpect;
+	}
+	DWORD dwRetVal = GetAdaptersAddresses(family, flags, NULL, pAddresses, &outBufLen);
+	/*		MACAddresses vAddress;*/
+	if (dwRetVal != ERROR_SUCCESS) {
+		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("dwRetVal = %d", dwRetVal);
+		return Error_Unexpect;
+	}
+	PIP_ADAPTER_ADDRESSES pFirst = pAddresses;
+	while (pAddresses) {
+		if (pAddresses->FirstUnicastAddress->Address.lpSockaddr->sa_family == AF_INET &&
+			pAddresses->OperStatus == IfOperStatusUp &&
+			pAddresses->IfType != IF_TYPE_SOFTWARE_LOOPBACK) {
+			BYTE* pa = pAddresses->PhysicalAddress;
+			if (!pa) {
+				pAddresses = pAddresses->Next ? pAddresses->Next : NULL;
+				continue;
+			}
+
+			CSimpleStringA strFriendlyName(true);
+			CSimpleStringA strDescription(true);
+
+			DWORD dwNum = WideCharToMultiByte(CP_OEMCP, NULL, pAddresses->FriendlyName, -1, NULL, 0, NULL, FALSE);
+			char* psText = new char[dwNum];
+			if (psText != NULL) {
+				WideCharToMultiByte(CP_OEMCP, NULL, pAddresses->FriendlyName, -1, psText, dwNum, NULL, FALSE);
+				strFriendlyName = psText;
+				delete[] psText;
+			}
+
+			dwNum = WideCharToMultiByte(CP_OEMCP, NULL, pAddresses->Description, -1, NULL, 0, NULL, FALSE);
+			psText = new char[dwNum];
+			if (psText != NULL) {
+				WideCharToMultiByte(CP_OEMCP, NULL, pAddresses->Description, -1, psText, dwNum, NULL, FALSE);
+				strDescription = psText;
+				delete[] psText;
+			}
+
+			char bAddressBytes[MACSESION];
+			int bAddressInt[MACSESION];
+			memset(bAddressBytes, 0, MACSESION);
+			size_t nAddressSize = pAddresses->PhysicalAddressLength;
+			memcpy(bAddressBytes, pa, (nAddressSize < MACSESION ? nAddressSize : MACSESION));
+			for (int i = 0; i < MACSESION; ++i) {
+				bAddressInt[i] = bAddressBytes[i];
+				bAddressInt[i] &= 0x000000ff; // avoid "ff" leading bytes when "char" is lager then 0x7f
+			}
+			CSimpleStringA tmpmac = CSimpleStringA::Format("%02x:%02x:%02x:%02x:%02x:%02x",
+				bAddressInt[0],
+				bAddressInt[1],
+				bAddressInt[2],
+				bAddressInt[3],
+				bAddressInt[4],
+				bAddressInt[5]);
+
+			macList.Append(&tmpmac, 0, 1);
+			sockaddr_in* sa_in = (sockaddr_in*)pAddresses->FirstUnicastAddress->Address.lpSockaddr;
+			char buf_addr[100] = { 0 };
+			CSimpleStringA tmpip = CSimpleStringA(inet_ntop(AF_INET, &(sa_in->sin_addr), buf_addr, 100));
+			ipList.Append(&tmpip, 0, 1);
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s, %s: OperStatus: %d, IfType = %d, ip=%s, mac=%s"
+				, strFriendlyName.GetData(), strDescription.GetData()
+				, pAddresses->OperStatus, pAddresses->IfType, tmpip.GetData(), tmpmac.GetData());
+}
+		pAddresses = pAddresses->Next ? pAddresses->Next : NULL;
+}
+	HeapFree(GetProcessHeap(), 0, pFirst);
+	return Error_Succeed;
 
 #else
     std::map<std::string, std::string> inteIPs;
@@ -539,6 +821,182 @@ static ErrorCodeEnum GetINETMacAddresses(NetworkAddressesList& macList, NetworkA
 
 }
 
+
+static std::vector<NetworkAdapterItem> GetNetAdapterItems()
+{
+	std::vector<NetworkAdapterItem> results;
+#if defined(_MSC_VER)
+	ULONG flags = GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_INCLUDE_GATEWAYS;
+	ULONG family = AF_UNSPEC;
+	PIP_ADAPTER_ADDRESSES address_ptr = nullptr;
+	ULONG out_buf_len = 15000;
+	DWORD ret_val = 0;
+	PIP_ADAPTER_ADDRESSES cur_addr_ptr = nullptr;
+	PIP_ADAPTER_UNICAST_ADDRESS unicast_ptr = nullptr;
+	PIP_ADAPTER_ANYCAST_ADDRESS anycast_ptr = nullptr;
+	PIP_ADAPTER_MULTICAST_ADDRESS multicast_ptr = nullptr;
+	PIP_ADAPTER_DNS_SERVER_ADDRESS dns_server_ptr = nullptr;
+	IP_ADAPTER_PREFIX* prefix_ptr = nullptr;
+
+	do {
+		address_ptr = (PIP_ADAPTER_ADDRESSES)malloc(out_buf_len);
+		if (address_ptr == nullptr) {
+			return results;
+		}
+		ret_val = GetAdaptersAddresses(family, flags, NULL, address_ptr, &out_buf_len);
+		if (ERROR_BUFFER_OVERFLOW == ret_val) {
+			free(address_ptr);
+		}
+	} while (ret_val == ERROR_BUFFER_OVERFLOW);
+
+	if (NO_ERROR == ret_val) {
+		cur_addr_ptr = address_ptr;
+		while (cur_addr_ptr) {
+			std::string description = Util::W2S(cur_addr_ptr->Description);
+			bool is_local = IsLocalAdapter(cur_addr_ptr->AdapterName);
+			std::string friend_name = Util::W2S(cur_addr_ptr->FriendlyName);
+			NetworkAdapterItem item;
+			item.idx = cur_addr_ptr->IfIndex;
+			item.adapter_name = cur_addr_ptr->AdapterName;
+			item.description = description;
+			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(">>>>>>>>>>>>>>> friendly name: %s", friend_name.c_str());
+			item.friend_name = friend_name;
+			if (is_local) {
+				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Adapter Desc: %s", description.c_str());
+				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Adapter Name: %s", cur_addr_ptr->AdapterName);
+				item.isLocal = true;
+			}
+			if (cur_addr_ptr->PhysicalAddressLength != 0) {
+				char sz_addr[32] = { 0 };
+				std::stringstream str;
+				for (int i = 0; i < (int)cur_addr_ptr->PhysicalAddressLength; i++) {
+					if (i == ((int)cur_addr_ptr->PhysicalAddressLength - 1))
+						sprintf_s(sz_addr, "%.2X", (int)cur_addr_ptr->PhysicalAddress[i]);
+					else
+						sprintf_s(sz_addr, "%.2X:", (int)cur_addr_ptr->PhysicalAddress[i]);
+					str << sz_addr;
+				}
+				item.mac = str.str();
+			}
+			item.type = cur_addr_ptr->IfType;
+			item.operStatus = cur_addr_ptr->OperStatus;
+			switch (cur_addr_ptr->IfType) {
+			case MIB_IF_TYPE_OTHER:
+				break;
+			case MIB_IF_TYPE_ETHERNET:
+				break;
+			case MIB_IF_TYPE_TOKENRING:
+				break;
+			case MIB_IF_TYPE_FDDI:
+				break;
+			case MIB_IF_TYPE_PPP:
+				break;
+			case MIB_IF_TYPE_LOOPBACK:
+				break;
+			case MIB_IF_TYPE_SLIP:
+				break;
+			case IF_TYPE_IEEE80211:
+				break;
+			case IF_TYPE_WWANPP:
+			case IF_TYPE_WWANPP2:
+				//WWAN devices
+				break;
+			default:
+				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unknown type %d", cur_addr_ptr->IfType);
+				break;
+			}
+			unicast_ptr = cur_addr_ptr->FirstUnicastAddress;
+			while (unicast_ptr) {
+				char ip[120] = { 0 };
+				if (AF_INET == unicast_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET, &((sockaddr_in*)unicast_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				} else if (AF_INET6 == unicast_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET6, &((sockaddr_in*)unicast_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				}
+				unicast_ptr = unicast_ptr->Next;
+			}
+			if (cur_addr_ptr->Dhcpv4Server.lpSockaddr) {
+				char ip[120] = { 0 };
+				if (AF_INET == cur_addr_ptr->Dhcpv4Server.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET, &((sockaddr_in*)cur_addr_ptr->Dhcpv4Server.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				} else if (AF_INET6 == cur_addr_ptr->Dhcpv4Server.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET6, &((sockaddr_in*)cur_addr_ptr->Dhcpv4Server.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				}
+				item.dhcp = ip;
+			}
+			dns_server_ptr = cur_addr_ptr->FirstDnsServerAddress;
+			while (dns_server_ptr) {
+				char ip[120] = { 0 };
+				if (AF_INET == dns_server_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET, &((sockaddr_in*)dns_server_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				} else if (AF_INET6 == dns_server_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET6, &((sockaddr_in*)dns_server_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				}
+				dns_server_ptr = dns_server_ptr->Next;
+			}
+			auto gateway_ptr = cur_addr_ptr->FirstGatewayAddress;
+			while (gateway_ptr) {
+				char ip[120] = { 0 };
+				if (AF_INET == gateway_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET, &((sockaddr_in*)gateway_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				} else if (AF_INET6 == gateway_ptr->Address.lpSockaddr->sa_family) {
+					inet_ntop(PF_INET6, &((sockaddr_in*)gateway_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
+				}
+				gateway_ptr = gateway_ptr->Next;
+			}
+			results.push_back(item);
+			cur_addr_ptr = cur_addr_ptr->Next;
+		}
+	} else {
+		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("GetAdaptersAddresses failed with error: %d", ret_val);
+	}
+	free(address_ptr);
+#else
+///*TODO(80374374@3/7/2023):  */
+#endif //_MSC_VER
+	return results;
+}
+
+static BOOL CheckLANConnectStatus()
+{
+#if defined(_MSC_VER)
+	DWORD dwFlag(0);
+	BOOL bRet = InternetGetConnectedState(&dwFlag, 0);
+
+	if ((dwFlag & INTERNET_CONNECTION_CONFIGURED) == INTERNET_CONNECTION_CONFIGURED) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system has a valid connection to the Internet, but it might or might not be currently connected.");
+	}
+	if ((dwFlag & INTERNET_CONNECTION_LAN) == INTERNET_CONNECTION_LAN) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a local area network to connect to the Internet.");
+	}
+	if ((dwFlag & INTERNET_CONNECTION_MODEM) == INTERNET_CONNECTION_MODEM) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a modem to connect to the Internet.");
+	}
+	if ((dwFlag & INTERNET_CONNECTION_MODEM_BUSY) == INTERNET_CONNECTION_MODEM_BUSY) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("No longer used: INTERNET_CONNECTION_MODEM_BUSY");
+	}
+	if ((dwFlag & INTERNET_CONNECTION_OFFLINE) == INTERNET_CONNECTION_OFFLINE) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system is in offline mode.");
+	}
+	if ((dwFlag & INTERNET_CONNECTION_PROXY) == INTERNET_CONNECTION_PROXY) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a proxy server to connect to the Internet.");
+	}
+	if ((dwFlag & INTERNET_RAS_INSTALLED) == INTERNET_RAS_INSTALLED) {
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system has RAS installed.");
+	}
+
+	if (bRet) {
+		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InternetGetConnectedState Succeed: 0x%08X", dwFlag);
+	} else {
+		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("InternetGetConnectedState failed: 0x%08X, GLE=%u", dwFlag, GetLastError());
+	}
+	return bRet;
+#else
+	return FALSE;
+#endif //_MSC_VER
+
+}
+
 static std::string GetWWWInfoThroughDig(const std::string& wwwUrl)
 {
     std::string succStr, errStr;

Module/include/DevEntityCommBase.hpp

@@ -7,10 +7,11 @@
 #include "SpHelper.h"
 #include "DeviceBaseClass.h"
 #include "SimpleString.h"
+#include "ModuleMix.h"
 #include "path.h"
 #include "toolkit.h"
-#include <regex>
 
+#include <regex>
 
 struct VendorLibInfo
 {
@@ -94,7 +95,6 @@ struct VendorLibInfo
 	}
 };
 
-
 class CDevAdptEntityBase : public CEntityBase
 {
 
@@ -119,6 +119,9 @@ public:
 
 	VendorLibInfo vendorLibInfo;
 
+protected:
+	virtual ErrorCodeEnum CustomVendorLibInfo() { return Error_Succeed; }
+
 private:
 
 	ErrorCodeEnum ExtractVendorLibName();
@@ -140,8 +143,70 @@ inline ErrorCodeEnum CDevAdptEntityBase::ExtractVendorLibName()
 		spRootConfig->ReadConfigValue(strSection, "Vendor", vendorLibInfo.strVendor);
 		spRootConfig->ReadConfigValue(strSection, "Version", vendorLibInfo.strVersion);
 		spRootConfig->ReadConfigValue(strSection, "Batch", vendorLibInfo.strBatch);
+
+#if defined(_MSC_VER)
+
+		int iVersion = 0;
+		int iBatch = 0;
+		if (!vendorLibInfo.strVersion.IsNullOrEmpty()) iVersion = atoi((const char*)vendorLibInfo.strVersion);
+		if (!vendorLibInfo.strBatch.IsNullOrEmpty()) iBatch = atoi((const char*)vendorLibInfo.strBatch);
+
+		CSystemStaticInfo sysInfo;
+		erroCode = GetFunction()->GetSystemStaticInfo(sysInfo);
+		if (IS_SUCCEED(erroCode)) {
+			if (!sysInfo.strMachineType.Compare("RVC.Stand2S", true)) {
+				CSimpleStringA strVendor(true);
+				spRootConfig->ReadConfigValue("Device.PinPad", "Vendor", strVendor);
+				//zss first，kxd second，keba third
+				//TODO:kxd ,keba
+				if (!strVendor.Compare("Zss", true)) {
+					//如果配置大于等于7.1，直接读取root，否则映射加载7.1
+					if ((iVersion != 0 && iBatch != 0) && !(iVersion > 7 || (iVersion == 7 && iBatch >= 1))) {
+						//读取运行时信息
+						CSimpleStringA deviceInfo(true);
+						GetFunction()->GetSysVar("zssInfo", deviceInfo);
+						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("zssInfo:%s", deviceInfo.GetData());
+						if (!deviceInfo.Compare("ZSS9100", true)) {
+							vendorLibInfo.strVendor = "ZSS";
+							vendorLibInfo.strVersion = "7";
+							vendorLibInfo.strBatch = "1";
+						}
+					}
+				} else if (!strVendor.Compare("kxd", true)) {
+					//如果配置大于等于7.1，直接读取root，否则映射加载7.1
+					if ((iVersion != 0 && iBatch != 0) && !(iVersion > 7 || (iVersion == 7 && iBatch >= 1))) {
+						//读取运行时信息
+						CSimpleStringA deviceInfo(true);
+						GetFunction()->GetSysVar("kxdInfo", deviceInfo);
+						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("kxdInfo:%s", deviceInfo.GetData());
+						if (!deviceInfo.Compare("KS218", true)) {
+							vendorLibInfo.strVendor = "kxd";
+							vendorLibInfo.strVersion = "7";
+							vendorLibInfo.strBatch = "1";
+						}
+					}
+				} else if (!strVendor.Compare("Keba", true)) {
+					//如果配置大于等于7.1，直接读取root，否则映射加载7.1
+					if ((iVersion != 0 && iBatch != 0) && !(iVersion > 7 || (iVersion == 7 && iBatch >= 1))) {
+						//读取运行时信息
+						CSimpleStringA deviceInfo(true);
+						GetFunction()->GetSysVar("kebaInfo", deviceInfo);
+						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("kebaInfo:%s", deviceInfo.GetData());
+						if (!deviceInfo.Compare("E1080", true)) {
+							vendorLibInfo.strVendor = "keba";
+							vendorLibInfo.strVersion = "7";
+							vendorLibInfo.strBatch = "1";
+						}
+					}
+				}
+			}
+		}
+#endif //_MSC_VER
 	}
 
+	if (IS_SUCCEED(erroCode)) {
+		erroCode = CustomVendorLibInfo();
+	}
 	return erroCode;
 }
 
@@ -164,10 +229,12 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 
 	struct VendorLogConfig {
 
-		CSimpleStringA strLevel = "OFF";
-		CSimpleStringA strType = "FILE";
-		CSimpleStringA strDllName = "";
-		CSimpleStringA strLogPath = "";
+		VendorLogConfig() :strLevel("OFF"), strType("FILE"), strDllName(""), strLogPath("") {}
+
+		CSimpleStringA strLevel;
+		CSimpleStringA strType;
+		CSimpleStringA strDllName;
+		CSimpleStringA strLogPath;
 
 		void Settle()  {
 			toolkit_setenv("VENDOR_RECODE_LEVEL", strLevel);
@@ -186,10 +253,10 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 	CSimpleStringA str;
 	centerConfig->ReadConfigValue(GetEntityName(), vendorLibInfo.strVendor, str);
 	if (str.IsNullOrEmpty()) {
-		Dbg("To get all config");
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("To get all config");
 		centerConfig->ReadConfigValue(GetEntityName(), "All", str);
 	}
-	Dbg("All: %s", str.GetData());
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("All: %s", str.GetData());
 
 	if (!str.IsNullOrEmpty()) {
 		stLogConfig.strLevel = str;
@@ -202,7 +269,8 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 		CSimpleStringA strWhiteNameSheet;
 		centerConfig->ReadConfigValue(GetEntityName(), "AllowTerminals", strWhiteNameSheet);
 		Dbg("AllowTerminals: %s", strWhiteNameSheet.GetData());
-		if (!strWhiteNameSheet.IsNullOrEmpty())  {
+		/** 白名单存在，说明需要过滤终端号，但是集中配置改造后已经没有这种操作了，这个逻辑后续可以去掉 Gifur@2023328]*/
+		if (!strWhiteNameSheet.IsNullOrEmpty())  { 
 			bool bWhiteNameSheet = false;
 			
 			CAutoArray<CSimpleStringA> arrayWhiteNameSheet = strWhiteNameSheet.Split(',');
@@ -222,9 +290,9 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 	}
 
 	bool fromLocal = false;
-
+	/*从集中配置读取的开关为关闭，尝试读取本地的设置*/
 	if (stLogConfig.strLevel.Compare("OFF", true) == 0) {
-		Dbg("Try to read from global settings.");
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Try to read from global settings.");
 		CSmartPointer<IConfigInfo> spConfig;
 		ErrorCodeEnum erroCode = GetFunction()->OpenConfig(Config_Cache, spConfig);
 
@@ -232,7 +300,7 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 		spConfig->ReadAllKeys("AdapterLogSwith", adapters);
 		CSimpleStringA strKey(true);
 		for (int i = 0; i < adapters.GetCount(); ++i) {
-            Dbg("%d: %s, %s", i, adapters[i].GetData(), GetEntityName());
+            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%d: %s, %s", i, adapters[i].GetData(), GetEntityName());
 			if (adapters[i].Compare(GetEntityName(), true) == 0) {
 				strKey = adapters[i];
 				break;
@@ -242,7 +310,7 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 			CSimpleStringA strValue(true);
 			spConfig->ReadConfigValue("AdapterLogSwith", strKey, strValue);
 			CAutoArray<CSimpleStringA> settings;
-			Dbg("Value: %s", strValue.GetData());
+			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Value: %s", strValue.GetData());
 			if (!strValue.IsNullOrEmpty() && (settings = strValue.Split(',')).GetCount() == 2) {
 				if (settings[0].GetLength() == 1 && atoi(settings[0]) >= 1 && settings[1].GetLength() == 1) {
 					if (settings[1].Compare("1") == 0)  stLogConfig.strLevel = "Fatal";
@@ -265,7 +333,7 @@ inline void CDevAdptEntityBase::InitializeVendorLogSwitch()
 			stLogConfig.strType = str;
 
 		GetFunction()->GetPath("Dbg", stLogConfig.strLogPath);
-		Dbg("Dbg: %s", stLogConfig.strLogPath.GetData());
+		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Dbg: %s", stLogConfig.strLogPath.GetData());
 		stLogConfig.Settle();
 
         do {

Module/include/DevFSMCommBase.hpp

@@ -9,14 +9,16 @@
 #include "DeviceBaseClass.h"
 #include "publicFunExport.h"
 #include <winpr/file.h>
+#include <map>
+#include <string>
 
-#if DEVICE_BASE_INTERFACE_FILE_VERSION == 2
-using DevAdaptObjCreateFunc = ErrorCodeEnum(*)(DWORD dwDevClassID, DeviceBaseClass * &pOutDevAptObj);
-using DevAdaptObjReleaseFunc = ErrorCodeEnum(*)(DWORD dwDevClassID, DeviceBaseClass * &pInDevAptObj);
-#else
-using DevAdaptObjCreateFunc = ErrorCodeEnum(*)(DeviceBaseClass * &pOutDevAptObj);
-using DevAdaptObjReleaseFunc = ErrorCodeEnum(*)(DeviceBaseClass * &pInDevAptObj);
-#endif
+#if defined(_MSC_VER)
+typedef ErrorCodeEnum(*DevAdaptObjCreateFunc)(DeviceBaseClass*& baseObj);
+typedef ErrorCodeEnum(*DevAdaptObjReleaseFunc)(DeviceBaseClass*& pBaseObj);
+#else //C/C++ Compiler 
+using DevAdaptObjCreateFunc = ErrorCodeEnum(*)(DeviceBaseClass*& pOutDevAptObj);
+using DevAdaptObjReleaseFunc = ErrorCodeEnum(*)(DeviceBaseClass*& pInDevAptObj);
+#endif //_MSC_VER
 
 #define HARDWARE_ENTITY_RESET_ENTITYID(ent, entityID)	\
 do{\
@@ -88,29 +90,6 @@ do {\
 #define LOG_WATCHDOG_ERROR_MSG_MACRO(errCode, MethodSig)\
 	LOG_ERROR_MSG_MACRO(errCode, MethodSig, WATCHDOG)
 
-/*
-
-assert(DeviceBaseHelper::GetCurVendorType("") == Vendor_Invalide);
-assert(DeviceBaseHelper::GetCurVendorType("buzhidao") == Vendor_Invalide);
-assert(DeviceBaseHelper::GetCurVendorType("hyosung") == Vendor_Hyosung);
-assert(DeviceBaseHelper::GetCurVendorType("KXD") == Vendor_Kxd);
-assert(DeviceBaseHelper::GetCurVendorType("KEBa") == Vendor_Keba);
-assert(DeviceBaseHelper::GetCurVendorType("nanTiAn") == Vendor_Nantian);
-assert(DeviceBaseHelper::GetCurVendorType("YOTAP") == Vendor_yotap);
-assert(DeviceBaseHelper::GetCurVendorType("zSs") == Vendor_ZSS);
-assert(DeviceBaseHelper::GetCurVendorType("GWI") == Vendor_GreateWall);
-assert(DeviceBaseHelper::GetCurVendorType("yihua") == Vendor_YiHua);
-assert(DeviceBaseHelper::GetCurVendorType("yh") == Vendor_YiHua);
-assert(DeviceBaseHelper::GetCurVendorType("GRG") == Vendor_GRG);
-assert(DeviceBaseHelper::GetCurVendorType("cw") == Vendor_CW);
-assert(DeviceBaseHelper::GetCurVendorType("eastCOM") == Vendor_EastCom);
-assert(DeviceBaseHelper::GetCurVendorType("hx") == Vendor_HuaXin);
-assert(DeviceBaseHelper::GetCurVendorType("sankyo") == Vendor_Sankyo);
-assert(DeviceBaseHelper::GetCurVendorType("chinavision") == Vendor_ChinaVision);
-
-
-*/
-
 enum VendorNameType 
 {
 	Vendor_Invalide,
@@ -149,58 +128,26 @@ static const char* VendorNameStr[] = {
 	"hx"
 };
 
-static std::map<CSimpleStringA, DWORD> WarnCodeMap = {
-	{"CardIssuer", 0x2030021f},//在各实体entity_UserErrorCode.h头文件中定义
-	{"ContactlessCard", 0x21300203},
-	{"CardSwiper", 0x20200207},
-	{"FingerPrint", 0x20400211},
-	{"IDCertificate", 0x20100202},
-	{"PinPad", 0x20600207},
-	{"Gpio", 0x20900201},
-	{"HSPScanner", 0x21700207},
-	{"WatchDog", 0x20d00201},
-	{"Ups", 0x20e00201}
-};
-
-static std::map<CSimpleStringA, DWORD> RootIniCodeMap = {
-    {"CardIssuer", 0x20300299},
-    {"ContactlessCard", 0x21300224},
-    {"CardSwiper", 0x20200238},
-    {"FingerPrint", 0x20400229},
-    {"IDCertificate", 0x2010021f},
-    {"PinPad", 0x2060021f},
-    {"Gpio", 0x20900203},
-    {"HSPScanner", 0x2170020f},
-    {"WatchDog", 0x20d00204},
-    {"Ups", 0x20e00204}
-};
-
 inline static VendorNameType GetCurVendorType(LPCTSTR vendorName)
 {
-	if (vendorName == NULL || strlen(vendorName) == 0)  {
+	if (vendorName == NULL || strlen(vendorName) == 0) {
 		return Vendor_Invalide;
 	}
-
 	int idx = -1;
-
-	for (int i = 0; i < sizeof(VendorNameStr) / sizeof(VendorNameStr[0]); ++i)  {
-		if (strnicmp(vendorName, VendorNameStr[i], strlen(VendorNameStr[i])) == 0)  {
+	for (int i = 0; i < sizeof(VendorNameStr) / sizeof(VendorNameStr[0]); ++i) {
+		if (strnicmp(vendorName, VendorNameStr[i], strlen(VendorNameStr[i])) == 0) {
 			idx = i;
 			break;
 		}
 	}
-
 	if (idx == -1) {
-
 		/*历史遗留原因，怡化厂商有两个适配器名字*/
 		if (strnicmp(vendorName, "yihua", strlen("yihua")) == 0) {
 			idx = Vendor_YiHua;
-		
 		} else {
 			idx = Vendor_Invalide;
 		}
 	}
-
 	return (VendorNameType)idx;
 }
 
@@ -240,7 +187,6 @@ struct DevAdptLibHelper
 		{
 			TearDown();
 		}
-
 		return erroCode;
 	}
 
@@ -258,9 +204,7 @@ struct DevAdptLibHelper
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("Create device adapter object failed! EC=%s", SpStrError(erroCode));
 			return erroCode;
 		}
-
 		LOG_ASSERT(m_AdptObjPtr != nullptr);
-
 		return Error_Succeed;
 	}
 
@@ -288,11 +232,7 @@ struct DevAdptLibHelper
 				DeviceBaseClass* devBasePtr = static_cast<DeviceBaseClass*>(m_AdptObjPtr);
 				if (devBasePtr != nullptr) {
 					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("To Release DevAdapter Object...");
-#if DEVICE_BASE_INTERFACE_FILE_VERSION == 2
-                    pFuncReleaseAdapt(0, devBasePtr);
-#else
                     pFuncReleaseAdapt(devBasePtr);
-#endif
                     m_AdptObjPtr = nullptr;
 				} else {
 					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("static cast base dev class failed!");
@@ -304,7 +244,7 @@ struct DevAdptLibHelper
 		pFuncReleaseAdapt = pFuncCreateAdapt = nullptr;
 	}
 
-	explicit operator bool() const { return (m_AdptObjPtr != nullptr); }
+	operator bool() const { return (m_AdptObjPtr != nullptr); }
 	operator DeviceBaseClass* () { return m_AdptObjPtr; }
 
 	TSubAdpt* GetDevPointer() { return m_AdptObjPtr; }
@@ -338,35 +278,69 @@ struct DevAdptLibHelper
 		TearDown();
 	}
 
-	DevAdptLibHelper(const DevAdptLibHelper&) = delete; 
+#if defined(RVC_OS_LINUX)
+	DevAdptLibHelper(const DevAdptLibHelper&) = delete;
 	DevAdptLibHelper& operator=(const DevAdptLibHelper&) = delete;
+#endif //RVC_OS_LINUX
 
 private:
 
 	toolkit_lib_t m_lib;
-
 	DevAdaptObjCreateFunc pFuncCreateAdapt;
 	DevAdaptObjReleaseFunc pFuncReleaseAdapt;
 
 	TSubAdpt* m_AdptObjPtr;
 };
 
-struct AdapterInfo
+
+struct AdaptorInfo
 {
+
+public:
+
+	CSimpleStringA strVendor;
+	CSimpleStringA strVersion;
+	CSimpleStringA strBatch;
+	CSimpleStringA strPort;
+	CSimpleStringA strBaudrate;
+	CSimpleStringA strPortNum;
+	CSimpleStringA strInOutDir;
+	CSimpleStringA strCheckdata;
+	CSimpleStringA strKeysn;
+
+	AdaptorInfo() :strVendor(true), strVersion(true), strBatch(true)
+		, strPort(true), strBaudrate(true)
+		, strPortNum(true), strInOutDir(true)
+		, strCheckdata(true), strKeysn(true)
+	{
+	}
+};
+
+struct AdapterInfo : public AdaptorInfo
+{
+	CSimpleStringA adapterFilePath;
 	CSimpleStringA adapterFileName;
+
 	DevCategoryInfo devCatInfo;
 
+	AdapterInfo() :adapterFilePath(true), adapterFileName(true)
+	{
+		ZeroMemory(devCatInfo.szModel, sizeof(devCatInfo.szModel));
+		ZeroMemory(devCatInfo.szType, sizeof(devCatInfo.szType));
+		ZeroMemory(devCatInfo.szVendor, sizeof(devCatInfo.szVendor));
+	}
+
 	void FulfillCategoryInfo(const DevCategoryInfo& rhs)
 	{
 		devCatInfo.eState = rhs.eState;
 		devCatInfo.version.wMajor = rhs.version.wMajor;
-        devCatInfo.version.wMinor = rhs.version.wMinor;
-        devCatInfo.version.wRevision = rhs.version.wRevision;
-        devCatInfo.version.wBuild = rhs.version.wBuild;
+		devCatInfo.version.wMinor = rhs.version.wMinor;
+		devCatInfo.version.wRevision = rhs.version.wRevision;
+		devCatInfo.version.wBuild = rhs.version.wBuild;
 
 		strcpy(devCatInfo.szType, rhs.szType);
-        strcpy(devCatInfo.szModel, rhs.szModel);
-        strcpy(devCatInfo.szVendor, rhs.szVendor);
+		strcpy(devCatInfo.szModel, rhs.szModel);
+		strcpy(devCatInfo.szVendor, rhs.szVendor);
 	}
 };
 
@@ -376,6 +350,8 @@ struct ErrorPackage {
 	CSimpleStringA devSN;
 	ErrorCodeEnum devErrCode;
 	DWORD apiErrCode;
+
+	ErrorPackage() :msgHead(true), devSN(true), devErrCode(Error_Succeed), apiErrCode(0) {}
 };
 
 struct DevEntityErrorCode {
@@ -421,7 +397,30 @@ class CCommDevFSM : public FSMImpl<TFSM>
 {
 
 public:
-	CCommDevFSM() :m_FirstStart(TRUE), m_bOpened(FALSE), m_csAlarmMsg("No more information"), m_contiErrTimes(0) {}
+	CCommDevFSM() :m_FirstStart(TRUE), m_bOpened(false), m_bOpening(false), m_csAlarmMsg("No more information"), m_contiErrTimes(0)
+	{
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("CardIssuer", 0x2030021f));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("ContactlessCard", 0x21300203));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("CardSwiper", 0x20200207));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("FingerPrint", 0x20400211));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("IDCertificate", 0x20100202));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("PinPad", 0x20600207));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("Gpio", 0x20900201));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("HSPScanner", 0x21700207));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("WatchDog", 0x20d00201));
+		m_WarnCodeMap.insert(std::make_pair<std::string, DWORD>("Ups", 0x20e00201));
+
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("CardIssuer", 0x20300299));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("ContactlessCard", 0x21300224));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("CardSwiper", 0x20200238));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("FingerPrint", 0x20400229));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("IDCertificate", 0x2010021f));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("PinPad", 0x2060021f));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("Gpio", 0x20900203));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("HSPScanner", 0x2170020f));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("WatchDog", 0x20d00204));
+		m_RootIniCodeMap.insert(std::make_pair<std::string, DWORD>("Ups", 0x20e00204));
+	}
 
 	ErrorCodeEnum GetAndSplitDevErrInfo(
 		CSimpleStringA& csErrMsg, WORD& wdDevErrCode, LPCTSTR lpszFuncNameForDisplay = "");
@@ -438,140 +437,247 @@ public:
 		ErrorCodeEnum eRet = GetAndSplitDevErrInfo(csMsg, wdErrorCode);
 		return (eRet == Error_Succeed);
 	}
-	void SetErrPackage(ErrorPackage& errPkg, CSimpleStringA msgHead, CSimpleStringA devSN, ErrorCodeEnum errCode, DWORD apiCode)
+	void SetErrPackage(CSimpleStringA msgHead, CSimpleStringA devSN, ErrorCodeEnum errCode, DWORD apiCode)
 	{
-		errPkg.msgHead = msgHead;
-		errPkg.devSN = devSN;
-		errPkg.devErrCode = errCode;
-		errPkg.apiErrCode = apiCode;
+		m_errPkg.msgHead = msgHead;
+		m_errPkg.devSN = devSN;
+		m_errPkg.devErrCode = errCode;
+		m_errPkg.apiErrCode = apiCode;
 	}
 
-	DWORD AlarmDEC(ErrorPackage errPkg, bool bToBusiness = false, bool alarmOrNot = true) {
+	DWORD AlarmDEC(bool bToBusiness = false, bool alarmOrNot = true) {
 		WORD wdErrCode = 0;
 		CSimpleStringA csErrMsg(true);
-		ErrorCodeEnum ec = GetAndSplitDevErrInfo(csErrMsg, wdErrCode, (LPCTSTR)errPkg.msgHead);
+		ErrorCodeEnum ec = GetAndSplitDevErrInfo(csErrMsg, wdErrCode, (LPCTSTR)m_errPkg.msgHead);
 		if (ec == Error_Succeed && wdErrCode != 0) {
 			//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
-			if ((errPkg.apiErrCode >> 20) == m_entCode.dwEntityId)
-				UpdateDEC(errPkg.apiErrCode);
+			if ((m_errPkg.apiErrCode >> 20) == m_entCode.dwEntityId)
+				UpdateDEC(m_errPkg.apiErrCode);
 			else
 				UpdateDEC(wdErrCode);
-
 		}
-		else if (errPkg.apiErrCode != 0) {
-			UpdateDEC(errPkg.apiErrCode);
+		else if (m_errPkg.apiErrCode != 0) {
+			UpdateDEC(m_errPkg.apiErrCode);
 		}
 		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
 		DWORD dwCode = GetAlarmDEC();
 		if (alarmOrNot) {
-            LogErrMsgEx(errPkg, csErrMsg, dwCode, bToBusiness);
+            LogErrMsgEx(m_errPkg, csErrMsg, dwCode, bToBusiness);
 		} else {
             const CSimpleStringA alarmMsg = CSimpleStringA::Format("{\"DevSN\":\"%s\", \"Prefix\":\"%s\", \"Code\":\"%s\", \"Msg\":\"%s\"}"
-                                                                   , errPkg.devSN.GetData(), errPkg.msgHead.GetData(), SpStrError(errPkg.devErrCode), csErrMsg);
+                                                                   , m_errPkg.devSN.GetData(), m_errPkg.msgHead.GetData(), SpStrError(m_errPkg.devErrCode), csErrMsg);
 			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(alarmMsg.GetData());
 		}
 		return dwCode;
 	}
+	/*fulfill adapter elem, open param and adapter file name&absolute path */
+	void FulfillAdapterInfoFrom(const VendorLibInfo& vendorLib)
+	{
+		m_adapterInfo.strVendor = vendorLib.strVendor;
+		m_adapterInfo.strVersion = vendorLib.strVersion;
+		m_adapterInfo.strBatch = vendorLib.strBatch;
+
+		CSmartPointer<IConfigInfo> spConfigRoot;
+		this->GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
+
+		CSimpleStringA entityName(this->GetEntityBase()->GetEntityName());
+		CSimpleStringA sectionName = CSimpleStringA::Format("Device.%s", entityName.GetData());
+		CSimpleStringA csVendor(true), csVersion(true), csBatch(true), csPort(true), csBaudrate(true);
+		//spConfigRoot->ReadConfigValue(sectionName.GetData(), "Vendor", csVendor);
+		//spConfigRoot->ReadConfigValue(sectionName.GetData(), "Version", csVersion);
+		//spConfigRoot->ReadConfigValue(sectionName.GetData(), "Batch", csBatch);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Port", csPort);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Baudrate", csBaudrate);
+
+		m_adapterInfo.strPort = csPort;
+		m_adapterInfo.strBaudrate = csBaudrate;
+
+		CSimpleStringA csPortNum(true), csCheckData(true), csKeySN(true), csInOutDir(true);
+		if (!entityName.Compare("Gpio")) {
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "PortNum", csPortNum);
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "InOutDir", csInOutDir);
+			m_adapterInfo.strPortNum = csPortNum;
+			m_adapterInfo.strInOutDir = csInOutDir;
+		} else if (!entityName.Compare("PinPad")) {
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "Checkdata", csCheckData);
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "Keysn", csKeySN);
+			m_adapterInfo.strCheckdata = csCheckData;
+			m_adapterInfo.strKeysn = csKeySN;
+		}
+
+		m_adapterInfo.adapterFileName = vendorLib.toLibNameString();
+		CSimpleStringA strDepPath;
+		this->GetEntityBase()->GetFunction()->GetPath("Dep", strDepPath);
+		m_adapterInfo.adapterFilePath = CSimpleStringA::Format(
+			"%s" SPLIT_SLASH_STR "%s", (LPCTSTR)strDepPath, (LPCTSTR)m_adapterInfo.adapterFileName);
+	}
+
+	ErrorCodeEnum FulfillAdapterDevCategory()
+	{
+		if (!!m_hDevHelper) {
+			ErrorCodeEnum result(Error_Succeed);
+			DevCategoryInfo devCat;
+			ZeroMemory(devCat.szModel, sizeof(devCat.szModel));
+			ZeroMemory(devCat.szType, sizeof(devCat.szType));
+			ZeroMemory(devCat.szVendor, sizeof(devCat.szVendor));
+			result = m_hDevHelper->GetDevCategory(devCat);
+			if (IS_SUCCEED(result)) {
+				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szVendor:%s,szType:%s,szModel:%s,version:%d.%d.%d.%d", devCat.szVendor
+					, devCat.szType, devCat.szModel, devCat.version.wMajor, devCat.version.wMinor, devCat.version.wRevision, devCat.version.wBuild);
+				m_adapterInfo.FulfillCategoryInfo(devCat);
+			}
+			return result;
+		}
+		return Error_InvalidState;
+	}
+
+#if defined(_MSC_VER)
+
+	const char* LPCSTRSmartPrintString(const CSimpleStringA& str)
+	{
+		return str.IsNullOrEmpty() ? "" : str.GetData();
+	}
 
-	void ToLogRootINIInfoOnce(FSMBase* pFSM)
+	CSimpleStringA GenerateJson(AdaptorInfo adaptorInfo, const CSimpleStringA& devDeviceName)
+	{
+		CSimpleStringA result(true);
+		if (0 == devDeviceName.Compare("Gpio", true)) {
+			result = CSimpleStringA::Format("{\"Vendor\":\"%s\", \"Version\":\"%s\", \"Batch\":\"%s\", \"Port\":\"%s\", \"Baudrate\":\"%s\", \"PortNum\":\"%s\", \"InOutDir\":\"%s\"}",
+				LPCSTRSmartPrintString(adaptorInfo.strVendor), LPCSTRSmartPrintString(adaptorInfo.strVersion),
+				LPCSTRSmartPrintString(adaptorInfo.strBatch), LPCSTRSmartPrintString(adaptorInfo.strPort), LPCSTRSmartPrintString(adaptorInfo.strBaudrate),
+				LPCSTRSmartPrintString(adaptorInfo.strPortNum), LPCSTRSmartPrintString(adaptorInfo.strInOutDir));
+		} else if (0 == devDeviceName.Compare("PinPad", true)) {
+			result = CSimpleStringA::Format("{\"Vendor\":\"%s\", \"Version\":\"%s\", \"Batch\":\"%s\", \"Port\":\"%s\", \"Baudrate\":\"%s\", \"Checkdata\":\"%s\", \"Keysn\":\"%s\"}",
+				LPCSTRSmartPrintString(adaptorInfo.strVendor), LPCSTRSmartPrintString(adaptorInfo.strVersion),
+				LPCSTRSmartPrintString(adaptorInfo.strBatch), LPCSTRSmartPrintString(adaptorInfo.strPort), LPCSTRSmartPrintString(adaptorInfo.strBaudrate),
+				LPCSTRSmartPrintString(adaptorInfo.strCheckdata), LPCSTRSmartPrintString(adaptorInfo.strKeysn));
+		} else {
+			result = CSimpleStringA::Format("{\"Vendor\":\"%s\", \"Version\":\"%s\", \"Batch\":\"%s\", \"Port\":\"%s\", \"Baudrate\":\"%s\"}",
+				LPCSTRSmartPrintString(adaptorInfo.strVendor), LPCSTRSmartPrintString(adaptorInfo.strVersion),
+				LPCSTRSmartPrintString(adaptorInfo.strBatch), LPCSTRSmartPrintString(adaptorInfo.strPort), LPCSTRSmartPrintString(adaptorInfo.strBaudrate));
+		}
+		return result;
+	}
+
+#endif //_MSC_VER
+
+	void ToLogRootINIInfoOnce()
 	{
         CSmartPointer<IConfigInfo> spConfig;
-        pFSM->GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, spConfig);
-		CSimpleStringA entityName(pFSM->GetEntityBase()->GetEntityName());
+		this->GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, spConfig);
+		CSimpleStringA entityName(this->GetEntityBase()->GetEntityName());
 		int nUploadTime(0);
 		spConfig->ReadConfigValueInt("RootUploadFlag", entityName, nUploadTime);
-
         SYSTEMTIME stNow = CSmallDateTime::GetNow().ToSystemTime();
         SYSTEMTIME lastUploadTime = CSmallDateTime(nUploadTime).ToSystemTime();
-
         if (lastUploadTime.wYear != stNow.wYear || lastUploadTime.wMonth != stNow.wMonth || lastUploadTime.wDay != stNow.wDay) {
-			ToLogRootINIInfo(pFSM);
+			ToLogRootINIInfo();
 			spConfig->WriteConfigValue("RootUploadFlag", entityName, CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
         }
 	}
 
 	/** GPIO不调用此接口 [Gifur@20221025]*/
-	void ToLogRootINIInfo(FSMBase* pFSM)
+	void ToLogRootINIInfo()
 	{
-        CSmartPointer<IConfigInfo> spConfigRoot;
-        pFSM->GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
+		CSimpleStringA entityName(this->GetEntityBase()->GetEntityName());
+		std::map<std::string, std::string> rootInfo;
+#if 1
+		rootInfo["Vendor"] = m_adapterInfo.strVendor.GetData();
+		rootInfo["Version"] = m_adapterInfo.strVersion.GetData();
+		rootInfo["Batch"] = m_adapterInfo.strBatch.GetData();
+		rootInfo["Port"] = m_adapterInfo.strPort.GetData();
+		rootInfo["Baudrate"] = m_adapterInfo.strBaudrate.GetData();
 
-        CSimpleStringA entityName(pFSM->GetEntityBase()->GetEntityName());
-        CSimpleStringA sectionName = CSimpleStringA::Format("Device.%s", entityName.GetData());
-        CSimpleStringA csVendor(true), csVersion(true), csBatch(true), csPort(true), csBaudrate(true);
-        spConfigRoot->ReadConfigValue(sectionName.GetData(), "Vendor", csVendor);
-        spConfigRoot->ReadConfigValue(sectionName.GetData(), "Version", csVersion);
-        spConfigRoot->ReadConfigValue(sectionName.GetData(), "Batch", csBatch);
-        spConfigRoot->ReadConfigValue(sectionName.GetData(), "Port", csPort);
-        spConfigRoot->ReadConfigValue(sectionName.GetData(), "Baudrate", csBaudrate);
+		if (!entityName.Compare("Gpio")) {
+			rootInfo["PortNum"] = m_adapterInfo.strPortNum.GetData();
+			rootInfo["InOutDir"] = m_adapterInfo.strInOutDir.GetData();
+		} else if (!entityName.Compare("PinPad")) {
+			rootInfo["Checkdata"] = m_adapterInfo.strCheckdata.GetData();
+			rootInfo["Keysn"] = m_adapterInfo.strKeysn.GetData();
+		}
+#else
+		CSmartPointer<IConfigInfo> spConfigRoot;
+		this->GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
+		CSimpleStringA sectionName = CSimpleStringA::Format("Device.%s", entityName.GetData());
+		CSimpleStringA csVendor(true), csVersion(true), csBatch(true), csPort(true), csBaudrate(true);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Vendor", csVendor);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Version", csVersion);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Batch", csBatch);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Port", csPort);
+		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Baudrate", csBaudrate);
 
-		std::map<std::string, std::string> rootInfo;
-        CSimpleStringA csPortNum(true), csCheckData(true), csKeySN(true), csInOutDir(true);
+		CSimpleStringA csPortNum(true), csCheckData(true), csKeySN(true), csInOutDir(true);
 		rootInfo["Vendor"] = csVendor;
 		rootInfo["Version"] = csVersion;
-        rootInfo["Batch"] = csBatch;
-        rootInfo["Port"] = csPort;
-        rootInfo["Baudrate"] = csBaudrate;
-
-        if (!entityName.Compare("Gpio")) {
-            spConfigRoot->ReadConfigValue(sectionName.GetData(), "PortNum", csPortNum);
-            spConfigRoot->ReadConfigValue(sectionName.GetData(), "InOutDir", csInOutDir);
-            rootInfo["PortNum"] = csPortNum;
-            rootInfo["InOutDir"] = csInOutDir;
-        } else if (!entityName.Compare("PinPad")) {
-            spConfigRoot->ReadConfigValue(sectionName.GetData(), "Checkdata", csCheckData);
-            spConfigRoot->ReadConfigValue(sectionName.GetData(), "Keysn", csKeySN);
-            rootInfo["Checkdata"] = csCheckData;
-            rootInfo["Keysn"] = csKeySN;
-        }
+		rootInfo["Batch"] = csBatch;
+		rootInfo["Port"] = csPort;
+		rootInfo["Baudrate"] = csBaudrate;
+
+		if (!entityName.Compare("Gpio")) {
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "PortNum", csPortNum);
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "InOutDir", csInOutDir);
+			rootInfo["PortNum"] = csPortNum;
+			rootInfo["InOutDir"] = csInOutDir;
+		} else if (!entityName.Compare("PinPad")) {
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "Checkdata", csCheckData);
+			spConfigRoot->ReadConfigValue(sectionName.GetData(), "Keysn", csKeySN);
+			rootInfo["Checkdata"] = csCheckData;
+			rootInfo["Keysn"] = csKeySN;
+		}
+#endif
 
         std::pair<bool, std::string> strResult;
         strResult = generateJsonStr(rootInfo);
         strResult.second.c_str();
 
         if (!entityName.IsNullOrEmpty()) {
-            LogWarn(Severity_Low, Error_Debug, RootIniCodeMap[entityName], strResult.second.c_str());
+            LogWarn(Severity_Low, Error_Debug, m_RootIniCodeMap[entityName.GetData()], strResult.second.c_str());
         } else {
             DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Entity Name is empty, please check!!!");
         }
         return;
 	}
 
-	void ToLogWarnInfoAboutTerm(FSMBase* pFSM, AdapterInfo adapterInfo)
+	/** upload adapter file's hash value and open param as well as dev category information*/
+	void ToLogWarnInfoAboutTerm()
 	{
-		CSmartPointer<IConfigInfo> spConfigRoot;
-		pFSM->GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
-
-		CSimpleStringA entityName = CSimpleStringA::Format("%s", pFSM->GetEntityBase()->GetEntityName());
-		CSimpleStringA sectionName = CSimpleStringA::Format("Device.%s", entityName.GetData());
-		CSimpleStringA csPort(true), csBaudrate(true);
-		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Port", csPort);
-		spConfigRoot->ReadConfigValue(sectionName.GetData(), "Baudrate", csBaudrate);
-
+		CSimpleStringA entityName(this->GetEntityBase()->GetEntityName());
 		//calculate file hash value
 		std::map<std::string, std::string> termInfo;
 		char* strFileHash = new char[128];
 		ZeroMemory(strFileHash, 128);
 		BYTE fileHash[32];
-		SM3File(const_cast<char*>(adapterInfo.adapterFileName.GetData()), fileHash);
+		SM3File(const_cast<char*>(m_adapterInfo.adapterFilePath.GetData()), fileHash);
 		SP::Module::Util::HexBuf2StrBuf(fileHash, &strFileHash, 32);
 
+#if defined(_MSC_VER)
+		int fileSize = 0;
+		HANDLE hFile;
+		hFile = CreateFile(m_adapterInfo.adapterFilePath.GetData(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+		if (hFile == INVALID_HANDLE_VALUE) {
+			fileSize = 0;
+		} else {
+			fileSize = GetFileSize(hFile, NULL);
+			CloseHandle(hFile);
+		}
+#else
 		//calculate file size
 		struct stat statbuf;
 		ZeroMemory(&statbuf, sizeof(statbuf));
-		stat(adapterInfo.adapterFileName.GetData(), &statbuf);
+		stat(m_adapterInfo.adapterFilePath.GetData(), &statbuf);
 		int fileSize = statbuf.st_size;
+#endif //_MSC_VER
 
 		//necessary elements about adapter
 		CSimpleStringA csPortNum(true), csCheckData(true), csKeySN(true), csInOutDir(true);
-		termInfo["VendorDllName"] = adapterInfo.adapterFileName;
+		termInfo["VendorDllName"] = m_adapterInfo.adapterFilePath.GetData();
 		termInfo["VendorDllFileHash"] = strFileHash;
 		ZeroMemory(strFileHash, 128);
 		termInfo["VendorDllFileSize"] = _itoa(fileSize, strFileHash, 10);
-		termInfo["szModel"] = adapterInfo.devCatInfo.szModel;
-		termInfo["szType"] = adapterInfo.devCatInfo.szType;
-		termInfo["Port"] = csPort;
-		termInfo["Baudrate"] = csBaudrate;
+		termInfo["szModel"] = m_adapterInfo.devCatInfo.szModel;
+		termInfo["szType"] = m_adapterInfo.devCatInfo.szType;
+		termInfo["Port"] = m_adapterInfo.strPort.GetData();
+		termInfo["Baudrate"] = m_adapterInfo.strBaudrate.GetData();
 
 		if (strFileHash != nullptr) {
 			delete[] strFileHash;
@@ -579,24 +685,21 @@ public:
 		}
 
 		if (!entityName.Compare("Gpio")) {
-			spConfigRoot->ReadConfigValue(sectionName.GetData(), "PortNum", csPortNum);
-			spConfigRoot->ReadConfigValue(sectionName.GetData(), "InOutDir", csInOutDir);
-			termInfo["PortNum"] = csPortNum;
-			termInfo["InOutDir"] = csInOutDir;
+			termInfo["PortNum"] = m_adapterInfo.strPortNum.GetData();
+			termInfo["InOutDir"] = m_adapterInfo.strInOutDir.GetData();
 		}
 		else if (!entityName.Compare("PinPad")) {
-			spConfigRoot->ReadConfigValue(sectionName.GetData(), "CheckData", csCheckData);
-			spConfigRoot->ReadConfigValue(sectionName.GetData(), "Keysn", csKeySN);
+			termInfo["CheckData"] = m_adapterInfo.strCheckdata.GetData();
+			termInfo["Keysn"] = m_adapterInfo.strKeysn.GetData();
 		}
+
 		std::pair<bool, std::string> strResult;
 		strResult = generateJsonStr(termInfo);
 		strResult.second.c_str();
 
-		if (!entityName.IsNullOrEmpty())
-		{
-			LogWarn(Severity_Low, Error_Unexpect, WarnCodeMap[entityName], strResult.second.c_str());
-		}
-		else {
+		if (!entityName.IsNullOrEmpty()) {
+			LogWarn(Severity_Low, Error_Unexpect, m_WarnCodeMap[entityName.GetData()], strResult.second.c_str());
+		} else {
 			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Entity Name is empty, please check!!!");
 		}
 		return;
@@ -621,14 +724,46 @@ public:
 		return result;
 	}
 
+	virtual ErrorCodeEnum PreOpenDevice() { return Error_Succeed; }
+	virtual ErrorCodeEnum ToOpenDevice() { return Error_NotImpl; }
+	virtual ErrorCodeEnum PostOpenDevice() { return Error_Succeed; }
+
+	ErrorCodeEnum OpenDevice()
+	{
+		if (m_bOpening) {
+			return Error_Pending;
+		}
+		if (m_bOpened) {
+			return Error_DevAlreadyConnected;
+		}
+		m_bOpening = true;
+		ErrorCodeEnum result = PreOpenDevice();
+		if (IS_SUCCEED(result)) {
+			result = ToOpenDevice();
+			if (IS_SUCCEED(result)) {
+				m_bOpened = true;
+				result = PostOpenDevice();
+			}
+		}
+		m_bOpening = false;
+		return result;
+ 	}
+
+public:
+
+		bool m_bOpened;
+		bool m_bOpening;
+
 protected:
 
 	DevAdptLibHelper<TDevClass> m_hDevHelper;
 	DevEntityErrorCode m_entCode;
 	BOOL m_FirstStart;
-	BOOL m_bOpened;
+	
+	ErrorPackage m_errPkg;
 	CSimpleStringA m_csAlarmMsg;
 	unsigned int m_contiErrTimes;
+	AdapterInfo m_adapterInfo;
 
 	void UpdateEntityIDIfZero()
 	{
@@ -640,8 +775,7 @@ protected:
 	void UpdateEntityID()
 	{
         CEntityStaticInfo esi = { 0 };
-        ErrorCodeEnum ec = this->GetEntityBase()->GetFunction()->GetEntityStaticInfo(
-            this->GetEntityBase()->GetEntityName(), esi);
+        ErrorCodeEnum ec = this->GetEntityBase()->GetFunction()->GetEntityStaticInfo(this->GetEntityBase()->GetEntityName(), esi);
 
         if (ec == Error_Succeed) {
             DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("wEntityDevelopID: 0x%X", esi.wEntityDevelopID);
@@ -711,7 +845,7 @@ protected:
 	}
 
 	void LogErrMsg(const char* pMsgHead, ErrorCodeEnum eErrCode, DWORD defaultDevCode = 0, BOOL bAlarm = FALSE);
-	void LogErrMsgEx(ErrorPackage errPkg, const char* pMsgBody, DWORD finalErrCode /*= 0*/, BOOL bToBusiness = FALSE);
+	void LogErrMsgEx(const ErrorPackage& errPkg, const char* pMsgBody, DWORD finalErrCode /*= 0*/, BOOL bToBusiness = FALSE);
 
     void GetFileSizeAndCalcHashValue(const char* fileName, int& fileSize, BYTE fileHash[32])
     {
@@ -732,6 +866,11 @@ protected:
     }
 
 	int CountDevError(CEntityBase *pEntityBase);
+
+	private:
+
+		std::map<std::string, DWORD> m_WarnCodeMap;
+		std::map<std::string, DWORD> m_RootIniCodeMap;
 };
 
 
@@ -817,7 +956,7 @@ inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsg(
 }
 
 template<class TFSM, class TDevClass>
-inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsgEx(ErrorPackage errPkg, const char* pMsgBody, DWORD finalErrCode /*= 0*/, BOOL bToBusiness)
+inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsgEx(const ErrorPackage& errPkg, const char* pMsgBody, DWORD finalErrCode /*= 0*/, BOOL bToBusiness)
 {
 	const CSimpleStringA alarmMsg = CSimpleStringA::Format("{\"DevSN\":\"%s\", \"Prefix\":\"%s\", \"Code\":\"%s\", \"Msg\":\"%s\"}"
                            , errPkg.devSN.GetData(), errPkg.msgHead.GetData(), SpStrError(errPkg.devErrCode), pMsgBody);
@@ -845,17 +984,18 @@ int CCommDevFSM<TFSM, TDevClass>::CountDevError(CEntityBase* pEntityBase)
 		} else {
 			int value(0);
 			spCenterConfig->ReadConfigValueInt("Common", "ErrUpperLimit", value);
-			if (0 <= value) {
+			if (0 == value) {
 				iErrNumLimit = 5;
+			} else if (0 > value) {
+				iErrNumLimit = 0;
 			} else {
 				iErrNumLimit = value;
 				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("iErrNumLimit=%d", iErrNumLimit);
 			}
 		}
 	}
-
 	m_contiErrTimes++;
-	if (m_contiErrTimes >= iErrNumLimit) {
+	if (iErrNumLimit > 0 && m_contiErrTimes >= iErrNumLimit) {
 		return 1;
 	} else {
 		return 0;

Module/include/EventCode.h

@@ -54,7 +54,8 @@ static const char* Device_Type_Table[] = {
 #define EVENT_CENTERSETTING_NOTIFY_LACK_OF_CENTER_CONFIG 0x10100001
 /*国产化新增结束*/
 /*----SystemCustomization--modify--by--HYC--at--2021/3/2----*/
-#define EVENT_MOD_CENTERSETTING_RVCWEBVER_CHANGE  0x10100012          //检测到RvcWeb版本变更
+#define EVENT_MOD_CENTERSETTING_RVCWEBVER_CHANGE  0x10100011          //检测到RvcWeb版本变更
+#define EVENT_MOD_CENTERSETTING_CRITICAL_UPDATE  0x10100012           //集中配置更新事件
 #define ERR_MOD_CENTERSETTING_CONNECT_FAILED      0x10100013          //获取集中配置失败
 #define EVENT_MOD_CENTERSETTING_CONNECT_SUCC      0x10100014          //获取集中配置成功
 #define ERR_MOD_CENTERSETTING_GRAY_CONNECT_FAILED 0x10100015          //获取灰度控制失败
@@ -69,23 +70,7 @@ static const char* Device_Type_Table[] = {
 #define ERR_MOD_CENTERSETTING_CHANGE_FROM_NONE2HEADBRANCH      0x1010001E //从无切换到总行
 #define ERR_MOD_CENTERSETTING_CHANGE_FROM_NONE2SUBBRANCH      0x1010001F //从无切换到分行
 
-/*----SystemCustomization--modify--by--LZM--at--2020/4/8----*/
-#define LOG_WARN_SYSTEMINITIAL_FAILED                0x10B40001  //系统定制失败
-#define LOG_WARN_UPLOAD_QUERY_PLAN_ERROR 0x10400002 //查询扫描计划http通讯报错
-#define LOG_WARN_UPLOAD_QUERY_FILE_OVER_LIMIT 0x10400003 //扫描文件文件过大告警
-#define LOG_WARN_UPLOAD_FILE_REPORT 0x10400004 //上传文件统计信息告警
-#define LOG_WARN_UPLOAD_QUERY_PLAN_DATA_ERROR 0x10400005 //查询扫描计划数据效验错误
-
-#define LOG_EVT_SYSTMECUSTOM_START_ACCESSAUTH        0x10B00001  //开始准入
-
-#define ERR_SYSTEMCUSTOMIZATION_READ_WRITE_CONFIG    0x10B10001  //读写配置文件错误
-#define ERR_SYSTEMCUSTOMIZATION_LANMAN_SERVICE       0x10B10002  //lanman server操作错误
-#define ERR_SYSTEMCUSTOMIZATION_WUAUSERV_SERVICE     0x10B10003  //wuauserv server操作错误
-#define ERR_SYSTEMCUSTOMIZATION_GET_SMB              0x10B10004  //服务控制器错误
-#define ERR_SYSTEMCUSTOMIZATION_GET_AUTO_UPDATE      0x10B10005  //windows自动更新错误
-#define ERR_SYSTEMCUSTOMIZATION_SYSTEM_CHECK         0x10B10006  //系统自检错误
-#define ERR_SYSTEMCUSTOMIZATION_LOAD_DLL             0x10B10007  //加载DLL错误
-/*----SystemCustomization--modify--by--LZM--at--2020/4/8----*/
+
 
 #define LOG_WARN_UPLOAD_SCANFILE_LOCK_ERROR 0x10400001 //扫描文件时文件独占句柄失败
 

Module/include/ModuleMix.h

@@ -45,7 +45,7 @@ enum UserDefEntityState
 	USER_SURVEILLANCE_EWSERROR,
 	USER_ENTITY_STATE_END
 };
-char *UserDefEntityMsg[USER_ENTITY_STATE_END][1] =
+static char *UserDefEntityMsg[USER_ENTITY_STATE_END][1] =
 {
 	"",
 	"发卡机--空闲",
@@ -85,15 +85,4 @@ char *UserDefEntityMsg[USER_ENTITY_STATE_END][1] =
 	"话机注销"
 };
 
-enum CapTypeEnum
-{
-    CAMTYPE_UNKNOWN = 0,
-    CAMTYPE_ENV,
-    CAMTYPE_OPT,
-    CAMTYPE_EWS,
-    CAMTYPE_HSPS,
-    CAMTYPE_CIRCLE,
-    CAMTYPE_MAX
-};
-
 #endif//__MODULE_MIX_H

Module/mod_HSPScanner/HSPScannerFSM.cpp

@@ -12,7 +12,6 @@
 #include <winpr/sysinfo.h>
 #include "opencv.hpp"
 #else
-#include "ModuleHelper.h"
 #include <opencv2/opencv.hpp>
 #endif //NOT _WIN32
 
@@ -108,9 +107,6 @@ CHSPScannerFSM::CHSPScannerFSM(void)
 	m_csBuadrate(""),
 	m_eDevStatus(DEVICE_STATUS_NOT_READY),
 	m_desiredAction(USER_EVT_QUIT),
-	m_bOpened(false),
-	m_bOpening(false),
-	m_contiErrTimes(0),
 	dwLastUserCode(0),
 	m_dwMaxImageSize(500)
 {
@@ -120,8 +116,6 @@ CHSPScannerFSM::CHSPScannerFSM(void)
 	m_errPkg.devSN = "";
 	m_errPkg.devErrCode = Error_Unexpect;
 	m_errPkg.apiErrCode = Error_Succeed;
-	//todo
-	ZeroMemory(&m_adapterInfo, sizeof(m_adapterInfo));
 }
 
 CHSPScannerFSM::~CHSPScannerFSM(void)
@@ -140,9 +134,9 @@ ErrorCodeEnum CHSPScannerFSM::OnInit()
 	m_csMachineType = sysInfo.strMachineType;
 	m_csDllFullPath.Clear();
 	InitialMaxResizeValue();
-#ifndef _WIN32
-	GET_DEV_ENTITY_BASE_POINTER()->InitializeVendorLogSwitch();
+
 	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
+	pEntity->InitializeVendorLogSwitch();
 	auto result = pEntity->ExtractVendorLibFullPath(m_csDllFullPath);
 	if (result == Error_NotConfig) {
 		PostEventLIFO(new FSMEvent(USER_EVT_NOCFG));
@@ -152,59 +146,17 @@ ErrorCodeEnum CHSPScannerFSM::OnInit()
 		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Fetch Vendor dllName failed %s.", (LPCTSTR)m_csDllFullPath);
 		goto FAIL;
 	}
+	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
 	LogWarn(Severity_Low, Error_Unexpect, HSPScanner_UserErrorCode_ROOT_INFO, (LPCTSTR)m_csDllFullPath);
-	m_adapterInfo.adapterFileName = m_csDllFullPath;
-	m_csDllName = pEntity->GetVendorLibName();
-
-	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, pEntity->vendorLibInfo.strVendor);
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("VendorDllName: %s.", (LPCTSTR)m_csDllFullPath);
-	erroCode = m_hDevHelper.LoadUp(m_csDllFullPath);
-#else
-	VendorLogControler(this, "HSPScanner");
-	erroCode = SpGetDevAdaptorPath(m_pEntity, GetEntityBase()->GetEntityName(), m_csDllFullPath, m_adaptorInfo);
-	/** 该接口会同步改动 m_adaptorInfo 的内容 Gifur@20221213]*/
-	ResetVendorDllName(m_csDllFullPath);
-	LogWarn(Severity_Low, Error_Unexpect, HSPScanner_UserErrorCode_ROOT_INFO, m_csDllFullPath.GetData());
-	CSimpleStringA adaptorInfo = GenerateJson(m_adaptorInfo, m_pEntity->GetEntityName());
-	LogWarn(Severity_Low, Error_Unexpect, HSPScanner_UserErrorCode_REAL_ROOT_CONFIG, adaptorInfo.GetData());
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("VendorDllName: %s.", (LPCTSTR)m_adapterInfo.adapterFileName);
+	ToLogRootINIInfoOnce();
+	erroCode = m_hDevHelper.LoadUp(m_adapterInfo.adapterFilePath);
 
-	CSmartPointer<IConfigInfo> spConfig;
-	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
-	spEntityFunction->OpenConfig(Config_Root, spConfig);
-	spConfig->ReadConfigValue("Device.HSPScanner", "Port", m_csPort);
-	spConfig->ReadConfigValue("Device.HSPScanner", "Baudrate", m_csBuadrate);
-	const int index = m_csDllFullPath.IndexOf(GetEntityBase()->GetEntityName());
-	if (index != -1) {
-		m_csDllName = (LPCTSTR)&m_csDllFullPath[index];
-		if (m_csDllName.IsEndWith(".dll"), true) {
-			m_csDllName = m_csDllName.SubString(0, m_csDllName.GetLength() - strlen(".dll"));
-		}
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_csDllName:%s", m_csDllName.GetData());
-	}
 
-	if (FAILURED(erroCode)) {
-		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("Fetch Vendor dllName failed %s.", (LPCTSTR)m_csDllFullPath);
-		SetLastUserCode(HSPScanner_UserErrorCode_DLLNAME_FAILED);
-		m_csDllFullPath.Clear();
-		goto FAIL;
-	}
-	VendorLogResetDllName(m_csDllFullPath);
-	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("VendorDllName: %s.", (LPCTSTR)m_csDllFullPath);
-	erroCode = LoadDllAndGetAddress((const char*)m_csDllFullPath);
-	if (FAILURED(erroCode)) {
-		if (!IsDevFurnished()) {
-			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("%s - GLE=%u", (LPCTSTR)m_csDllName, GetLastError());
-			PostEventLIFO(new FSMEvent(USER_EVT_NOCFG));
-			return Error_Succeed;
-		}
-		SetLastUserCode(HSPScanner_UserErrorCode_LOAD_DLLFILE_FAILED);
-		goto FAIL;
-	}
-#endif //NOT _WIN32
-
-	if (result == Error_Succeed) {
+	if (erroCode == Error_Succeed) {
 		if (Error_Succeed == (erroCode = TryToOpenDevice())) {
 			m_eDevStatus = DEVICE_STATUS_NORMAL;
+			ToLogWarnInfoAboutTerm();
 			return erroCode;
 		}
 	}
@@ -217,28 +169,11 @@ FAIL:
 
 ErrorCodeEnum CHSPScannerFSM::OnExit()
 {
-#ifndef _WIN32
 	if (m_hDevHelper) {
 		ErrorCodeEnum errCode = Error_Succeed;
 		m_hDevHelper.TearDown();
 		return errCode;
 	}
-#else
-	if (m_pHSPS) {
-		ErrorCodeEnum erroCode(Error_Succeed);
-		if (m_bOpened) {
-			erroCode = m_pHSPS->DevClose();
-			if (Error_Succeed != erroCode) {
-				SetErrPackage(m_errPkg, "OnExit::DevClose", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_DevClose);
-				AlarmDEC(m_errPkg);
-			}
-			LOG_TRACE("Invoke 'DevClose' returned %d(0x%x).", erroCode, erroCode);
-		}
-		erroCode = ReleaseDevComponent((DeviceBaseClass*&)m_pHSPS);
-		LOG_TRACE("Invoke 'ReleaseDevComponent' returned %d(0x%x).", erroCode, erroCode);
-		m_pHSPS = NULL;
-}
-#endif //NOT _WIN32
 	return Error_Succeed;
 }
 
@@ -247,14 +182,6 @@ void CHSPScannerFSM::s0_on_entry()
 	m_bOperating = FALSE;
 	m_nFatalTimes = 0;
 	m_ecSelfTest = Error_Succeed;
-
-#ifndef _WIN32
-	if (m_FirstStart) {
-		m_FirstStart = FALSE;
-		ToLogRootINIInfoOnce(this);
-		ToLogWarnInfoAboutTerm(this, m_adapterInfo);
-	}
-#endif //NOT _WIN32
 }
 
 void CHSPScannerFSM::s0_on_exit()
@@ -626,8 +553,8 @@ unsigned int CHSPScannerFSM::s3_on_event(FSMEvent* e)
 					if (ISSUCCEEDED(erroCode)) {
 						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview)("Hide Preview Dialog");
 					} else {
-						SetErrPackage(m_errPkg, "Hide Preview", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-						SetLastUserCode(AlarmDEC(m_errPkg));
+						SetErrPackage("Hide Preview", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+						SetLastUserCode(AlarmDEC());
 						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("Hide Preview Dialog failed: 0x%X", erroCode);
 					}
 					pEvt->m_ctx->Answer(TransECWithRepeat(erroCode));
@@ -667,15 +594,15 @@ unsigned int CHSPScannerFSM::s3_on_event(FSMEvent* e)
 		if (m_bOpened) {
 			ErrorCodeEnum erroCode = m_hDevHelper->Reset();
 			if (FAILURED(erroCode)) {
-				SetErrPackage(m_errPkg, "s3_on_event::Reset", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_Reset);
-				AlarmDEC(m_errPkg);
+				SetErrPackage("s3_on_event::Reset", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_Reset);
+				AlarmDEC();
 				m_ecSelfTest = Error_InvalidState;
 				uRet = 1;
 			} else {
 				ErrorCodeEnum eXYW = m_hDevHelper->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
 				if (FAILURED(eXYW)) {
-					SetErrPackage(m_errPkg, "s3_on_event::SetViewPos", m_csDevNo, eXYW, MEC_DEVAPI_HSPSCANNER_SetViewPos);
-					AlarmDEC(m_errPkg);
+					SetErrPackage("s3_on_event::SetViewPos", m_csDevNo, eXYW, MEC_DEVAPI_HSPSCANNER_SetViewPos);
+					AlarmDEC();
 					uRet = 1;
 					m_ecSelfTest = Error_InvalidState;
 					e->SetHandled();
@@ -702,8 +629,8 @@ unsigned int CHSPScannerFSM::s3_on_event(FSMEvent* e)
 					}
 					if (FAILURED(erroCode)) {
 						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Recover failed under desiration of %s", EvtTypeToString(m_desiredAction));
-						SetErrPackage(m_errPkg, "s3_on_event::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-						AlarmDEC(m_errPkg);
+						SetErrPackage("s3_on_event::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+						AlarmDEC();
 						uRet = 1;
 						m_ecSelfTest = Error_InvalidState;
 						e->SetHandled();
@@ -1190,8 +1117,8 @@ int CHSPScannerFSM::StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_
 		if (ISSUCCEEDED(erroCode)) {
 			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview)("Show Preview Dialog succ");
 		} else {
-			SetErrPackage(m_errPkg, "StartPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-			SetLastUserCode(AlarmDEC(m_errPkg));
+			SetErrPackage("StartPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+			SetLastUserCode(AlarmDEC());
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("Show Preview Dialog failed: 0x%X", erroCode);
 		}
 	} else if (ISSUCCEEDED(erroCode)) {
@@ -1204,15 +1131,15 @@ int CHSPScannerFSM::StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_
 			("End to SetPreview(1) returned %d(0x%x).", erroCode, erroCode);
 
 		if (FAILURED(erroCode)) {
-			SetErrPackage(m_errPkg, "StartPreview::SetPreview(1)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Open);
-			SetLastUserCode(AlarmDEC(m_errPkg, true));
+			SetErrPackage("StartPreview::SetPreview(1)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Open);
+			SetLastUserCode(AlarmDEC(true));
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("StartPreview failed: 0x%X", erroCode);
 		} else {
 			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview)("StartPreview succ");
 		}
 	} else {
-		SetErrPackage(m_errPkg, "StartPreview::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
-		SetLastUserCode(AlarmDEC(m_errPkg, true));
+		SetErrPackage("StartPreview::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
+		SetLastUserCode(AlarmDEC(true));
 		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_StartPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("GetDevStatus failed: 0x%X", erroCode);
 	}
 
@@ -1236,8 +1163,8 @@ int CHSPScannerFSM::StopPreview(SpReqAnsContext<HSPScannerService_CancelPreview_
 			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview)("Hide Preview Dialog succ");
 			nRes = 1;
 		} else {
-			SetErrPackage(m_errPkg, "StopPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-			SetLastUserCode(AlarmDEC(m_errPkg));
+			SetErrPackage("StopPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+			SetLastUserCode(AlarmDEC());
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("Hide Preview Dialog failed: 0x%X", erroCode);
 			nRes = 4;
 		}
@@ -1253,8 +1180,8 @@ int CHSPScannerFSM::StopPreview(SpReqAnsContext<HSPScannerService_CancelPreview_
 			nRes = 2;
 			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview)("SetPreview(0) succ");
 		} else {
-			SetErrPackage(m_errPkg, "StopPreview::SetPreview(0)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close);
-			SetLastUserCode(AlarmDEC(m_errPkg, true));
+			SetErrPackage("StopPreview::SetPreview(0)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close);
+			SetLastUserCode(AlarmDEC(true));
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_CancelPreview).setResultCode(MapCode2RTAString(GetLastUserCode()))("SetPreview(0) failed: 0x%X", erroCode);
 		}
 	}
@@ -1439,11 +1366,11 @@ int CHSPScannerFSM::ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req,
 	}
 	else
 	{
-		SetErrPackage(m_errPkg, "ScanImage::ScanImage", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_ScanImage);
+		SetErrPackage("ScanImage::ScanImage", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_ScanImage);
 #ifdef BUSINESS_FAULT_SWITCH_OFF
-		SetLastUserCode(AlarmDEC(m_errPkg, false));
+		SetLastUserCode(AlarmDEC(false));
 #else
-		SetLastUserCode(AlarmDEC(m_errPkg, true));
+		SetLastUserCode(AlarmDEC(true));
 #endif // BUSINESS_FAULT_SWITCH_OFF
 		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImage).setResultCode(MapCode2RTAString(GetLastUserCode()))("ScanImage failed returned 0x%X", erroCode);
 		ctx->Answer(TransECWithRepeat(erroCode), GetLastUserCode());
@@ -1570,11 +1497,11 @@ int CHSPScannerFSM::ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Re
 	else
 	{
 		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER)("ScanImageEx failed returned %s, %d, %d.", SpStrError(erroCode), len, strlen((const char*)pBtImage));
-		SetErrPackage(m_errPkg, "ScanImageEx::ScanImageEx", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_ScanImageEx);
+		SetErrPackage("ScanImageEx::ScanImageEx", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_ScanImageEx);
 #ifdef BUSINESS_FAULT_SWITCH_OFF
-		SetLastUserCode(AlarmDEC(m_errPkg, false));
+		SetLastUserCode(AlarmDEC(false));
 #else
-		SetLastUserCode(AlarmDEC(m_errPkg, true));
+		SetLastUserCode(AlarmDEC(true));
 #endif // BUSINESS_FAULT_SWITCH_OFF
 		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_ScanImageEx).setResultCode(MapCode2RTAString(GetLastUserCode()))("ScanImageEx failed returned 0x%x, %d, %d.", erroCode, len, strlen((const char*)pBtImage));
 		ctx->Answer(TransECWithRepeat(erroCode), GetLastUserCode());
@@ -1631,8 +1558,8 @@ int CHSPScannerFSM::SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Re
 	{
 		retCode |= 0x0001;
 		//GetAndDbgDevError();
-		SetErrPackage(m_errPkg, "SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 	//////////////////////////////////////////////////////////////////////////
@@ -1659,8 +1586,8 @@ int CHSPScannerFSM::SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Re
 	if(FAILURED(erroCode)) 
 	{
 		retCode |= 0x0002;
-		SetErrPackage(m_errPkg, "SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 	//////////////////////////////////////////////////////////////////////////
@@ -1682,8 +1609,8 @@ int CHSPScannerFSM::SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Re
 	if(FAILURED(erroCode)) 
 	{
 		retCode |= 0x0004;
-		SetErrPackage(m_errPkg, "SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetProperty::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 
@@ -1727,8 +1654,8 @@ int CHSPScannerFSM::SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req,
 		erroCode = m_hDevHelper->SetViewPos(ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth);
 		if(FAILURED(erroCode))
 		{
-			SetErrPackage(m_errPkg, "SetWinPos::SetViewPos", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetViewPos);
-			SetLastUserCode(AlarmDEC(m_errPkg));
+			SetErrPackage("SetWinPos::SetViewPos", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetViewPos);
+			SetLastUserCode(AlarmDEC());
 			nRes = 2;
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetWinPos).setResultCode(MapCode2RTAString(GetLastUserCode()))("SetViewPos failed: 0x%X", erroCode);
 		}
@@ -1744,8 +1671,8 @@ int CHSPScannerFSM::SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req,
 		erroCode = m_hDevHelper->SetParam(HSPS_MODEL_VIEW, value);
 		if(FAILURED(erroCode))
 		{
-			SetErrPackage(m_errPkg, "SetWinPos::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-			SetLastUserCode(AlarmDEC(m_errPkg));
+			SetErrPackage("SetWinPos::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+			SetLastUserCode(AlarmDEC());
 			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(HSPScannerService_LogCode_SetWinPos).setResultCode(MapCode2RTAString(GetLastUserCode()))("SetParam failed: 0x%X", erroCode);
 			nRes = 1;
 		}
@@ -1772,8 +1699,8 @@ int CHSPScannerFSM::GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_
 	}
 	else
 	{
-		SetErrPackage(m_errPkg, "GetDevStatus::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("GetDevStatus::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
+		SetLastUserCode(AlarmDEC());
 		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_GetDevStatus).setResultCode(MapCode2RTAString(GetLastUserCode()))("GetDevStatus failed: 0x%X", erroCode);
 		nRes = 1;
 	}
@@ -1799,8 +1726,8 @@ int CHSPScannerFSM::GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
 	}
 	else
 	{
-		SetErrPackage(m_errPkg, "GetDevInfo::GetDevCategory", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevCategory);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("GetDevInfo::GetDevCategory", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevCategory);
+		SetLastUserCode(AlarmDEC());
 		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(HSPScannerService_LogCode_GetDevInfo).setResultCode(MapCode2RTAString(GetLastUserCode()))("GetDevInfo failed: 0x%X", erroCode);
 		nRes = 1;
 	}
@@ -1811,43 +1738,6 @@ int CHSPScannerFSM::GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
 	return nRes;
 }
 
-#if defined(_MSC_VER)
-
-
-ErrorCodeEnum CHSPScannerFSM::LoadDllAndGetAddress(const char* szDllName)
-{
-	ErrorCodeEnum erroCode = Error_Unexpect;
-	SAFE_FREE_LIBRARY(m_hVendorDll);
-	m_hVendorDll = LoadLibraryA(szDllName);
-	if (m_hVendorDll == NULL) {
-		const DWORD tmpError = GetLastError();
-		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("LoadLibraryA[%s] failed with error %u.", szDllName, tmpError);
-		if (tmpError == 126) {
-			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("该问题是缺失某个DLL导致的错误。");
-		}
-		LogWarn(Severity_High, Error_DevLoadFileFailed, HSPScanner_UserErrorCode_LOAD_DLLFILE_FAILED, CSimpleStringA::Format("load library failed! %u", tmpError));
-		return Error_DevLoadFileFailed;
-	}
-	if ((CreateDevComponent = (LpCreateDevCom)GetProcAddress(m_hVendorDll,
-		"CreateDevComponent")) == NULL) {
-		LogWarn(Severity_High, Error_DevLoadFileFailed, HSPScanner_UserErrorCode_GET_CDC_ADDR_FAILED,
-			CSimpleStringA::Format("Get 'CreateDevComponent' Func address failed with code %d", GetLastError()));
-		return Error_DevLoadFileFailed;
-	}
-	if ((ReleaseDevComponent = (LpReleaseDevCom)GetProcAddress(m_hVendorDll,
-		"ReleaseDevComponent")) == NULL) {
-		LogWarn(Severity_High, Error_DevLoadFileFailed, HSPScanner_UserErrorCode_GET_RDC_ADDR_FAILED,
-			CSimpleStringA::Format("Get 'ReleaseDevComponent' Func address failed with code %d", GetLastError()));
-		return Error_DevLoadFileFailed;
-	}
-
-	SetCustLastErrorCode();
-	return Error_Succeed;
-
-}
-
-#endif //_MSC_VER
-
 BOOL CHSPScannerFSM::GetCurImageName(CSimpleStringA& csImagName, bool bExt /*= false*/)
 {
     if (bExt) {
@@ -1940,13 +1830,13 @@ ErrorCodeEnum CHSPScannerFSM::OnDevExit()
 				if(ISSUCCEEDED(erroCode)) {
 					LogEvent(Severity_Middle, LOG_EVT_HSPS_LIGHT_OFF, "HSPScanner warning off.");
 				} else {
-					SetErrPackage(m_errPkg, "OnDevExit::SetPreview(0)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close);
-					AlarmDEC(m_errPkg);
+					SetErrPackage("OnDevExit::SetPreview(0)", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetPreview_Close);
+					AlarmDEC();
 				}
 			}
 		} else if (!FAILURED(erroCode)) {
-			SetErrPackage(m_errPkg, "OnDevExit::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
-			AlarmDEC(m_errPkg);
+			SetErrPackage("OnDevExit::GetDevStatus", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevStatus);
+			AlarmDEC();
 		} else {
 			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("HSPSCanner device is disconnected!");
 		}
@@ -1961,73 +1851,6 @@ ErrorCodeEnum CHSPScannerFSM::OnDevExit()
 	return erroCode;
 }
 
-#if defined(_MSC_VER)
-void CHSPScannerFSM::UploadVendorDllInfo()
-{
-	LOG_FUNCTION();
-
-	std::map<std::string, std::string> termInfo;
-	BYTE fileHash[32];
-	int fileSize = 0;
-	GetFileSizeAndCalcHashValue(m_csDllFullPath, fileSize, fileHash);
-
-	char* strFileHash = new char[128];
-	memset(strFileHash, 0, 128);
-	HexBuf2StrBuf(fileHash, &strFileHash, 32);
-	termInfo["VendorDllName"] = m_csDllFullPath.GetData();
-	termInfo["VendorDllFileHash"] = strFileHash;
-	memset(strFileHash, 0, 128);
-	termInfo["VendorDllFileSize"] = _itoa(fileSize, strFileHash, 10);
-
-	if (strlen(m_devCat.szModel) > 1 && strlen(m_devCat.szModel) < 255)
-		termInfo["szModel"] = m_devCat.szModel;
-	if (strlen(m_devCat.szType) > 1 && strlen(m_devCat.szType) < 255)
-		termInfo["szType"] = m_devCat.szType;
-	termInfo["Port"] = m_csPort;
-	termInfo["Baudrate"] = m_csBuadrate;
-
-	std::pair<bool, std::string> strResult;
-	strResult = generateJsonStr(termInfo);
-
-	CSmartPointer<IConfigInfo> spConfigRun;
-	CSimpleStringA csWarnMsg("");
-	int wDay = 99;
-	GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
-	SYSTEMTIME localTime;
-	GetLocalTime(&localTime);
-	spConfigRun->ReadConfigValueInt("DllInfo", "WarnDay", wDay);
-	spConfigRun->ReadConfigValue("DllInfo", "WarnMsg", csWarnMsg);
-	if ((strResult.first && !strResult.second.empty())
-		&&
-		(csWarnMsg.IsNullOrEmpty() || csWarnMsg.Compare(strResult.second.c_str()) || wDay != localTime.wDay)) {
-		LogWarn(Severity_Low, Error_Unexpect, HSPScanner_UserErrorCode_UPLOAD_VENDORINFO, strResult.second.c_str());
-		spConfigRun->WriteConfigValueInt("DllInfo", "WarnDay", localTime.wDay);
-		spConfigRun->WriteConfigValue("DllInfo", "WarnMsg", strResult.second.c_str());
-	} else {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("not need to upload: %s", strFileHash);
-	}
-	if (strFileHash != NULL)
-		delete[] strFileHash;
-	return;
-}
-#endif //_MSC_VER
-
-UINT CHSPScannerFSM::UnitTest(LPCTSTR testTag)
-{
-#ifdef TWINKLE_LOCAL_DEBUG
-	LOG_FUNCTION();
-	do
-	{
-		UploadVendorDllInfo();
-
-	}while(false);
-
-#endif //TWINKLE_LOCAL_DEBUG
-
-	return 0;
-}
-
-
 LPCTSTR CHSPScannerFSM::MapCode2RTAString(DWORD dwValue)
 {
 	switch (dwValue) {
@@ -2102,52 +1925,6 @@ LPCTSTR CHSPScannerFSM::MapCode2RTAString(DWORD dwValue)
 	return "SUC0000";
 }
 
-#if defined(_MSC_VER)
-BOOL CHSPScannerFSM::ResetVendorDllName(CSimpleStringA& newDllName)
-{
-	if (newDllName.IsEndWith("keba.7.1.dll", true) || newDllName.IsEndWith("keba.1.1.dll")) {
-		CSimpleStringA strExistDriver(true);
-		BOOL isNewOne(FALSE);
-		if (ExistsFileA("C:\\Program Files (x86)\\eloamDll_2.4\\bin\\eloamDll.dll")) {
-			strExistDriver = "C:\\Program Files (x86)\\eloamDll_2.4\\bin\\eloamDll.dll";
-			isNewOne = TRUE;
-		} else if (ExistsFileA("C:\\Program Files\\eloamDll_2.4\\bin\\eloamDll.dll")) {
-			strExistDriver = "C:\\Program Files\\eloamDll_2.4\\bin\\eloamDll.dll";
-			isNewOne = TRUE;
-		} else if (ExistsFileA("C:\\Program Files (x86)\\eloamDll_2.3\\bin\\eloamDll.dll")) {
-			strExistDriver = "C:\\Program Files (x86)\\eloamDll_2.3\\bin\\eloamDll.dll";
-		} else if (ExistsFileA("C:\\Program Files\\eloamDll_2.3\\bin\\eloamDll.dll")) {
-			strExistDriver = "C:\\Program Files\\eloamDll_2.3\\bin\\eloamDll.dll";
-		}
-
-		if (!strExistDriver.IsNullOrEmpty()) {
-			CSmartPointer<IConfigInfo> spConfig;
-			CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
-			spEntityFunction->OpenConfig(Config_CenterSetting, spConfig);
-			CSimpleStringA strDepDirPath(true);
-			spEntityFunction->GetPath("Dep", strDepDirPath);
-			strDepDirPath += "\\";
-			strDepDirPath += "HSPScanner.keba.7.2.dll";
-			if (ExistsFileA(strDepDirPath)) {
-				int value(0);
-				spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "KebaAdapterSwitch", value);
-				if (value == 0) {
-					LogWarn(Severity_Low, Error_Debug, LOG_WARN_HSPS_VENDORDLL_KEBA_MATCHED, strExistDriver);
-					return FALSE;
-				} else {
-					LogWarn(Severity_Low, Error_Debug, LOG_WARN_HSPS_VENDORDLL_CHANGE, strDepDirPath);
-					newDllName = strDepDirPath;
-					m_adaptorInfo.strVersion = "7";
-					m_adaptorInfo.strBatch = "2";
-					return TRUE;
-				}
-			}
-		}
-	}
-	return FALSE;
-}
-#endif //_MSC_VER
-
 void CHSPScannerFSM::SelfTest(EntityTestEnum eTestType,
 	CSmartPointer<ITransactionContext> pTransactionContext)
 {
@@ -2189,6 +1966,7 @@ void CHSPScannerFSM::OnStateTrans(int iSrcState, int iDstState)
 ErrorCodeEnum CHSPScannerFSM::SetPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
 	HSPScannerService_StartPreview_Ans>::Pointer ctx)
 {
+	int nRes = 0;
 	ErrorCodeEnum erroCode = Error_Succeed;
 	int retCode = 0;
 	//////////////////////////////////////////////////////////////////////////
@@ -2205,8 +1983,8 @@ ErrorCodeEnum CHSPScannerFSM::SetPreview(SpReqAnsContext<HSPScannerService_Start
 	if(FAILURED(erroCode)) 
 	{
 		retCode |= 0x0001;
-		SetErrPackage(m_errPkg, "SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 	//////////////////////////////////////////////////////////////////////////
@@ -2233,8 +2011,8 @@ ErrorCodeEnum CHSPScannerFSM::SetPreview(SpReqAnsContext<HSPScannerService_Start
 	if(FAILURED(erroCode)) 
 	{
 		retCode |= 0x0002;
-		SetErrPackage(m_errPkg, "SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 	//////////////////////////////////////////////////////////////////////////
@@ -2256,8 +2034,8 @@ ErrorCodeEnum CHSPScannerFSM::SetPreview(SpReqAnsContext<HSPScannerService_Start
 	if(FAILURED(erroCode)) 
 	{
 		retCode |= 0x0004;
-		SetErrPackage(m_errPkg, "SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
-		SetLastUserCode(AlarmDEC(m_errPkg));
+		SetErrPackage("SetPreview::SetParam", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_SetParam);
+		SetLastUserCode(AlarmDEC());
 		erroCode = Error_Succeed;
 	}
 
@@ -2324,32 +2102,21 @@ void CHSPScannerFSM::InitialMaxResizeValue()
 
 ErrorCodeEnum CHSPScannerFSM::TryToOpenDevice()
 {
-
-#ifndef _WIN32
 	ErrorCodeEnum result(Error_Succeed);
 	m_bOpening = true;
-
 	result = m_hDevHelper->DevOpen();
 	if (FAILURED(result)) {
-		SetErrPackage(m_errPkg, "OnInit::DevOpen", m_csDevNo, result, MEC_DEVAPI_HSPSCANNER_DevOpen);
-		AlarmDEC(m_errPkg);
+		SetErrPackage("OnInit::DevOpen", m_csDevNo, result, MEC_DEVAPI_HSPSCANNER_DevOpen);
+		AlarmDEC();
 		SetLastUserCode(LOG_ERR_HSPS_DEVOPEN_FAILED);
 	} else {
 		SetLastUserCode();
 		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Open HSPS succ");
-		ZeroMemory(m_devCat.szModel, sizeof(m_devCat.szModel));
-		ZeroMemory(m_devCat.szType, sizeof(m_devCat.szType));
-		ZeroMemory(m_devCat.szVendor, sizeof(m_devCat.szVendor));
-		result = m_hDevHelper->GetDevCategory(m_devCat);
-		if (result == Error_Succeed) {
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szVendor:%s,szType:%s,szModel:%s,version:%d.%d.%d.%d", m_devCat.szVendor
-				, m_devCat.szType, m_devCat.szModel, m_devCat.version.wMajor, m_devCat.version.wMinor, m_devCat.version.wRevision, m_devCat.version.wBuild);
-			m_adapterInfo.FulfillCategoryInfo(m_devCat);
-		} else {
-			SetErrPackage(m_errPkg, "OnInit::GetDevCategory", m_csDevNo, result, MEC_DEVAPI_HSPSCANNER_GetDevCategory);
-			AlarmDEC(m_errPkg);
+		result = FulfillAdapterDevCategory();
+		if (result != Error_Succeed) {
+			SetErrPackage("OnInit::GetDevCategory", m_csDevNo, result, MEC_DEVAPI_HSPSCANNER_GetDevCategory);
+			AlarmDEC();
 		}
-
 		m_bOpened = true;
 		{
 			m_nRecX = 1280;
@@ -2366,98 +2133,4 @@ ErrorCodeEnum CHSPScannerFSM::TryToOpenDevice()
 
 	m_bOpening = false;
 	return result;
-#else
-
-	ErrorCodeEnum erroCode(Error_Succeed);
-
-	m_bOpening = true;
-
-	bool bOpenFlag = false;
-	bool bCreateDevCom = false;
-	int initCount = 0;
-	const int initCountMax = 1;
-	int MilliSleepSec = 1000;
-
-	if (m_hVendorDll == NULL) {
-		erroCode = LoadDllAndGetAddress(m_csDllFullPath);
-		if (FAILURED(erroCode)) {
-			goto FINISHED;
-		}
-	}
-
-	do {
-		if (!bCreateDevCom) {
-			if (CreateDevComponent((DeviceBaseClass*&)m_pHSPS) != Error_Succeed) {
-				LogWarn(Severity_High, Error_NotInit, HSPScanner_UserErrorCode_CREATE_OBJECT_FAILED, "Create HSPScanner module failed.");
-				initCount++;
-				m_pHSPS = NULL;
-				if (initCount > initCountMax) {
-					SAFE_FREE_LIBRARY(m_hVendorDll);
-					SetLastUserCode(HSPScanner_UserErrorCode_CREATE_OBJECT_FAILED);
-					erroCode = Error_DevLoadFileFailed;
-					goto FINISHED;
-				}
-				Sleep(100);
-				continue;
-			}
-			bCreateDevCom = true;
-		}
-
-		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("To Open HSPS...");
-		erroCode = m_pHSPS->DevOpen();
-		if (FAILURED(erroCode)) {
-			initCount++;
-			if (initCount < initCountMax) {
-				Sleep(200);
-				continue;
-			}
-			SetErrPackage(m_errPkg, "TryToOpenDevice::DevOpen", CSimpleStringA::Format("%d", initCount), erroCode, MEC_DEVAPI_HSPSCANNER_DevOpen);
-			SetLastUserCode(AlarmDEC(m_errPkg));
-			SetLastUserCode(LOG_ERR_HSPS_DEVOPEN_FAILED);
-			if (bCreateDevCom && ReleaseDevComponent != NULL && m_pHSPS != NULL) {
-				ReleaseDevComponent((DeviceBaseClass*&)m_pHSPS);
-				m_pHSPS = NULL;
-			} else if (m_pHSPS != NULL) {
-				m_pHSPS = NULL;
-			}
-			SAFE_FREE_LIBRARY(m_hVendorDll);
-			erroCode = Error_DevConnFailed;
-			goto FINISHED;
-		}
-
-		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Open HSPS succ");
-		ZeroMemory(m_devCat.szModel, sizeof(m_devCat.szModel));
-		ZeroMemory(m_devCat.szType, sizeof(m_devCat.szType));
-		ZeroMemory(m_devCat.szVendor, sizeof(m_devCat.szVendor));
-		erroCode = m_pHSPS->GetDevCategory(m_devCat);
-		if (erroCode == Error_Succeed) {
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szVendor:%s,szType:%s,szModel:%s,version:%d.%d.%d.%d", m_devCat.szVendor
-				, m_devCat.szType, m_devCat.szModel, m_devCat.version.wMajor, m_devCat.version.wMinor, m_devCat.version.wRevision, m_devCat.version.wBuild);
-		} else {
-			SetErrPackage(m_errPkg, "TryToOpenDevice::GetDevCategory", m_csDevNo, erroCode, MEC_DEVAPI_HSPSCANNER_GetDevCategory);
-			AlarmDEC(m_errPkg);
-		}
-		m_bOpened = true;
-		bOpenFlag = true;
-
-	} while (!bOpenFlag);
-
-	if (ISSUCCEEDED(erroCode)) {
-		m_nRecX = 1280;
-		m_nRecY = 0;
-		m_nRecW = 1920;
-		ErrorCodeEnum ecInit = m_pHSPS->SetViewPos(m_nRecX, m_nRecY, m_nRecW);
-		ErrorCodeEnum ecInitScan = m_pHSPS->SetParam(HSPS_MODEL_SCANSIZE, HSPS_SCAN_FULL);
-		ErrorCodeEnum ecInitRotate = m_pHSPS->SetParam(HSPS_MODEL_ROTATE, HSPS_ROTATE_NOANGLE);
-		ErrorCodeEnum ecInitColor = m_pHSPS->SetParam(HSPS_MODEL_COLOR, HSPS_COLOR_FULL);
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ViewPos: %d, Scan: %d, rotate: %d, color: %d.",
-			ecInit, ecInitScan, ecInitRotate, ecInitColor);
-	}
-
-FINISHED:
-
-	m_bOpening = false;
-	return erroCode;
-#endif //NOT _WIN32
-
 }

Module/mod_HSPScanner/HSPScannerFSM.h

@@ -8,13 +8,13 @@
 #include "HSPScanner_server_g.h"
 #include "DevFSMCommBase.hpp"
 #include "HSPSCanner_UserErrorCode.h"
-#include "DevErrorCode.h"
 
 #if defined(_MSC_VER)
-#include "DevCommData.h"
 #include "json.h"
 #include <xstring>
 using namespace std;
+#else
+#include "DevErrorCode.h"
 #endif //_MSC_VER
 
 using namespace HSPScanner;
@@ -391,15 +391,6 @@ public:
 
 	ErrorCodeEnum OnDevExit();
 
-#if defined(_MSC_VER)
-	void UploadVendorDllInfo();
-#endif //_MSC_VER
-
-	UINT UnitTest(LPCTSTR testTag);
-
-	bool m_bOpened;
-	bool m_bOpening;
-
 	void SetLastUserCode(DWORD dwCode = 0) 
 	{ 
 		dwLastUserCode = dwCode; 
@@ -410,22 +401,9 @@ public:
 	}
 	LPCTSTR MapCode2RTAString(DWORD dwValue = 0);
 
-#if defined(_MSC_VER)
-	BOOL ResetVendorDllName(CSimpleStringA& newDllName);
-#endif //_MSC_VER
-
-
 private:
 	int m_version, m_batch;
 
-#if defined(_MSC_VER)
-	HMODULE m_hVendorDll;
-	LpCreateDevCom CreateDevComponent;
-	LpReleaseDevCom ReleaseDevComponent;
-
-	CHSPSClass* m_pHSPS;
-#endif //_MSC_VER
-
 	ErrorCodeEnum m_ecSelfTest;
 	DWORD m_dwErroCode;
 	BOOL m_bOperating;
@@ -444,55 +422,15 @@ private:
 	EvtType m_desiredAction;
 	CSimpleStringA m_csMachineType;
 	DevCategoryInfo m_devCat;
-	
-
-#if defined(_MSC_VER)
-	HardwareEntityCode m_entCode;
-#endif //_MSC_VER
-	ErrorPackage m_errPkg;
-	CSimpleStringA m_csAlarmMsg;
 
-	int m_contiErrTimes;
 	DWORD dwLastUserCode;
-
-#ifndef _WIN32
-	AdapterInfo m_adapterInfo;
-#else
-	AdaptorInfo m_adaptorInfo;
-#endif //NOT _WIN32
 	DWORD m_dwMaxImageSize;
 
 public:
 
-#if defined(_MSC_VER)
-	ErrorCodeEnum LoadDllAndGetAddress(const char* szDllName);
-#endif //_MSC_VER
-
 	DWORD GetCustLastErrorCode() { return m_dwErroCode; }
 	void SetCustLastErrorCode(DWORD dwVal = 0) { m_dwErroCode = dwVal; }
 
-	bool IsDevFurnished() 
-	{
-#ifdef RVC_OS_WIN
-		CSimpleStringA strDllName = GET_DEV_ENTITY_BASE_POINTER()->GetVendorLibName();
-		if(strDllName.IsNullOrEmpty())
-			return false;
-		size_t len = strlen(GetEntityBase()->GetEntityName());
-		if(strDllName.GetLength() <= len)
-			return false;
-		LPCTSTR lpszSuffix = (LPCTSTR)strDllName[len];
-		return !!strnicmp(lpszSuffix, ".so", strlen(".so"));
-#else
-		if (m_csDllName.IsNullOrEmpty() || m_csDllName.GetLength() == 0)
-			return false;
-		size_t len = strlen(GetEntityBase()->GetEntityName());
-		if (m_csDllName.GetLength() <= len)
-			return false;
-		LPCTSTR lpszSuffix = (LPCTSTR)m_csDllName[len];
-		return !!strnicmp(lpszSuffix, ".dll", strlen(".dll"));
-#endif // RVC_OS_WIN
-	}
-
 	ErrorCodeEnum TryToOpenDevice();
 
 private:
@@ -516,28 +454,6 @@ private:
 		}
 		return -1;
 	}
-
-#if defined(_MSC_VER)
-
-	void ResetRepeatErrTimes()
-	{
-		m_contiErrTimes = 0;
-	}
-
-	ErrorCodeEnum TransECWithRepeat(const ErrorCodeEnum& ec)
-	{
-		ErrorCodeEnum result(ec);
-		if (ec == Error_Succeed) {
-			//ResetRepeatErrTimes();
-		} else if (!m_bOpened) {
-			result = Error_DevNotAvailable;
-		} else if (0 < DeviceBaseHelper::CountDevError(GetEntityBase()->GetFunction(), m_contiErrTimes)) {
-			result = Error_DevFailAddUp;
-			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("exceed max allow repeat error times! 0x%x -> 0x%x", ec, result);
-		}
-		return result;
-	}
-#endif //_MSC_VER
 	
 	void InitialMaxResizeValue();
 };

Module/mod_HSPScanner/mod_HSPScanner.cpp

@@ -3,7 +3,7 @@
 
 #include "stdafx.h"
 #include "mod_HSPScanner.h"
-
+#include "fileutil.h"
 
 void CHSPScannerServerSession::Handle_StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
 	HSPScannerService_StartPreview_Ans>::Pointer ctx)
@@ -73,8 +73,52 @@ void CHSPScannerServerSession::Handle_Exit(SpOnewayCallContext<HSPScannerService
 	m_pEntity->Exit(ctx);
 }
 
+#if defined(_MSC_VER)
+ErrorCodeEnum CHSPScannerEntity::CustomVendorLibInfo()
+{
+	if (vendorLibInfo.strVendor.Compare("keba", true) == 0
+		&& ((vendorLibInfo.strVersion == "7" && vendorLibInfo.strBatch == "1")
+			|| (vendorLibInfo.strVersion == "1" && vendorLibInfo.strBatch == "1"))) {
+		CSimpleStringA strExistDriver(true);
+		BOOL isNewOne(FALSE);
+		if (ExistsFileA("C:\\Program Files (x86)\\eloamDll_2.4\\bin\\eloamDll.dll")) {
+			strExistDriver = "C:\\Program Files (x86)\\eloamDll_2.4\\bin\\eloamDll.dll";
+			isNewOne = TRUE;
+		} else if (ExistsFileA("C:\\Program Files\\eloamDll_2.4\\bin\\eloamDll.dll")) {
+			strExistDriver = "C:\\Program Files\\eloamDll_2.4\\bin\\eloamDll.dll";
+			isNewOne = TRUE;
+		} else if (ExistsFileA("C:\\Program Files (x86)\\eloamDll_2.3\\bin\\eloamDll.dll")) {
+			strExistDriver = "C:\\Program Files (x86)\\eloamDll_2.3\\bin\\eloamDll.dll";
+		} else if (ExistsFileA("C:\\Program Files\\eloamDll_2.3\\bin\\eloamDll.dll")) {
+			strExistDriver = "C:\\Program Files\\eloamDll_2.3\\bin\\eloamDll.dll";
+		}
+
+		if (!strExistDriver.IsNullOrEmpty()) {
+			CSmartPointer<IConfigInfo> spConfig;
+			GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
+			CSimpleStringA strDepDirPath(true);
+			GetFunction()->GetPath("Dep", strDepDirPath);
+			strDepDirPath += "\\";
+			strDepDirPath += "HSPScanner.keba.7.2.dll";
+			if (ExistsFileA(strDepDirPath)) {
+				int value(0);
+				spConfig->ReadConfigValueInt(GetEntityName(), "KebaAdapterSwitch", value);
+				if (value == 0) {
+					LogWarn(Severity_Low, Error_Debug, LOG_WARN_HSPS_VENDORDLL_KEBA_MATCHED, strExistDriver);
+				} else {
+					LogWarn(Severity_Low, Error_Debug, LOG_WARN_HSPS_VENDORDLL_CHANGE, strDepDirPath);
+					vendorLibInfo.strVersion = "7";
+					vendorLibInfo.strBatch = "2";
+				}
+			}
+		}
+	}
+	return Error_Succeed;
+}
+#endif //_MSC_VER
 
 
 SP_BEGIN_ENTITY_MAP()
 	SP_ENTITY(CHSPScannerEntity)
 	SP_END_ENTITY_MAP()
+

Module/mod_HSPScanner/mod_HSPScanner.h

@@ -83,10 +83,7 @@ public:
 
 	virtual void OnStarted()
 	{
-#if defined(_MSC_VER)
-		/** Windows °æ±¾ÐèÒª Gifur@2022915]*/
-		if (m_fsm.m_bOpened) { m_fsm.UploadVendorDllInfo(); }
-#endif //_MSC_VER
+
 	}
 
 	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
@@ -198,6 +195,11 @@ public:
 	virtual bool IsService() const { return true; }
 	virtual bool IsMultiThread() const { return true; }; 
 
+	protected:
+#if defined(_MSC_VER)
+		ErrorCodeEnum CustomVendorLibInfo();
+#endif //_MSC_VER
+
 private:
 	CHSPScannerFSM m_fsm;
 };