myvtm/Module/include/DevFSMCommBase.hpp

#ifndef _COMM_DEVICE_FSM_BASE_HPP_
#define _COMM_DEVICE_FSM_BASE_HPP_

#include "DevEntityCommBase.hpp"
#include "SpFSM.h"
#include "DevErrorCode.h"
#include "DeviceBaseClass.h"

#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

/*

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,
	Vendor_Sankyo,
	Vendor_ChinaVision,
	Vendor_Hyosung,
	Vendor_Kxd,
	Vendor_Keba,
	Vendor_Nantian,
	Vendor_yotap,
	Vendor_ZSS,
	Vendor_GreateWall,
	Vendor_YiHua,
	Vendor_GRG,
	Vendor_CW,
	Vendor_EastCom,
	Vendor_HuaXin,
	Vendor_MAX
};

static const char* VendorNameStr[] = {
	"Unknown",
	"Sankyo",
	"ChinaVision",
	"hyosung",
	"kxd",
	"keba",
	"nantian",
	"yotap",
	"zss",
	"gwi",
	"yh", // "yihua"
	"grg",
	"CW",
	"EastCom",
	"hx"
};

inline static VendorNameType GetCurVendorType(LPCTSTR vendorName)
{
	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) {
			idx = i;
			break;
		}
	}
	if (idx == -1) {
		/*历史遗留原因，怡化厂商有两个适配器名字*/
		if (strnicmp(vendorName, "yihua", strlen("yihua")) == 0) {
			idx = Vendor_YiHua;
		}
		else {
			idx = Vendor_Invalide;
		}
	}
	return (VendorNameType)idx;
}

template <typename TSubAdpt>
struct DevAdptLibHelper
{

	ErrorCodeEnum LoadLibAddress(const CSimpleStringA& strFullLibPath)
	{
		ErrorCodeEnum erroCode = Error_Succeed;

		do {
			int res = toolkit_dlopen(strFullLibPath, &m_lib);
			if (res != 0) {
				Dbg("toolkit_dlopen[%s] failed with error %s.", strFullLibPath.GetData(), toolkit_dlerror(&m_lib));
				erroCode = Error_DevLoadFileFailed;
				break;
			}

			if ((res = toolkit_dlsym(&m_lib, "CreateDevComponent", (void**)&pFuncCreateAdapt)) != 0) {
				Dbg("Get 'CreateDevComponent' Func address failed with error: %s", toolkit_dlerror(&m_lib));
				erroCode = Error_DevLoadFileFailed;
				break;
			}
			if ((res = toolkit_dlsym(&m_lib, "ReleaseDevComponent", (void**)&pFuncReleaseAdapt)) != 0) {
				Dbg("Get 'ReleaseDevComponent' Func address failed with error: %s", toolkit_dlerror(&m_lib));
				erroCode = Error_DevLoadFileFailed;
				break;
			}

		} while (false);

		if (IS_FAILURED(erroCode)) {
			TearDown();
		}

		return erroCode;
	}

	ErrorCodeEnum CreateDevAdptObject()
	{
		if (m_AdptObjPtr != nullptr) {
			return Error_AlreadyExist;
		}
		if (pFuncCreateAdapt == nullptr || pFuncReleaseAdapt == nullptr) {
			return Error_NotInit;
		}

		ErrorCodeEnum erroCode = Error_Succeed;
		erroCode = pFuncCreateAdapt((DeviceBaseClass*&)m_AdptObjPtr);
		if (IS_FAILURED(erroCode)) {
			Dbg("Create device adapter object failed! EC=%s", SpStrError(erroCode));
			return erroCode;
		}

		LOG_ASSERT(m_AdptObjPtr != nullptr);

		return Error_Succeed;
	}

	/** Integrate function LoadLibAddress and CreateDevAdptObject*/
	ErrorCodeEnum LoadUp(const CSimpleStringA& strFullLibPath)
	{
		ErrorCodeEnum erroCode = LoadLibAddress(strFullLibPath);
		if (IS_SUCCEED(erroCode)) {
			erroCode = CreateDevAdptObject();
		}
		return erroCode;
	}

