#IQRV #comment 卡机编译适配支持

DevAdapter/self/CMakeLists.txt

@@ -9,6 +9,7 @@ rvc_define_dependen_dirs()
 add_subdirectory(liblog4vendor)
 if(MSVC)
 	add_subdirectory(pinpad)
+	add_subdirectory(cardissuer)
 endif(MSVC)
 
 #  =-=-=-=-=-=-=-=-=-= {VendorName}/CMakeLists.txt 文件最后必须声明如下内容=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=

DevAdapter/self/cardissuer/CMakeLists.txt

@@ -0,0 +1,19 @@
+# 声明模块名称的前缀和名称
+rvc_dev_define_module("CardIssuer")
+
+# rvc_dev_config_library 内需要使用这三个参数，用于拼接输出的适配器文件名称
+set(${MODULE_PREFIX}_VENDOR ${CURRENT_VENDOR})
+set(${MODULE_PREFIX}_VERSION "1")
+set(${MODULE_PREFIX}_BATCH "1")
+
+# 包含要编译的实现文件，rvc_dev_config_library 内使用
+set(${MODULE_PREFIX}_SRCS SHARED
+        VirtualDeviceClass.cpp 
+        )
+
+# 适配器工程需要通过此宏替代 add_library
+rvc_dev_config_library(${MODULE_NAME} ${MODULE_PREFIX})
+
+
+#  =-=-=-=-=-=-=-=-=-= {适配器工程}/CMakeLists.txt 文件最后必须声明如下内容=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=
+rvc_dev_target_install(${MODULE_FULL_NAME})

DevAdapter/self/cardissuer/VirtualDeviceClass.cpp

