myvtm/DevAdapter/self/dep/libHSPSCannerLoader/libHSPSCannerLoader.cpp

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

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



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

HINSTANCE hinstLib = NULL;

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

struct DevErrorInfo errInfoInstance;

void SetLastErrInfo(const char* formatStr, ...)
{
	va_list arg;
	va_start(arg, formatStr);
	sprintf_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) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_MisMatched;
		}
		pFuncReleaseAdapt = (DevAdaptObjReleaseFunc)GetProcAddress(hinstLib, "ReleaseDevComponent");
		if (NULL == pFuncCreateAdapt) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NotIntegrated;
		}
		erroCode = pFuncCreateAdapt((DeviceBaseClass*&)pDevAdapterInstance);
		if (erroCode != Error_Succeed) {
			pDevAdapterInstance = NULL;
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_NoTarget;
		}
		if (pDevAdapterInstance == NULL) {
			FreeLibrary(hinstLib);
			pFuncCreateAdapt = NULL;
			pFuncReleaseAdapt = NULL;
			return Error_Null;
		}

	} else {
		SetLastErrInfo("load library failed %d", GetLastError());
		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()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->DevOpen();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_SetParam(int type, int value)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->SetParam((ParamType)type, (ParamTypeValue)value);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_SetPreview(short nValue)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->SetPreview(nValue);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ScanImage(const char* pszFileName)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->ScanImage(pszFileName);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_ScanImageEx(BYTE* pBtImg, int* pBtLen, const char* pszFileName)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	int inner = *pBtLen;
	ErrorCodeEnum result = pDevAdapterInstance->ScanImageEx(pBtImg, inner, pszFileName);
	*pBtLen = inner;
	return result;
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_SetViewPos(int nX, int nY, int nWidth)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->SetViewPos(nX, nY, nWidth);
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_SetProperty()
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	return pDevAdapterInstance->SetProperty();
}

LIBSUBDEVICELOADER_API ErrorCodeEnum Bridge_GetDevStatus(Bridge_HspsDevStatus* status)
{
	if (pDevAdapterInstance == NULL) {
		return Error_NotInit;
	}
	HspsDevStatus inner;
	ErrorCodeEnum result = pDevAdapterInstance->GetDevStatus(inner);
	if (result == Error_Succeed) {
		status->isConnected = inner.isConnected;
		status->inPreview = inner.inPreview;
		status->inShow = inner.inShow;
	}
	return result;
}