	void TearDown()
	{
		if (m_AdptObjPtr != nullptr) {
			m_AdptObjPtr->DevClose();
			if (nullptr != pFuncReleaseAdapt) {
				DeviceBaseClass* devBasePtr = static_cast<DeviceBaseClass*>(m_AdptObjPtr);
#if DEVICE_BASE_INTERFACE_FILE_VERSION == 2
				pFuncReleaseAdapt(0, devBasePtr);
#else
				pFuncReleaseAdapt(devBasePtr);
#endif
				m_AdptObjPtr = nullptr;
			}
		}
		toolkit_dlclose(&m_lib);
		pFuncReleaseAdapt = pFuncCreateAdapt = nullptr;
	}

	explicit operator bool() const { return (m_AdptObjPtr != nullptr); }
	operator DeviceBaseClass* () { return m_AdptObjPtr; }

	TSubAdpt* GetDevPointer() { return m_AdptObjPtr; }

	TSubAdpt* operator->() { return m_AdptObjPtr; }

	DevAdptLibHelper()
		: pFuncCreateAdapt(nullptr), pFuncReleaseAdapt(nullptr)
		, m_AdptObjPtr(nullptr)
	{

	}
	~DevAdptLibHelper()
	{
		TearDown();
	}

private:

	toolkit_lib_t m_lib;
	DevAdaptObjCreateFunc pFuncCreateAdapt;
	DevAdaptObjReleaseFunc pFuncReleaseAdapt;

	TSubAdpt* m_AdptObjPtr;
};

struct DevEntityErrorCode {

	DWORD dwEntityId;
	DWORD dwVendorId;
	DWORD dwVendorErroCode;
	DWORD dwReserved;

	DevEntityErrorCode() :dwEntityId(0), dwVendorId(0), dwVendorErroCode(0), dwReserved(0) {}

	void ResetWithEntityID(WORD wEntityID)
	{
		dwEntityId = dwVendorId = dwVendorErroCode = dwReserved = 0;
		dwEntityId = wEntityID;
	}

	void SetDevCode(DWORD devErrorCode, DWORD dwReservedCode)
	{
		dwVendorErroCode = devErrorCode;
		dwReserved = dwReservedCode;
	}

	void SetVendorID(DWORD dwVendorID)
	{
		dwVendorId = dwVendorID;
	}

	DWORD GetCompleteErrorCode() const {
		return MAKE_SLV_ERRORCODE(dwEntityId, dwVendorId, dwVendorErroCode);
	}

	DWORD GetCompleteErrorCode2Business() const {
		return MAKE_SLV_ERRORCODE_TO_BUSINESS(dwEntityId, dwVendorErroCode, dwReserved);
	}

};

template<class TFSM, class TDevClass>
class CCommDevFSM : public FSMImpl<TFSM>
{
public:
	ErrorCodeEnum GetAndSplitDevErrInfo(CSimpleStringA& csErrMsg, 
		WORD& wdDevErrCode, LPCTSTR lpszFuncNameForDisplay = "");
	ErrorCodeEnum LogDevErrInfo(LPCTSTR lpszFuncName = "")
	{
		CSimpleStringA csMsg;
		WORD wdErrorCode = 0;
		return GetAndSplitDevErrInfo(csMsg, wdErrorCode, lpszFuncName);
	}
	bool GetDevErrorCode(WORD& wdErrorCode)
	{
		CSimpleStringA csMsg;
		ErrorCodeEnum eRet = GetAndSplitDevErrInfo(csMsg, wdErrorCode);
		return (eRet == Error_Succeed);
	}
protected:
	DevAdptLibHelper<TDevClass> m_hDevHelper;

	DevEntityErrorCode m_entCode;
	CSimpleStringA m_csAlarmMsg = "No more information";