@@ -0,0 +1,675 @@
+#include "VirtualDeviceClass.h"
+#include "libCardIssuerLoader.h"
+
+static VirtualDeviceClassImpl* object = NULL;
+
+VirtualDeviceClassImpl::VirtualDeviceClassImpl()
+{
+
+}
+
+VirtualDeviceClassImpl::~VirtualDeviceClassImpl()
+{
+
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::GetDevCategory(DevCategoryInfo& devCategory)
+{
+	ErrorCodeEnum result;
+	DevCategoryInfo inner;
+	result = Bridge_GetDevCategory(&inner);
+	if (result == Error_Succeed) {
+		strcpy_s(devCategory.szType, MAX_DEV_TYPE_LEN, inner.szType);
+		strcpy_s(devCategory.szModel, MAX_DEV_MODEL_LEN, inner.szModel);
+		strcpy_s(devCategory.szVendor, MAX_DEV_VENDOR_LEN, inner.szVendor);
+		devCategory.eState = inner.eState;
+		devCategory.version.wMajor = inner.version.wMajor;
+		devCategory.version.wMinor = inner.version.wMinor;
+		devCategory.version.wRevision = inner.version.wRevision;
+		devCategory.version.wBuild = inner.version.wBuild;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::Reset()
+{
+	return Bridge_Reset();
+}
+
+
+ErrorCodeEnum VirtualDeviceClassImpl::DevClose()
+{
+	ErrorCodeEnum result = Error_Succeed;
+	return (result = Bridge_DevClose());
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::GetLastErr(DevErrorInfo& devErrInfo)
+{
+	ErrorCodeEnum result = Error_Succeed;
+	DevErrorInfo inner;
+	result = Bridge_GetLastErr(&inner);
+	if (result == Error_Succeed) {
+		devErrInfo.dwErrMsgLen = inner.dwErrMsgLen;
+		strcpy_s(devErrInfo.szErrMsg, MAX_DEV_ERROR_MSG_LEN, inner.szErrMsg);
+	}
+	return (result);
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
+{
+	ErrorCodeEnum result = Error_Succeed;
+	return (result = Bridge_DevOpen(dwPort, dwBaudRate));
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::GetDevStatus(CardIssuerStatus& devStatus)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CardIssuerStatus inner;
+	result = Bridge_GetDevStatus(&inner);
+	if (result == Error_Succeed) {
+		devStatus.eMedia = (CardStatusEnum)inner.eMedia;
+		devStatus.eRetainBin = (RtBinStatusEnum)inner.eRetainBin;
+		devStatus.dwRetainCount = inner.dwRetainCount;
+		memcpy(devStatus.eIssuerBin, inner.eIssuerBin, 12 * sizeof(int));
+		memcpy(devStatus.dwIssuerCount, inner.dwIssuerCount, 12 * sizeof(DWORD));
+		memcpy(devStatus.eKakuTape, inner.eKakuTape, 8 * sizeof(int));
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::GetDeviceSN(char*& pDevSN)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	char* inner = new char[128];
+	if (inner == NULL) return Error_Resource;
+	memset(inner, 0, sizeof(char) * 128);
+	result = Bridge_GetDeviceSN(&inner);
+	if (result == Error_Succeed) {
+		strcpy_s(pDevSN, 128, inner);
+	}
+	delete[] inner;
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MoveCard(CardPosEnum eCardPos, int hopperNo /*= 1*/)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_MoveCard(eCardPos, hopperNo);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SetCardInType(CardInEnum eCardIn)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SetCardInType(eCardIn);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MagRead(MagTracks& magTracks)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_MagTracks inner;
+	result = Bridge_MagRead(&inner);
+	if (result == Error_Succeed) {
+		magTracks.eRange = (TrackRange)inner.eRange;
+		for (int i = 0; i < MAX_MAG_TRACK_NUM; ++i) {
+			magTracks.track[i].eSource = (TrackSrcEnum)inner.track[i].eSource;
+			magTracks.track[i].eStatus = (TrackDataStateEnum)inner.track[i].eStatus;
+			magTracks.track[i].dwSize = inner.track[i].dwSize;
+			memset(magTracks.track[i].data, 0, sizeof(BYTE) * MAX_MAG_TRACK_SIZE);
+			memcpy(magTracks.track[i].data, inner.track[i].data, sizeof(BYTE) * MAX_MAG_TRACK_SIZE);
+		}
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_MagTracks inner;
+	inner.eRange = magTracks.eRange;
+	for (int i = 0; i < MAX_MAG_TRACK_NUM; ++i) {
+		inner.track[i].eSource = (TrackSrcEnum)magTracks.track[i].eSource;
+		inner.track[i].eStatus = (TrackDataStateEnum)magTracks.track[i].eStatus;
+		inner.track[i].dwSize = magTracks.track[i].dwSize;
+		memset(inner.track[i].data, 0, sizeof(BYTE) * MAX_MAG_TRACK_SIZE);
+		memcpy(inner.track[i].data, magTracks.track[i].data, sizeof(BYTE) * MAX_MAG_TRACK_SIZE);
+	}
+	result = Bridge_MagWrite(inner, eWriteMode);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SetRetractCounter(DWORD dwCount)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SetRetractCounter(dwCount);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SetIssuerCounter(DWORD dwCount, int hopperNo /*= 1*/)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SetIssuerCounter(dwCount, hopperNo);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ActiveICCard()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_ActiveICCard();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ContactIC()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_ContactIC();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ReleaseIC()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_ReleaseIC();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::WarmReset()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_ReleaseIC();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ICCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CmdInfo inner_sendBuf;
+	Bridge_CmdInfo inner_recvBuf;
+
+	inner_sendBuf.dwSize = sendBuf.dwSize;
+	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+
+	result = Bridge_ICCommand(inner_sendBuf, &inner_recvBuf);
+	if (result == Error_Succeed) {
+		recvBuf.dwSize = inner_recvBuf.dwSize;
+		memcpy(recvBuf.data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMActive(BYTE vcc /*= 0x30*/)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SAMActive(vcc);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMDeactivate()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SAMDeactivate();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMWarmReset()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SAMWarmReset();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMQueryStatus(SAMStatus& samStatus)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SAMStatus inner;
+
+	result = Bridge_SAMQueryStatus(&inner);
+	if (result == Error_Succeed) {
+		samStatus.isActive = inner.isActive;
+		samStatus.chosenOfSAM = inner.chosenOfSAM;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMSelect(const int sn)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SAMSelect(sn);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SAMCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CmdInfo inner_sendBuf;
+	Bridge_CmdInfo inner_recvBuf;
+
+	inner_sendBuf.dwSize = sendBuf.dwSize;
+	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+
+	result = Bridge_SAMCommand(inner_sendBuf, &inner_recvBuf);
+	if (result == Error_Succeed) {
+		recvBuf.dwSize = inner_recvBuf.dwSize;
+		memcpy(recvBuf.data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ActiveICCardATR(CmdInfo& atrBuf)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CmdInfo inner;
+
+	inner.dwSize = atrBuf.dwSize;
+	memcpy(inner.data, atrBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+
+	result = Bridge_ActiveICCardATR(&inner);
+	if (result == Error_Succeed) {
+		atrBuf.dwSize = inner.dwSize;
+		memcpy(atrBuf.data, inner.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::Print(BYTE*& data, const int dataSize, const int side)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	BYTE* inner = new BYTE[2048];
+	if (inner == NULL) {
+		return Error_Resource;
+	}
+	memset(inner, 0, sizeof(BYTE) * 2048);
+	memcpy(inner, data, 2048);
+
+	result = Bridge_Print(&inner, dataSize, side);
+	delete[] inner;
+
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::QueryPrinterStatus()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_QueryPrinterStatus();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ActiveContactlessICCard(char fstType, char scdType, char thdType, char& outType)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	char inner = outType;
+	result = Bridge_ActiveContactlessICCard(fstType, scdType, thdType, &inner);
+	if (result == Error_Succeed) {
+		outType = inner;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::DeactivateICCard()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_DeactivateICCard();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::DeactContactlessICCard()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_DeactContactlessICCard();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MifareCommand(MifareFuctionEnum eFunType, CmdInfo sendBuf, CmdInfo& recvBuf)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CmdInfo inner_sendBuf;
+	Bridge_CmdInfo inner_recvBuf;
+
+	inner_sendBuf.dwSize = sendBuf.dwSize;
+	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+
+	result = Bridge_MifareCommand((MifareFuctionEnum)eFunType, inner_sendBuf, &inner_recvBuf);
+	if (result == Error_Succeed) {
+		recvBuf.dwSize = inner_recvBuf.dwSize;
+		memcpy(recvBuf.data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::RFTypeABCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_CmdInfo inner_sendBuf;
+	Bridge_CmdInfo inner_recvBuf;
+
+	inner_sendBuf.dwSize = sendBuf.dwSize;
+	memcpy(inner_sendBuf.data, sendBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+
+	result = Bridge_RFTypeABCommand(inner_sendBuf, &inner_recvBuf);
+	if (result == Error_Succeed) {
+		recvBuf.dwSize = inner_recvBuf.dwSize;
+		memcpy(recvBuf.data, inner_recvBuf.data, sizeof(BYTE) * MAX_IC_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	BYTE inner = btType;
+	result = Bridge_DevOpenEx(dwPort, dwBaudRate, btOpenType, pDevSN, &inner);
+	if (result == Error_Succeed) {
+		btType = inner;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::TransferEnInit(int& iStatus, BYTE*& Cr1, int& lenR1, BYTE*& Cr3, int& lenR3, BYTE*& dKey, int& lenKey)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	int inner_iStatus = 0;
+	int inner_lenR1 = 0;
+	int inner_lenR3 = 0;
+	int inner_lenKey = 0;
+
+	BYTE* inner_cr1 = new BYTE[256];
+	BYTE* inner_cr3 = new BYTE[256];
+	BYTE* inner_key = new BYTE[256];
+
+	if (inner_cr1 == NULL || inner_cr3 == NULL || inner_key == NULL) {
+
+		if (inner_cr1 != NULL) delete[] inner_cr1;
+		if (inner_cr3 != NULL) delete[] inner_cr3;
+		if (inner_key != NULL) delete[] inner_key;
+		return Error_Resource;
+	}
+
+	memcpy(inner_cr1, Cr1, 256);
+	memcpy(inner_cr3, Cr3, 256);
+	memcpy(inner_key, dKey, 256);
+
+	result = Bridge_TransferEnInit(&inner_iStatus, &inner_cr1, &inner_lenR1, &inner_cr3, &inner_lenR3, &inner_key, &inner_lenKey);
+	if (result == Error_Succeed) {
+		iStatus = inner_iStatus;
+		lenR1 = inner_lenR1;
+		lenR3 = inner_lenR3;
+		lenKey = inner_lenKey;
+
+		memcpy(Cr1, inner_cr1, 256);
+		memcpy(Cr3, inner_cr3, 256);
+		memcpy(dKey, inner_key, 256);
+	}
+
+	if (inner_cr1 != NULL) delete[] inner_cr1;
+	if (inner_cr3 != NULL) delete[] inner_cr3;
+	if (inner_key != NULL) delete[] inner_key;
+
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SetR2(int& iStatus, BYTE* pCr2, int lenR2)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	int inner_iStatus = iStatus;
+	result = Bridge_SetR2(&inner_iStatus, pCr2, lenR2);
+	if (result == Error_Succeed) {
+		iStatus = inner_iStatus;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SendWorkingKey(const char* pWorkingKey)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SendWorkingKey(pWorkingKey);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLLoadKey(const SCIKeyInfo key)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SCIKeyInfo inner;
+	memcpy(inner.key, key.key, MAX_WORKING_KEY_SIZE);
+	inner.dwSize = key.dwSize;
+	result = Bridge_SLLoadKey(inner);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLSetParam(SCIParamType eType, int value)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SLSetParam(eType, value);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLLock()
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_SLLock();
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLUnLock(const SCICheckCode checkCode, bool bTemp /*= true*/)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SCICheckCode inner;
+	inner.dwSize = checkCode.dwSize;
+	memcpy(inner.code, checkCode.code, MAX_CHECK_CODE_SIZE);
+	result = Bridge_SLUnLock(inner, bTemp ? 1 : 0);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLGetTempData(SCITempData& ksnData, SCITempData& ramData)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SCITempData inner_ksn;
+	Bridge_SCITempData inner_ram;
+
+	result = Bridge_SLGetTempData(&inner_ksn, &inner_ram);
+	if (result == Error_Succeed) {
+		ksnData.dwSize = inner_ksn.dwSize;
+		memcpy(ksnData.data, inner_ksn.data, MAX_TEMP_DATA_SIZE);
+		ramData.dwSize = inner_ram.dwSize;
+		memcpy(ramData.data, inner_ram.data, MAX_TEMP_DATA_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::SLOpenDoor(const SCITempData data)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SCITempData inner;
+	inner.dwSize = data.dwSize;
+	memcpy(inner.data, data.data, MAX_TEMP_DATA_SIZE);
+	result = Bridge_SLOpenDoor(inner);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothControl(SCIBluetoothCMD eCmd)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_BluetoothControl(eCmd);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothModifyKey(unsigned char* key)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_BluetoothModifyKey(key);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothModifyName(unsigned char* name)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_BluetoothModifyName(name);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothGetVersion(char*& version)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	char* inner = new char[256];
+	if (inner == NULL) return Error_Resource;
+	memset(inner, 0, sizeof(char) * 256);
+	result = Bridge_BluetoothGetVersion(&inner);
+	if (result == Error_Succeed) {
+		strcpy_s(version, 256, inner);
+	}
+	delete[] inner;
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothGetConnectName(unsigned char*& name)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	unsigned char* inner = new unsigned char[256];
+	if (inner == NULL) return Error_Resource;
+	memset(inner, 0, sizeof(unsigned char) * 256);
+	result = Bridge_BluetoothGetConnectName(&inner);
+	if (result == Error_Succeed) {
+		strcpy((char*)name, (const char*)inner);
+	}
+	delete[] inner;
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::BluetoothGetSignalStrength(unsigned char*& signal)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	unsigned char* inner = new unsigned char[256];
+	if (inner == NULL) return Error_Resource;
+	memset(inner, 0, sizeof(unsigned char) * 256);
+	result = Bridge_BluetoothGetSignalStrength(&inner);
+	if (result == Error_Succeed) {
+		strcpy((char*)signal, (const char*)inner);
+	}
+	delete[] inner;
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::LightControl(SCILightType eLight, bool bOnOff)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_LightControl(eLight, bOnOff ? 1 : 0);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::QueryBatteryPower(int& bat)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	int inner;
+	result = Bridge_QueryBatteryPower(&inner);
+	if (result == Error_Succeed) {
+		bat = inner;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MoveCardToSlot(int slot)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_MoveCardToSlot(slot);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::MoveCardFromSlot(int slot)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	result = Bridge_MoveCardFromSlot(slot);
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::ReadAccount(CardNo& cardNo)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+
+	Bridge_CardNo inner;
+	result = Bridge_ReadAccount(&inner);
+	if (result == Error_Succeed) {
+		cardNo.dwSize = inner.dwSize;
+		cardNo.dwTrack2Size = inner.dwTrack2Size;
+		cardNo.dwTrack3Size = inner.dwTrack3Size;
+		memcpy(cardNo.account, inner.account, MAX_MAG_TRACK_SIZE);
+		memcpy(cardNo.track2, inner.track2, MAX_MAG_TRACK_SIZE);
+		memcpy(cardNo.track3, inner.track3, MAX_MAG_TRACK_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::GetSlotSum(int& sum)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	int inner;
+	result = Bridge_GetSlotSum(&inner);
+	if (result == Error_Succeed) {
+		sum = inner;
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::QuerySlotsStatus(SlotStatus& slots, const int slot, bool bFull /*= false*/)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_SlotStatus inner;
+
+	result = Bridge_QuerySlotsStatus(&inner, slot, bFull ? 1 : 0);
+	if (result == Error_Succeed) {
+		slots.dwSize = inner.dwSize;
+		memcpy(slots.status, inner.status, MAX_SLOT_BUFFER_SIZE);
+	}
+	return result;
+}
+
+ErrorCodeEnum VirtualDeviceClassImpl::PrintCardFaceRightNow(const KakuPrintInfo printInfo)
+{
+	ErrorCodeEnum result = Error_Unexpect;
+	Bridge_KakuPrintInfo inner;
+	memset(inner.formPath, 0, sizeof(char) * MAX_KAKU_FILE_SIZE);
+	memset(inner.fields, 0, sizeof(char) * MAX_KAKU_FIELDS_SIZE);
+	strcpy_s(inner.formPath, printInfo.formPath);
+	strcpy_s(inner.fields, printInfo.fields);
+
+	result = Bridge_PrintCardFaceRightNow(inner);
+	return result;
+}
+
+DEVICEBASE_API ErrorCodeEnum  CreateDevComponent(DeviceBaseClass*& pOutDevAptObj)
+{
+	ErrorCodeEnum result(Error_Unexpect);
+	if (object == NULL) {
+		char* buf;
+		DWORD size;
+		const char* var = "INVOKE_VENDOR_ADAPTER_NAME";
+		size = GetEnvironmentVariableA(var, NULL, 0);
+		//ERROR_ENVVAR_NOT_FOUND
+		if (size <= 0) {
+			return Error_InvalidState;
+		}
+		buf = new char[size + 3];
+		if (buf == NULL) {
+			return Error_Resource;
+		}
+		memset(buf, 0, sizeof(char) * (size + 3));
+		size = GetEnvironmentVariableA(var, buf, size);
+		result = Bridge_LoadDevObject(buf);
+		if (result == Error_Succeed) {
+			object = new VirtualDeviceClassImpl();
+		}
+		delete[] buf;
+	}
+	pOutDevAptObj = object;
+	return result;
+}
+
+DEVICEBASE_API ErrorCodeEnum  ReleaseDevComponent(DeviceBaseClass*& pInDevAptObj)
+{
+	ErrorCodeEnum result = Bridge_ReleaseDevObject();
+	if (result == Error_Succeed && pInDevAptObj != NULL) {
+		delete pInDevAptObj;
+		pInDevAptObj = NULL;
+	}
+	return result;
+}
+

DevAdapter/self/cardissuer/VirtualDeviceClass.h

@@ -0,0 +1,147 @@
+#ifndef VIRTUAL_DEVICE_CLASS_HEADER_
+#define VIRTUAL_DEVICE_CLASS_HEADER_
+
+
+#include "CardIssuerClass.h"
+
+class VirtualDeviceClassImpl : public CardIssuerClass
+{
+public:
+	VirtualDeviceClassImpl();
+	~VirtualDeviceClassImpl();
+
+	//DeviceBaseClass
+	ErrorCodeEnum GetDevCategory(DevCategoryInfo& devCategory);
+	ErrorCodeEnum Reset();
+	ErrorCodeEnum DevClose();
+	ErrorCodeEnum GetLastErr(DevErrorInfo& devErrInfo);
+
+	//SubDeviceClass
+	ErrorCodeEnum DevOpen(DWORD dwPort, DWORD dwBaudRate);
+
+	ErrorCodeEnum GetDevStatus(CardIssuerStatus& devStatus);
+
+	ErrorCodeEnum GetDeviceSN(char*& pDevSN);
+
+	ErrorCodeEnum MoveCard(CardPosEnum eCardPos, int hopperNo = 1);
+
+	ErrorCodeEnum SetCardInType(CardInEnum eCardIn);
+
+	ErrorCodeEnum MagRead(MagTracks& magTracks);
+
+	ErrorCodeEnum MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode);
+
+	ErrorCodeEnum SetRetractCounter(DWORD dwCount);
+
+	ErrorCodeEnum SetIssuerCounter(DWORD dwCount, int hopperNo = 1);
+
+	ErrorCodeEnum ActiveICCard();
+
+	ErrorCodeEnum ContactIC();
+
+	ErrorCodeEnum ReleaseIC();
+
+	ErrorCodeEnum WarmReset();
+
+	ErrorCodeEnum ICCommand(CmdInfo sendBuf, CmdInfo& recvBuf);
+	//////////////////SAM 卡操作部分////////////////////
+	ErrorCodeEnum SAMActive(BYTE vcc = 0x30);;
+	ErrorCodeEnum SAMDeactivate();;
+	ErrorCodeEnum SAMWarmReset();;
+	ErrorCodeEnum SAMQueryStatus(SAMStatus& samStatus);;
+	ErrorCodeEnum SAMSelect(const int sn);;
+	//即时制卡卡库需要实现SAMCommand，用来执行apdu指令
+	ErrorCodeEnum SAMCommand(CmdInfo sendBuf, CmdInfo& recvBuf);;
+	//即时制卡卡库需要实现ActiveICCardATR，用来激活卡片，返回ATR
+	ErrorCodeEnum ActiveICCardATR(CmdInfo& atrBuf);
+
+	////////////////卡面打印部分（非即时制卡的卡面印刷，即时制卡的卡面打印接口为PrintCardFaceRightNow），部分机型(例如合肥分行大机)有此功能//////////////////
+	ErrorCodeEnum Print(BYTE*& data, const int dataSize, const int side);;
+	ErrorCodeEnum QueryPrinterStatus();;
+
+	////////////////////////////////////////////////////////////////////////////
+	////////非接(IC)部分 start，没有此部分，在接口实现中直接返回Error_NotImpl///////////////
+	////////////////////////////////////////////////////////////////////////////
+
+	ErrorCodeEnum ActiveContactlessICCard(char fstType, char scdType, char thdType, char& outType);
+	//
+	//	Deactivate contact IC card
+	//
+	ErrorCodeEnum DeactivateICCard();
+	//
+	//	Deactivate contactless IC card
+	//
+	ErrorCodeEnum DeactContactlessICCard();
+	//
+	//	RF Mifare Classic protocol operation
+	//	Arguments:
+	//	- eFunType:function type as load key,authentication and so on
+	//	- sendBuf:[parameter][data]
+	//	- recvBuf:[status(1byte)][return data]
+	//
+	ErrorCodeEnum MifareCommand(MifareFuctionEnum eFunType, CmdInfo sendBuf, CmdInfo& recvBuf);
+	//
+	//	RF Type A,B command.
+	//	APDU:Application Protocol Data Unit
+	//	Arguments:
+	// 	- CmdSend.lpCmd:Command-APDU
+	// 	- CmdRecv.lpData:Response-APDU
+	//
+	ErrorCodeEnum RFTypeABCommand(CmdInfo sendBuf, CmdInfo& recvBuf);
+	////////非接(IC)部分 end/////////////////////////////////////////////////////////
+
+	ErrorCodeEnum DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char* pDevSN, BYTE& btType);
+
+	/////////////////////////////////////////////////////////////////////////
+	///以下是便携式卡机特有API，接口实现中其他机型直接返回Error_NotImpl即可//
+	/////////////////////////////////////////////////////////////////////////
+
+	ErrorCodeEnum TransferEnInit(int& iStatus, BYTE*& Cr1, int& lenR1, BYTE*& Cr3, int& lenR3, BYTE*& dKey, int& lenKey);
+
+	ErrorCodeEnum SetR2(int& iStatus, BYTE* pCr2, int lenR2);
+
+	ErrorCodeEnum SendWorkingKey(const char* pWorkingKey);
+
+	//安全锁接口部分 begin
+	ErrorCodeEnum SLLoadKey(const SCIKeyInfo key);
+
+	ErrorCodeEnum SLSetParam(SCIParamType eType, int value);
+	ErrorCodeEnum SLLock();
+	ErrorCodeEnum SLUnLock(const SCICheckCode checkCode, bool bTemp = true);
+	ErrorCodeEnum SLGetTempData(SCITempData& ksnData, SCITempData& ramData);
+	ErrorCodeEnum SLOpenDoor(const SCITempData data);
+	//安全锁接口部分 end
+
+	//蓝牙控制部分 start
+	//蓝牙指令控制，命令参看SCIBluetoothCMD说明
+	ErrorCodeEnum BluetoothControl(SCIBluetoothCMD eCmd);
+	//修改配对密码
+	ErrorCodeEnum BluetoothModifyKey(unsigned char* key);
+	//修改蓝牙设备名称
+	ErrorCodeEnum BluetoothModifyName(unsigned char* name);
+	//获取版本信息
+	ErrorCodeEnum BluetoothGetVersion(char*& version);
+	//获取连接设备名称
+	ErrorCodeEnum BluetoothGetConnectName(unsigned char*& name);
+	//获取连接设备信号强度
+	ErrorCodeEnum BluetoothGetSignalStrength(unsigned char*& signal);
+	//蓝牙控制部分 end
+
+	ErrorCodeEnum LightControl(SCILightType eLight, bool bOnOff);
+	ErrorCodeEnum QueryBatteryPower(int& bat);
+
+	ErrorCodeEnum MoveCardToSlot(int slot);
+	//把卡片从指定卡槽位移动到读卡器
+	ErrorCodeEnum MoveCardFromSlot(int slot);
+	//读取卡号
+	//优先从IC卡解析卡号，如果纯磁条卡，则返回磁道解析的卡号
+	ErrorCodeEnum ReadAccount(CardNo& cardNo);
+	//获取总卡槽数
+	ErrorCodeEnum GetSlotSum(int& sum);
+	//获取卡槽状态
+	ErrorCodeEnum QuerySlotsStatus(SlotStatus& slots, const int slot, bool bFull = false);
+	//即时制卡卡库专用接口
+	ErrorCodeEnum PrintCardFaceRightNow(const KakuPrintInfo printInfo);
+};
+
+#endif //VIRTUAL_DEVICE_CLASS_HEADER_