myvtm/DevAdapter/self/dep/libIDCertificateLoader/libIDCertificateLoader.cpp

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

#include "stdafx.h"
#include <stdio.h>
#include "libIDCertificateLoader.h"
typedef ErrorCodeEnum(*DevAdaptObjCreateFunc)(DeviceBaseClass*& baseObj);
typedef ErrorCodeEnum(*DevAdaptObjReleaseFunc)(DeviceBaseClass*& pBaseObj);

HINSTANCE hinstLib = NULL;

DevAdaptObjCreateFunc pFuncCreateAdapt = NULL;
DevAdaptObjReleaseFunc pFuncReleaseAdapt = NULL;
IDCerClass* 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)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DevOpen(dwPort);
}

LIBSUBDEVICELOADER_API	ErrorCodeEnum Bridge_IDCerRFControl(int bControl)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->IDCerRFControl(!!bControl);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_IDCerAuthenticate()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->IDCerAuthenticate();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_IDCerGetData(Bridge_IDCerInfo* idCerInfo) 
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	IDCerInfo inner;
	memset(&inner, 0, sizeof(inner));

	ErrorCodeEnum result = pDevAdapterInstance->IDCerGetData(inner);
	if (result == Error_Succeed)
	{
		memcpy(idCerInfo->name.data, inner.name.data, MAX_IDCER_INFO_SIZE);
		idCerInfo->name.dwSize = inner.name.dwSize;

		memcpy(idCerInfo->sex.data, inner.sex.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->sex.dwSize = inner.sex.dwSize;

		memcpy(idCerInfo->nation.data, inner.nation.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->nation.dwSize = inner.nation.dwSize;

		memcpy(idCerInfo->birthday.data, inner.birthday.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->birthday.dwSize = inner.birthday.dwSize;

		memcpy(idCerInfo->address.data, inner.address.data, MAX_IDCER_INFO_SIZE);
		idCerInfo->address.dwSize = inner.address.dwSize;

		memcpy(idCerInfo->idno.data, inner.idno.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->idno.dwSize = inner.idno.dwSize;

		memcpy(idCerInfo->department.data, inner.department.data, MAX_IDCER_INFO_SIZE);
		idCerInfo->department.dwSize = inner.department.dwSize;

		memcpy(idCerInfo->startDate.data, inner.startDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->startDate.dwSize = inner.startDate.dwSize;

		memcpy(idCerInfo->endDate.data, inner.endDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfo->endDate.dwSize = inner.endDate.dwSize;

		memcpy(idCerInfo->newAddress.data, inner.newAddress.data, MAX_IDCER_INFO_SIZE);
		idCerInfo->newAddress.dwSize = inner.newAddress.dwSize;

		memcpy(idCerInfo->photoPath.data, inner.photoPath.data, MAX_IDCER_PHOTO_PATH);
		idCerInfo->photoPath.dwSize = inner.photoPath.dwSize;
	}

	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_IDCerGetDataEx(Bridge_IDCerInfoEx* idCerInfoEx)
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	IDCerInfoEx inner;
	memset(&inner, 0, sizeof(inner));

	ErrorCodeEnum result = pDevAdapterInstance->IDCerGetDataEx(inner);
	if (result == Error_Succeed)
	{
		memcpy(idCerInfoEx->name.data, inner.name.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx->name.dwSize = inner.name.dwSize;

		memcpy(idCerInfoEx->sex.data, inner.sex.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->sex.dwSize = inner.sex.dwSize;

		memcpy(idCerInfoEx->nation.data, inner.nation.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->nation.dwSize = inner.nation.dwSize;

		memcpy(idCerInfoEx->birthday.data, inner.birthday.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->birthday.dwSize = inner.birthday.dwSize;

		memcpy(idCerInfoEx->address.data, inner.address.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx->address.dwSize = inner.address.dwSize;

		memcpy(idCerInfoEx->idno.data, inner.idno.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->idno.dwSize = inner.idno.dwSize;

		memcpy(idCerInfoEx->department.data, inner.department.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx->department.dwSize = inner.department.dwSize;

		memcpy(idCerInfoEx->startDate.data, inner.startDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->startDate.dwSize = inner.startDate.dwSize;

		memcpy(idCerInfoEx->endDate.data, inner.endDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->endDate.dwSize = inner.endDate.dwSize;

		memcpy(idCerInfoEx->newAddress.data, inner.newAddress.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx->newAddress.dwSize = inner.newAddress.dwSize;

		memcpy(idCerInfoEx->photoPath.data, inner.photoPath.data, MAX_IDCER_PHOTO_PATH);
		idCerInfoEx->photoPath.dwSize = inner.photoPath.dwSize;

		memcpy(idCerInfoEx->englishName.data, inner.englishName.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx->englishName.dwSize = inner.englishName.dwSize;

		memcpy(idCerInfoEx->nationality.data, inner.nationality.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx->nationality.dwSize = inner.nationality.dwSize;

		memcpy(idCerInfoEx->idVersion.data, inner.idVersion.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx->idVersion.dwSize = inner.idVersion.dwSize;

		memcpy(idCerInfoEx->idType.data, inner.idType.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx->idType.dwSize = inner.idType.dwSize;

		memcpy(idCerInfoEx->reserved.data, inner.reserved.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx->reserved.dwSize = inner.reserved.dwSize;

		memcpy(idCerInfoEx->txzCode.data, inner.txzCode.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->txzCode.dwSize = inner.txzCode.dwSize;

		memcpy(idCerInfoEx->issuedSN.data, inner.issuedSN.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx->issuedSN.dwSize = inner.issuedSN.dwSize;

		memcpy(idCerInfoEx->reserved2.data, inner.reserved2.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->reserved2.dwSize = inner.reserved2.dwSize;

		memcpy(idCerInfoEx->reserved3.data, inner.reserved3.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->reserved3.dwSize = inner.reserved3.dwSize;

		memcpy(idCerInfoEx->reserved4.data, inner.reserved4.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->reserved4.dwSize = inner.reserved4.dwSize;

		memcpy(idCerInfoEx->reserved5.data, inner.reserved5.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx->reserved5.dwSize = inner.reserved5.dwSize;
	}

	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ForceIDEject() 
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->ForceIDEject();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ScanIDAndSaveImage() 
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->ScanIDAndSaveImage();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_QueryCardPos(int* pos) 
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	int inner;
	ErrorCodeEnum result = pDevAdapterInstance->QueryCardPos(inner);
	if (result == Error_Succeed)
	{
		*pos = inner;
	}
	return result; 
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_IDCerGetDataEx2(Bridge_IDCerInfoEx2* idCerInfoEx2)
{ 
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}

	IDCerInfoEx2 inner;
	memset(&inner, 0, sizeof(inner));

	ErrorCodeEnum result = pDevAdapterInstance->IDCerGetDataEx2(inner);
	if (result == Error_Succeed)
	{
		memcpy(idCerInfoEx2->name.data, inner.name.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx2->name.dwSize = inner.name.dwSize;

		memcpy(idCerInfoEx2->sex.data, inner.sex.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->sex.dwSize = inner.sex.dwSize;

		memcpy(idCerInfoEx2->nation.data, inner.nation.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->nation.dwSize = inner.nation.dwSize;

		memcpy(idCerInfoEx2->birthday.data, inner.birthday.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->birthday.dwSize = inner.birthday.dwSize;

		memcpy(idCerInfoEx2->address.data, inner.address.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx2->address.dwSize = inner.address.dwSize;

		memcpy(idCerInfoEx2->idno.data, inner.idno.data, 2 * MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->idno.dwSize = inner.idno.dwSize;

		memcpy(idCerInfoEx2->department.data, inner.department.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx2->department.dwSize = inner.department.dwSize;

		memcpy(idCerInfoEx2->startDate.data, inner.startDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->startDate.dwSize = inner.startDate.dwSize;

		memcpy(idCerInfoEx2->endDate.data, inner.endDate.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->endDate.dwSize = inner.endDate.dwSize;

		memcpy(idCerInfoEx2->newAddress.data, inner.newAddress.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx2->newAddress.dwSize = inner.newAddress.dwSize;

		memcpy(idCerInfoEx2->photoPath.data, inner.photoPath.data, MAX_IDCER_PHOTO_PATH);
		idCerInfoEx2->photoPath.dwSize = inner.photoPath.dwSize;

		memcpy(idCerInfoEx2->englishName.data, inner.englishName.data, MAX_IDCER_INFO_SIZE);
		idCerInfoEx2->englishName.dwSize = inner.englishName.dwSize;

		memcpy(idCerInfoEx2->nationality.data, inner.nationality.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx2->nationality.dwSize = inner.nationality.dwSize;

		memcpy(idCerInfoEx2->idVersion.data, inner.idVersion.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx2->idVersion.dwSize = inner.idVersion.dwSize;

		memcpy(idCerInfoEx2->idType.data, inner.idType.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx2->idType.dwSize = inner.idType.dwSize;

		memcpy(idCerInfoEx2->reserved.data, inner.reserved.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx2->reserved.dwSize = inner.reserved.dwSize;

		memcpy(idCerInfoEx2->txzCode.data, inner.txzCode.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->txzCode.dwSize = inner.txzCode.dwSize;

		memcpy(idCerInfoEx2->issuedSN.data, inner.issuedSN.data, IDCER_EIGHT_BYTE_SIZE);
		idCerInfoEx2->issuedSN.dwSize = inner.issuedSN.dwSize;

		memcpy(idCerInfoEx2->reserved2.data, inner.reserved2.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->reserved2.dwSize = inner.reserved2.dwSize;

		memcpy(idCerInfoEx2->reserved3.data, inner.reserved3.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->reserved3.dwSize = inner.reserved3.dwSize;

		memcpy(idCerInfoEx2->reserved4.data, inner.reserved4.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->reserved4.dwSize = inner.reserved4.dwSize;

		memcpy(idCerInfoEx2->reserved5.data, inner.reserved5.data, MAX_IDCER_SIMPLE_INFO_SIZE);
		idCerInfoEx2->reserved5.dwSize = inner.reserved5.dwSize;
	}

	return result;
}