	void UpdateEntityID()
	{
		CEntityStaticInfo esi = { 0 };
		ErrorCodeEnum ec = this->GetEntityBase()->GetFunction()->GetEntityStaticInfo(
			this->GetEntityBase()->GetEntityName(), esi);
		if (ec == Error_Succeed) {
			Dbg("wEntityDevelopID: 0x%X", esi.wEntityDevelopID);
			m_entCode.ResetWithEntityID(esi.wEntityDevelopID);
		}
	}

	DWORD UpdateDEC(DWORD dwVal = 0)
	{
		if (m_entCode.dwEntityId == 0) {
			UpdateEntityID();
		}
		int reserved = 0;
		reserved = (dwVal & 0xFC000) >> 14;
		m_entCode.SetDevCode(dwVal, reserved);
		return GetDEC();
	}
	DWORD GetDEC() const
	{
		return m_entCode.GetCompleteErrorCode();
	}
	//DWORD AlarmDEC() const {
	//	return GetDEC();
	//}
	DWORD AlarmDECToBusiness(DWORD dwVal = 0) {
		if (dwVal > 0)
			UpdateDEC(dwVal);
		//oilyang@20200528 according the meeting result,throw a LogError while answering ctx
		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
		DWORD dwCode = 0;
		if ((m_entCode.dwVendorErroCode >> 20) == m_entCode.dwEntityId)
			dwCode = m_entCode.dwVendorErroCode;
		else
			dwCode = m_entCode.GetCompleteErrorCode2Business();
		LogError(Severity_Middle, Error_Unexpect, dwCode, "TODO:");
		return dwCode;
	}
	void ClearRelatedDEC()
	{
		UpdateDEC();
		m_csAlarmMsg = "No more information";
	}
	void LogErrMsg(const char* pMsgHead, ErrorCodeEnum eErrCode, DWORD defaultDevCode = 0, BOOL bAlarm = FALSE);
};


template<class TFSM, class TDevClass>
inline ErrorCodeEnum CCommDevFSM<TFSM, TDevClass>::GetAndSplitDevErrInfo(
	CSimpleStringA& csErrMsg, WORD& wdDevErrCode, LPCTSTR lpszFuncNameForDisplay)
{
	csErrMsg = "";
	wdDevErrCode = 0;

	BOOL bDisplayFunName = TRUE;
	if (lpszFuncNameForDisplay == NULL || strlen(lpszFuncNameForDisplay) == 0)
		bDisplayFunName = FALSE;

	if (!m_hDevHelper) {
		Dbg("inst occurs nullptr !!!");
		return Error_Param;
	}

	DevErrorInfo devErrInfo;
	ZeroMemory(&devErrInfo, sizeof(DevErrorInfo));
	ErrorCodeEnum erroCode = m_hDevHelper->GetLastErr(devErrInfo);
	if (erroCode == Error_Succeed) {
		if (strlen(devErrInfo.szErrMsg) > 0) {
			csErrMsg = devErrInfo.szErrMsg;
		}

		if (devErrInfo.dwErrMsgLen > MAX_DEV_ERROR_MSG_LEN) {
			//oiltmp@20200520 comment the following line
			//wdDevErrCode = (WORD)((devErrInfo.dwErrMsgLen >> 16) & 0x0000FFFF);
		}
		if (bDisplayFunName) {
			Dbg("Invoke <%s> failed, Dev_GLE: DevErrCode[%d], ErrMsg[%s]",
				lpszFuncNameForDisplay, wdDevErrCode, (LPCTSTR)csErrMsg);
		}
		else {
			Dbg("Dev_GLE: DevErrCode[%d], ErrMsg[%s]", wdDevErrCode, (LPCTSTR)csErrMsg);
		}
	}
	else {
		if (bDisplayFunName) {
			Dbg("Invoke <%s> failed, and unfortunately Dev_GLE failed returned EC: %d(0x%X)",
				lpszFuncNameForDisplay, erroCode, erroCode);
			csErrMsg = CSimpleStringA::Format("Invoke <%s> failed", lpszFuncNameForDisplay);
		}
		else {
			Dbg("Dev_GLE failed returned EC: %d(0x%X)",
				erroCode, erroCode);
		}
	}
	return erroCode;
}

