myvtm/DevAdapter/self/dep/libContactlessCardLoader/libContactlessCardLoader.cpp

// libContactlessCardLoader.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include <Windows.h>
#include < stdio.h >
#include "libContactlessCardLoader.h"



typedef ErrorCodeEnum(*DevAdaptObjCreateFunc)(DeviceBaseClass*& baseObj);
typedef ErrorCodeEnum(*DevAdaptObjReleaseFunc)(DeviceBaseClass*& pBaseObj);

HINSTANCE hinstLib = NULL;

DevAdaptObjCreateFunc pFuncCreateAdapt = NULL;
DevAdaptObjReleaseFunc pFuncReleaseAdapt = NULL;
RFICClass* pDevAdapterInstance = NULL;

struct DevErrorInfo errInfoInstance;

void SetLastErrInfo(const char* formatStr, ...)
{
	va_list arg;
	va_start(arg, formatStr);
	vsprintf_s(errInfoInstance.szErrMsg, MAX_DEV_ERROR_MSG_LEN, formatStr, arg);
	errInfoInstance.dwErrMsgLen = strlen(errInfoInstance.szErrMsg);
	va_end(arg);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_LoadDevObject(const char* libraryPath)
{
	ErrorCodeEnum erroCode;
	hinstLib = LoadLibraryA(libraryPath);
	if (hinstLib != NULL) {
		pFuncCreateAdapt = (DevAdaptObjCreateFunc)GetProcAddress(hinstLib, "CreateDevComponent");
		if (NULL == pFuncCreateAdapt) {
			SetLastErrInfo("{\"ErrCode\":%u, \"Description\":\"Func:%s,Line:%d,Msg:GetProcAddress for CreateDevComponent\"}", GetLastError(), __FUNCTION__, __LINE__);
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_MisMatched;
		}
		pFuncReleaseAdapt = (DevAdaptObjReleaseFunc)GetProcAddress(hinstLib, "ReleaseDevComponent");
		if (NULL == pFuncCreateAdapt) {
			SetLastErrInfo("{\"ErrCode\":%u, \"Description\":\"Func:%s,Line:%d,Msg:GetProcAddress for ReleaseDevComponent\"}", GetLastError(), __FUNCTION__, __LINE__);
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NotIntegrated;
		}
		erroCode = pFuncCreateAdapt((DeviceBaseClass*&)pDevAdapterInstance);
		if (erroCode != Error_Succeed) {
			SetLastErrInfo("{\"ErrCode\":%u, \"RetCode\":%u, \"Description\":\"Func:%s,Line:%d,Msg:pFuncCreateAdapt for AdapterObject\"}", GetLastError(), erroCode, __FUNCTION__, __LINE__);
			pDevAdapterInstance = NULL;
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NoTarget;
		}
		if (pDevAdapterInstance == NULL) {
			SetLastErrInfo("{\"ErrCode\":%u, \"Description\":\"Func:%s,Line:%d,Msg:pFuncCreateAdapt return Null AdapterObject\"}", GetLastError(), __FUNCTION__, __LINE__);
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_Null;
		}

	} else {
		SetLastErrInfo("{\"ErrCode\":%u, \"Description\":\"Func:%s,Line:%d,Msg:LoadLibraryA current adapter file failed\"}", GetLastError(), __FUNCTION__, __LINE__);
		return Error_DevLoadFileFailed;
	}
	return Error_Succeed;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ReleaseDevObject()
{
	if (pFuncReleaseAdapt != NULL && pDevAdapterInstance != NULL) {
		DeviceBaseClass* devBasePtr = static_cast<DeviceBaseClass*>(pDevAdapterInstance);
		pFuncReleaseAdapt(devBasePtr);
		pDevAdapterInstance = NULL;
	}
	if (hinstLib != NULL) {
		FreeLibrary(hinstLib);
		hinstLib = NULL;
	}
	return Error_Succeed;
}

//////////////////////////////////////////////////////////////////////////

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetDevCategory(DevCategoryInfo* pDevCategory)
{
	ErrorCodeEnum result;
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	DevCategoryInfo inner;
	memset(inner.szType, 0, sizeof(char) * MAX_DEV_TYPE_LEN);
	memset(inner.szModel, 0, sizeof(char) * MAX_DEV_MODEL_LEN);
	memset(inner.szVendor, 0, sizeof(char) * MAX_DEV_VENDOR_LEN);

	result = pDevAdapterInstance->GetDevCategory(inner);
	if (result == Error_Succeed) {

		memset(pDevCategory->szType, 0, sizeof(char) * MAX_DEV_TYPE_LEN);
		memset(pDevCategory->szModel, 0, sizeof(char) * MAX_DEV_MODEL_LEN);
		memset(pDevCategory->szVendor, 0, sizeof(char) * MAX_DEV_VENDOR_LEN);

		strncpy_s(pDevCategory->szType, MAX_DEV_TYPE_LEN, inner.szType, strlen(inner.szType) > MAX_DEV_TYPE_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szType));
		strncpy_s(pDevCategory->szModel, MAX_DEV_MODEL_LEN, inner.szModel, strlen(inner.szModel) > MAX_DEV_MODEL_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szModel));
		strncpy_s(pDevCategory->szVendor, MAX_DEV_VENDOR_LEN, inner.szVendor, strlen(inner.szVendor) > MAX_DEV_VENDOR_LEN - 1 ? MAX_DEV_TYPE_LEN - 1 : strlen(inner.szVendor));

		pDevCategory->eState = inner.eState;
		pDevCategory->version.wMajor = inner.version.wMajor;
		pDevCategory->version.wMinor = inner.version.wMinor;
		pDevCategory->version.wRevision = inner.version.wRevision;
		pDevCategory->version.wBuild = inner.version.wBuild;
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_Reset()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->Reset();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_DevClose()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DevClose();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetLastErr(DevErrorInfo* pDevErrInfo)
{
	if (pDevAdapterInstance == NULL) {
		strcpy_s(pDevErrInfo->szErrMsg, MAX_DEV_ERROR_MSG_LEN, errInfoInstance.szErrMsg);
		pDevErrInfo->dwErrMsgLen = errInfoInstance.dwErrMsgLen;
		return Error_Succeed;
	}
	DevErrorInfo inner;
	ErrorCodeEnum result = pDevAdapterInstance->GetLastErr(inner);
	if (result == Error_Succeed) {
		memset(pDevErrInfo->szErrMsg, 0, sizeof(char) * MAX_DEV_ERROR_MSG_LEN);
		strncpy_s(pDevErrInfo->szErrMsg, MAX_DEV_ERROR_MSG_LEN, inner.szErrMsg, strlen(inner.szErrMsg) > MAX_DEV_ERROR_MSG_LEN - 1 ? MAX_DEV_ERROR_MSG_LEN - 1 : strlen(inner.szErrMsg));
		pDevErrInfo->dwErrMsgLen = inner.dwErrMsgLen;
	}
	return result;
}




//////////////////////////////////////////////////////////////////////////

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DevOpen(dwPort, dwBaudRate);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetDevStatus(Bridge_RFICReaderStatus* pDevStatus)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	RFICReaderStatus inner;
	ErrorCodeEnum result = pDevAdapterInstance->GetDevStatus(inner);
	if (result == Error_Succeed) {
		pDevStatus->eMediaPos = inner.eMediaPos;
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_AbortRead()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->AbortRead();
}


LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ActiveContactlessICCard(char fstType, char scdType, char thdType, char* pOutType)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	char inner;
	ErrorCodeEnum result = pDevAdapterInstance->ActiveContactlessICCard(fstType, scdType, thdType, inner);
	if (result == Error_Succeed) {
		*pOutType = inner;
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_DeactContactlessICCard()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DeactContactlessICCard();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_WarmReset()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->WarmReset();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_MifareCommand(int eFunType, Bridge_CmdInfo sendBuf, Bridge_CmdInfo* pRecvBuf)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	CmdInfo inner_sendBuf;
	CmdInfo inner_recvBuf;

	inner_sendBuf.dwSize = sendBuf.dwSize;
	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);

	ErrorCodeEnum result = pDevAdapterInstance->MifareCommand((MifareFuctionEnum)eFunType, inner_sendBuf, inner_recvBuf);
	if (result == Error_Succeed) {
		pRecvBuf->dwSize = inner_recvBuf.dwSize;
		memcpy(pRecvBuf->data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_RFTypeABCommand(Bridge_CmdInfo sendBuf, Bridge_CmdInfo* pRecvBuf)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	CmdInfo inner_sendBuf;
	CmdInfo inner_recvBuf;

	inner_sendBuf.dwSize = sendBuf.dwSize;
	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);

	ErrorCodeEnum result = pDevAdapterInstance->RFTypeABCommand(inner_sendBuf, inner_recvBuf);
	if (result == Error_Succeed) {
		pRecvBuf->dwSize = inner_recvBuf.dwSize;
		memcpy(pRecvBuf->data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
	}
	return result;
}


LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_HaltCard()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->HaltCard();
}