myvtm/DevAdapter/self/cardissuer/VirtualDeviceClass.cpp

#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;
}