template<class TFSM, class TDevClass>
inline void CCommDevFSM<TFSM, TDevClass>::LogErrMsg(
	const char* pMsgHead, ErrorCodeEnum eErrCode, DWORD defaultDevCode, BOOL bAlarm)
{
	Dbg("%s failed, EC = %s(0x%x)", pMsgHead, SpStrError(eErrCode), eErrCode);
	WORD wdErrCode = 0;
	CSimpleStringA csErrMsg(true);
	ErrorCodeEnum ec = GetAndSplitDevErrInfo(csErrMsg, wdErrCode);
	if (ec == Error_Succeed && wdErrCode != 0) {
		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
		if ((defaultDevCode >> 20) == m_entCode.dwEntityId)
			UpdateDEC(defaultDevCode);
		else
			UpdateDEC(wdErrCode);
	}
	else if (defaultDevCode != 0) {
		UpdateDEC(defaultDevCode);
	}
	m_csAlarmMsg = CSimpleStringA::Format("%s failed EC= %s : %s",
		pMsgHead, SpStrError(eErrCode), (LPCTSTR)csErrMsg);
	if (bAlarm) {
		LogWarn(Severity_High, eErrCode, AlarmDECToBusiness(), (LPCTSTR)m_csAlarmMsg);
	}
	return;
}


#define HARDWARE_ENTITY_RESET_ENTITYID(ent, entityID)	\
do{\
	memset(&ent, 0, sizeof(ent));	\
	ent.dwEntityId = entityID;	\
} while (false)

#define HARDWARE_ENTITY_SET_DEVCODE(ent, ec, reserved)	\
do {\
	ent.dwVendorErroCode = ec;	\
	ent.dwReserved = reserved;	\
} while (false)

// 先不上厂商标识 [5/14/2020 7:34 @Gifur]
#define HARDWARE_ENTITY_SET_VENDOR_NAME(ent, str)	\
	ent.dwVendorId = 0/*(DWORD)DeviceBaseHelper::GetCurVendorType(str)*/ 

#define HARDWARE_ENTITY_MAKE_ERRORCODE(ec)	\
	MAKE_SLV_ERRORCODE(ec.dwEntityId, (ec.dwVendorId), ec.dwVendorErroCode)

#define HARDWARE_ENTITY_MAKE_ERRORCODE_TO_BUSINESS(ec)	\
	MAKE_SLV_ERRORCODE_TO_BUSINESS(ec.dwEntityId, ec.dwVendorErroCode, ec.dwReserved)

/*class object must have 'LogErrMsg' function.*/
#define LOG_ERROR_MSG_MACRO(errCode, MethodSig, DeviceType)\
	do {\
		if(errCode != Error_Succeed) {\
			LogErrMsg(CSimpleStringA::Format("%s::%s at line:%d", __FUNCTION__, #MethodSig, __LINE__), \
			errCode, MEC_DEVAPI_##DeviceType##_(MethodSig), TRUE);\
	}\
	} while (false)

#define LOG_CARDISSUER_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, CARDISSUER)

#define LOG_CARDSWIPER_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, CARDSWIPER)

#define LOG_THERMALPRINT_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, THERMALPRINT)

#define LOG_DEVCONTROL_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, DEVCONTROL)

#define LOG_PRINTSEAL_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, PRINTSEAL)

#define LOG_FINGERPRINT_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, FINGERPRINT)

#define LOG_HSPSCANNER_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, HSPSCANNER)

#define LOG_UPS_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, UPS)

#define LOG_GPIO_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, GPIO)

#define LOG_IDCER_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, IDCER)

#define LOG_RF_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, RF)

#define LOG_PINPAD_ERROR_MSG_MACRO(errCode, MethodSig)\
	LOG_ERROR_MSG_MACRO(errCode, MethodSig, EPP)


#endif /*_COMM_DEVICE_FSM_BASE_HPP_*/