myvtm/DevAdapter/nantian/cardissuer.1.1/cardissuer.nantian.1.1.cpp

#include "cardissuer.nantian.1.1.h"
#include<cstring>
#include <cstdio>
CardIssuerClassImpl::CardIssuerClassImpl()
        :m_mode(0)
{
	dplHandle = NULL;
	DRVCardDispenser = NULL;
	m_isDevOpened = false;
	m_isCanceled = false;

	m_busy_flag = false;
	m_signal_get_flag = false;

	m_SetCardInTypeFlag = 0;
	m_CardInTypeFlag = false;

	RetainBox = 0;

	m_trace = NULL;
	m_trace = new CILIXTrace(NULL,"CardIssuer","CardIssuer_ACT_F55570");
	
	if(!LoadNTDRVDLL()) return ;
}

CardIssuerClassImpl::~CardIssuerClassImpl()
{
	if (DRVCardDispenser != NULL) Destroy_DRV_CardDispenser(DRVCardDispenser);
	if (dplHandle)
        dlclose(dplHandle);
	DRVCardDispenser = NULL;
	dplHandle = NULL;
}

bool CardIssuerClassImpl::LoadNTDRVDLL()
{
	char szInIPath[1024],szNTDRVPath[1024];

	CILIX_AUX_X::CILIX_GetModuleCurPath(szInIPath);
	sprintf(szNTDRVPath,"%s%s",szInIPath,"libdrv_act_f55570.nantian.so");
	dplHandle = NULL;
    void *pszErr = NULL;
	
	
    dplHandle = dlopen(szNTDRVPath, RTLD_LAZY);
    if (!dplHandle || pszErr)
    {
		m_trace->WriteTrace(CILIXTRACE_L_ERROR,"LoadNTDRVDLL","加载底层库%s失败",szNTDRVPath);
        return FALSE;
    }
	Create_DRV_CardDispenser = NULL;
	Create_DRV_CardDispenser = (pCreate_DRV_CardDispenser)dlsym(dplHandle,"Create_DRV_CardDispenser");
	if(Create_DRV_CardDispenser == NULL)
	{
		m_trace->WriteTrace(CILIXTRACE_L_ERROR,"LoadNTDRVDLL","加载底层库方法 Create_DRV_CardDispenser 失败",szNTDRVPath);
		return false;
	}
	Destroy_DRV_CardDispenser = NULL;
	Destroy_DRV_CardDispenser = (pDestroy_DRV_CardDispenser)dlsym(dplHandle,"Destroy_DRV_CardDispenser");
	if(Destroy_DRV_CardDispenser == NULL)
	{
		m_trace->WriteTrace(CILIXTRACE_L_ERROR,"LoadNTDRVDLL","加载底层库方法 Destroy_DRV_CardDispenser 失败",szNTDRVPath);
		return false;
	}

	DRVCardDispenser = Create_DRV_CardDispenser();
	return true;
}


ErrorCodeEnum CardIssuerClassImpl::GetDevCategory(DevCategoryInfo &devCategory)
{
	m_busy_flag = true;
	WAITING_LOOP();
	
    ErrorCodeEnum err = Error_Succeed;
    std::strcpy(devCategory.szModel, "ACT_F55570");
    std::strcpy(devCategory.szType, "CardIssuer");
    std::strcpy(devCategory.szVendor, "nantian");
	
	m_busy_flag = false;
    return err;
}

ErrorCodeEnum CardIssuerClassImpl::Reset()
{
   m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;
	try
	{
		if(!m_isDevOpened) 
		{
			strcpy(m_errorInfo.szErrMsg, "device not connect");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet =Error_DevConnFailed;
			throw(iRet);
		}
		//复位设备
		char *sReset[10] = {NULL};
		char PowerOnFlag[10] ="1";
		char PowerOffFlag[10]="3";
		sReset[1] = PowerOnFlag;
		sReset[2] = PowerOffFlag;
		iRet = DRVCardDispenser->ResetDev(3,sReset);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}
		iRet = Error_Succeed;
	}
	catch(int eret){iRet = eret;}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}

ErrorCodeEnum CardIssuerClassImpl::DevClose()
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;
	iRet = DRVCardDispenser->CloseDev();
	if(iRet != 0)
	{
		m_isDevOpened = false;

		iRet =Error_DevConnFailed;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}

ErrorCodeEnum CardIssuerClassImpl::GetLastErr(DevErrorInfo &devErrInfo)
{
    static int times = 0;
    char szMessage[128];
    sprintf(szMessage, "this is the %d times error message", ++times);
    strcpy(devErrInfo.szErrMsg, szMessage);
    devErrInfo.dwErrMsgLen = strlen(szMessage);
    return Error_Succeed;
}

DEVICEBASE_API ErrorCodeEnum CreateDevComponent(DeviceBaseClass *&baseObj)
{
    baseObj = new CardIssuerClassImpl();
    if(baseObj == NULL) {
    return Error_Resource;
    } else {
    return Error_Succeed;
    }
}
DEVICEBASE_API ErrorCodeEnum  ReleaseDevComponent(DeviceBaseClass *&pBaseObj)
{
    if(pBaseObj == NULL) {
    return Error_Param;
    }
    if(CardIssuerClassImpl* pTmp = dynamic_cast<CardIssuerClassImpl*>(pBaseObj))
    {
    delete pTmp;
    pTmp = NULL;
    return Error_Succeed;
    }
    return Error_Param;
}

ErrorCodeEnum CardIssuerClassImpl::DevOpen(DWORD dwPort, DWORD dwBaudRate)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;
	char *CapInfo[10];
	for (int i = 0; i < 10; i++)
	{
		CapInfo[i] = new char[20];
		memset(CapInfo[i], 0, 20);
	}
	try
	{
		char szComPort[100];
		memset(szComPort,0,sizeof(szComPort));
		sprintf(szComPort,"Com%d",(int)dwPort);

		memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));
		iRet = DRVCardDispenser->OpenDev(szComPort,(int)dwBaudRate);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "connect to device failed");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			m_isDevOpened = false;

			iRet =Error_DevConnFailed;
			throw(iRet);
		}
		m_isDevOpened = true ;

		char szErrorMsg[1024] = "";

		//复位设备
		char *sReset[10] = {NULL};
		char PowerOnFlag[10] ="1";
		char PowerOffFlag[10]="3";
		sReset[1] = PowerOnFlag;
		sReset[2] = PowerOffFlag;
		iRet = DRVCardDispenser->ResetDev(3,sReset);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}

		int mSupplyBin =2, mRetainBin =1, mHoldBin =0;

		DRVCardDispenser->GetDevCap(CapInfo);
		mSupplyBin = atoi(CapInfo[0]);
		mRetainBin = atoi(CapInfo[1]);
		mHoldBin = atoi(CapInfo[2]);
		iRet = Error_Succeed;
	}catch(int eret){iRet = eret;}

	m_busy_flag = false;
	for (int i = 0; i < 10; i++)
	{
		delete[]CapInfo[i];
	}
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::GetDevStatus(CardIssuerStatus &devStatus)
{
	{

		if (m_busy_flag == true || m_signal_get_flag == true)
		{
			if (m_StatusErrorCode == Error_Succeed)
				devStatus = tempStatus;

			return m_StatusErrorCode;
		}
	}

	m_signal_get_flag = true;

	int iRet = Error_Succeed;
	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));
	char *BoxStatus[200]={NULL};
	for (int i = 0; i < 200; i++)
	{
		BoxStatus[i] = new char[20];
		memset(BoxStatus[i], 0, 20);
	}
	try
	{
		if(!m_isDevOpened) 
		{
			strcpy(m_errorInfo.szErrMsg, "device not connect");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet =Error_DevConnFailed;
			throw(iRet);
		}

		//***设备状态查询
		char sDevice[10] = "";
		char sMedia[10] = "";
		char sChipPower[10] = "";
		char sRetainCount[10] = "";
		char sShutter[10] = "";
		char *sStatus[100] = {NULL};
		sStatus[1] = sDevice;
		sStatus[2] = sMedia;
		sStatus[4] = sChipPower;
		sStatus[8] = sRetainCount;
		sStatus[16] = sShutter;
		DRVCardDispenser->GetDevStatus(0,sStatus);

		//***判断设备状态
		if ((atoi(sDevice) != CARDDISPENSER_DEVONLINE) && ((atoi(sDevice) != CARDDISPENSER_DEVBUSY)))
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}
		switch((atoi(sMedia)))
		{
		case CARDDISPENSER_MEDIAPRESENT:
			{
				tempStatus.eMedia = CI_MEDIA_PRESENT;
				if ((atoi(sChipPower)) == CARDDISPENSER_CHIPONLINE || (atoi(sChipPower)) == CARDDISPENSER_CHIPBUSY)
					tempStatus.eMedia = CI_MEDIA_IC;
			}break;
		case CARDDISPENSER_MEDIANOTPRESENT:
			{
				tempStatus.eMedia = CI_MEDIA_NOTPRESENT;								   
			}break;
		case CARDDISPENSER_MEDIAJAMMED:tempStatus.eMedia = CI_MEDIA_JAMMED;break;
		case CARDDISPENSER_MEDIAENTERING:
			{
				tempStatus.eMedia = CI_MEDIA_ENTERING;								   
			}break;
		case CARDDISPENSER_MEDIALATCHED:
			{
				tempStatus.eMedia = CI_MEDIA_IC;							   
			}break;
		default:
			{
				tempStatus.eMedia = CI_MEDIA_NOTPRESENT;								   
			}break;
		}
		
		//吞卡数
		tempStatus.dwRetainCount = atoi(sChipPower) ;

		int ierr = DRVCardDispenser->GetCardBoxStatus(BoxStatus);

		//回收箱状态
		switch (atoi(BoxStatus[101]))
		{
		case CARDDISPENSER_BOXSTATUSOK:
		case CARDDISPENSER_BOXSTATUSLOW:
		case CARDDISPENSER_BOXSTATUSEMPTY:
		case CARDDISPENSER_BOXSTATUSHIGH:
			RetainBox = 0;
			tempStatus.eRetainBin = CI_RETAINBIN_OK;
			break;
		case CARDDISPENSER_BOXSTATUSFULL:
			tempStatus.eRetainBin = CI_RETAINBIN_FULL;
			RetainBox = 1;
			break;
		case CARDDISPENSER_BOXSTATUSMISSING:
		case CARDDISPENSER_BOXSTATUSINOP:
		case CARDDISPENSER_BOXSTATUSUNKNOWN:
			tempStatus.eRetainBin = CI_RETAIN_NOTSUPP;
			RetainBox = 2;
			break;
		default:
			tempStatus.eRetainBin = CI_RETAIN_NOTSUPP;
			RetainBox = 2;
			break;
		}
		//发卡箱状态
		for (int i = 1; i <= 2; i++)
		{
			switch (atoi(BoxStatus[i]))
			{
			case CARDDISPENSER_BOXSTATUSOK:
			case CARDDISPENSER_BOXSTATUSFULL:
			case CARDDISPENSER_BOXSTATUSHIGH:
				tempStatus.eIssuerBin[i-1] = CI_ISSUEHOPPER_OK;
				break;
			case CARDDISPENSER_BOXSTATUSLOW:
				tempStatus.eIssuerBin[i-1] = CI_ISSUEHOPPER_LOW;
				break;
			case CARDDISPENSER_BOXSTATUSEMPTY:
				tempStatus.eIssuerBin[i-1] = CI_ISSUEHOPPER_EMPTY;
				break;
			case CARDDISPENSER_BOXSTATUSMISSING:
			case CARDDISPENSER_BOXSTATUSINOP:
			case CARDDISPENSER_BOXSTATUSUNKNOWN:
				tempStatus.eIssuerBin[i-1] = CI_ISSUEHOPPER_NOTSUPP;
				break;
			default:
				tempStatus.eIssuerBin[i-1] = CI_ISSUEHOPPER_NOTSUPP;
				break;
			}
		}
		//发卡箱3状态
		tempStatus.eIssuerBin[2] = CI_ISSUEHOPPER_NOTSUPP;

		tempStatus.dwIssuerCount[0] = 0;
		tempStatus.dwIssuerCount[1] = 0;
		tempStatus.dwIssuerCount[2] = 0;

	}catch(int eret)
	{
		iRet = eret;
	}
	devStatus = tempStatus;
	m_signal_get_flag = false;
	m_StatusErrorCode = (ErrorCodeEnum)iRet;
	for (int i = 0; i < 200; i++)
	{
		delete[]BoxStatus[i];
	}
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::GetDeviceSN(char *&pDevSN)
{
	int iRet = Error_Succeed;
	strcpy(pDevSN, "");
	return (ErrorCodeEnum)iRet;
}
//发卡机通用接口
ErrorCodeEnum CardIssuerClassImpl::MoveCard(CardPosEnum eCardPos, int hopperNo )
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed ;
	try
	{
		if(!m_isDevOpened) 
		{
			strcpy(m_errorInfo.szErrMsg, "device not connect");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet =Error_DevConnFailed;
			throw(iRet);
		}

		memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

		//***设备状态查询
		char sDevice[10] = "";
		char sMedia[10] = "";
		char sChipPower[10] = "";
		char sRetainCount[10] = "";
		char sShutter[10] = "";
		char *sStatus[100] = {NULL};
		sStatus[1] = sDevice;
		sStatus[2] = sMedia;
		sStatus[4] = sChipPower;
		sStatus[8] = sRetainCount;
		sStatus[16] = sShutter;
		DRVCardDispenser->GetDevStatus(0,sStatus);
		if(stoi(sDevice) != CARDDISPENSER_DEVONLINE)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet =Error_Hardware;
			throw(iRet);		
		}
		
		m_trace->WriteTrace(CILIXTRACE_L_INFO,"MoveCard","eCardPos:%d",eCardPos);
		switch(eCardPos)
		{
			//退卡
		case CI_MOVECARD_FRONT_GATE:
			{
				if(atoi(sMedia) == CARDDISPENSER_MEDIANOTPRESENT)
				{
					strcpy(m_errorInfo.szErrMsg, "device not card to Gate");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Param;
					throw(iRet);
				}
				if((atoi(sMedia)==CARDDISPENSER_MEDIALATCHED)||
					(atoi(sChipPower) == CARDDISPENSER_CHIPONLINE)||
					(atoi(sChipPower) == CARDDISPENSER_CHIPBUSY))
				{
					iRet = DRVCardDispenser->ICCPower(12,NULL,NULL);
					if(iRet != 0)
					{
						strcpy(m_errorInfo.szErrMsg, "device ReleaseDactivates Fail!");
						m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
						iRet =Error_Hardware;
						throw(iRet);
					}
				}
				iRet = DRVCardDispenser->EjectCard();
				if(iRet != 0)
				{
					strcpy(m_errorInfo.szErrMsg, "device EjectCard Fail!");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Hardware;
					throw(iRet);
				}
				m_SetCardInTypeFlag = 0;
				m_CardInTypeFlag= false;
			}
			break;
			//吞卡
		case CI_MOVECARD_BACK_NOT_HOLD:
			{
				if(RetainBox != 0)
				{
					iRet =Error_Hardware;
					throw(iRet);
				}
				if(atoi(sMedia) == CARDDISPENSER_MEDIANOTPRESENT)
				{
					strcpy(m_errorInfo.szErrMsg, "device not card to BACK_NOT_HOLD");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Param;
					throw(iRet);
				}
				if((atoi(sMedia)==CARDDISPENSER_MEDIALATCHED)||
					(atoi(sChipPower) == CARDDISPENSER_CHIPONLINE)||
					(atoi(sChipPower) == CARDDISPENSER_CHIPBUSY))
				{
					iRet = DRVCardDispenser->ICCPower(12,NULL,NULL);
					if(iRet != 0)
					{
						strcpy(m_errorInfo.szErrMsg, "device ReleaseDactivates Fail!");
						m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
						iRet =Error_Hardware;
						throw(iRet);
					}
				}
				int tryTime = 0;
STARTRETAIN:
				iRet = DRVCardDispenser->RetainCard(101);
				if(iRet != 0)
				{
					if((iRet == E_CARDDISPENSER_RETIANBINFULL) && (tryTime <= 1))
					{
						iRet = DRVCardDispenser->SetRetainCount(0);
						tryTime++;
						goto STARTRETAIN;	
					}
					m_trace->WriteTrace(CILIXTRACE_L_INFO,"MoveCard","CI_MOVECARD_BACK_NOT_HOLD.tryTime:%d",tryTime);
					strcpy(m_errorInfo.szErrMsg, "device RetainCard Fail!");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Hardware;
					throw(iRet);
				}
				m_SetCardInTypeFlag = 0;
				m_CardInTypeFlag= false;
			}
			break;
			//发卡
		case CI_MOVECARD_FROM_HOPPER:
			{
				if(atoi(sMedia) != CARDDISPENSER_MEDIANOTPRESENT)
				{
					strcpy(m_errorInfo.szErrMsg, "device not card not FROM_HOPPER");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Param;
					throw(iRet);
				}
				iRet = DRVCardDispenser->Dispense(hopperNo);
				if(iRet != 0)
				{
					strcpy(m_errorInfo.szErrMsg, "device dispenser card error");
					m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
					iRet =Error_Hardware;
					throw(iRet);
				}
			}
			break;

		}
	}
	catch(int eret)
	{
		iRet = eret;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SetCardInType(CardInEnum eCardIn)
{
	m_busy_flag = true;
	WAITING_LOOP();

	if(m_SetCardInTypeFlag != 0)
	{
		while(m_SetCardInTypeFlag != 2) 
		{;}
	}

	m_SetCardInTypeFlag = 1;

	int iRet = Error_Succeed;
	try
	{

		int iInsertAction = 0;
		switch(eCardIn)
		{
		case CI_CARD_IN_TYPE_FORBIDDEN:{iInsertAction= 0; m_CardInTypeFlag = false;}break;
		case CI_CARD_IN_TYPE_MAG:      {iInsertAction= 3;}break;
		case CI_CARD_IN_TYPE_ALL:      {iInsertAction= 1;}break;
		}

		if(m_CardInTypeFlag)
			throw 0;

		iRet = DRVCardDispenser->InsertCard(iInsertAction);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}
		if(eCardIn!=CI_CARD_IN_TYPE_FORBIDDEN)
			m_CardInTypeFlag = true;

		iRet = Error_Succeed;
	}
	catch(int eret)
	{
		iRet = eret;
	}
	m_busy_flag = false;
	m_SetCardInTypeFlag = 2;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::MagRead(MagTracks &magTracks)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;
	try
	{
		memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

		char magTrack1[1024]="";
		char magTrack2[1024]="";
		char magTrack3[1024]="";
		char *magList[10]={NULL};
		magList[1] = magTrack1;
		magList[2] = magTrack2;
		magList[4] = magTrack3;

		int magTrackStatus[10]={0};
		m_trace->WriteTrace(CILIXTRACE_L_INFO,"MagRead","magTracks.eRange:%d",magTracks.eRange);
		iRet = DRVCardDispenser->ReadTrack(magTracks.eRange,magList,magTrackStatus);

		if ((magTracks.eRange&CI_TRACK_RANGE_1) == CI_TRACK_RANGE_1)
		{
			magTracks.track[CI_TRACK_SOURCE_1].eSource = CI_TRACK_SOURCE_1;
			if ((iRet==E_DRVBASE_SUCCESS)&&(magTrackStatus[1] == E_DRVBASE_SUCCESS))
			{
				magTracks.track[CI_TRACK_SOURCE_1].eStatus = CI_DATA_OK;
				magTracks.track[CI_TRACK_SOURCE_1].dwSize = strlen(magTrack1);
				memcpy(magTracks.track[CI_TRACK_SOURCE_1].data, magTrack1, magTracks.track[CI_TRACK_SOURCE_1].dwSize);
				magTracks.track[CI_TRACK_SOURCE_1].data[magTracks.track[CI_TRACK_SOURCE_1].dwSize] = '\0';
			}
			else
			{
				magTracks.track[CI_TRACK_SOURCE_1].eStatus = CI_DATA_INVALID;
				magTracks.track[CI_TRACK_SOURCE_1].dwSize = 0;
				magTracks.track[CI_TRACK_SOURCE_1].data[magTracks.track[CI_TRACK_SOURCE_1].dwSize] = '\0';	
			}
		}
		//Track2
		if ((magTracks.eRange&CI_TRACK_RANGE_2) == CI_TRACK_RANGE_2)
		{
			magTracks.track[CI_TRACK_SOURCE_2].eSource = CI_TRACK_SOURCE_2;
			if ((iRet==E_DRVBASE_SUCCESS)&&(magTrackStatus[2] == E_DRVBASE_SUCCESS))
			{	
				magTracks.track[CI_TRACK_SOURCE_2].eStatus = CI_DATA_OK;
				magTracks.track[CI_TRACK_SOURCE_2].dwSize = strlen(magTrack2);
				memcpy(magTracks.track[CI_TRACK_SOURCE_2].data, magTrack2, magTracks.track[CI_TRACK_SOURCE_2].dwSize);
				magTracks.track[CI_TRACK_SOURCE_2].data[magTracks.track[CI_TRACK_SOURCE_2].dwSize] = '\0';
			}
			else
			{
				magTracks.track[CI_TRACK_SOURCE_2].eStatus = CI_DATA_INVALID;
				magTracks.track[CI_TRACK_SOURCE_2].dwSize = 0;
				magTracks.track[CI_TRACK_SOURCE_2].data[magTracks.track[CI_TRACK_SOURCE_2].dwSize] = '\0';			
			}
		}

		//Track3
		if ((magTracks.eRange&CI_TRACK_RANGE_3) == CI_TRACK_RANGE_3)
		{
			magTracks.track[CI_TRACK_SOURCE_3].eSource = CI_TRACK_SOURCE_3;
			if ((iRet==E_DRVBASE_SUCCESS)&&(magTrackStatus[4] == E_DRVBASE_SUCCESS))
			{	
				magTracks.track[CI_TRACK_SOURCE_3].eStatus = CI_DATA_OK;
				magTracks.track[CI_TRACK_SOURCE_3].dwSize = strlen(magTrack3);
				memcpy(magTracks.track[CI_TRACK_SOURCE_3].data, magTrack3, magTracks.track[CI_TRACK_SOURCE_3].dwSize);
				magTracks.track[CI_TRACK_SOURCE_3].data[magTracks.track[CI_TRACK_SOURCE_3].dwSize] = '\0';
			}
			else
			{
				magTracks.track[CI_TRACK_SOURCE_3].eStatus = CI_DATA_INVALID;
				magTracks.track[CI_TRACK_SOURCE_3].dwSize = 0;
				magTracks.track[CI_TRACK_SOURCE_3].data[magTracks.track[CI_TRACK_SOURCE_3].dwSize] = '\0';
			}
		}

	}
	catch(int eret)
	{
		iRet = eret;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::MagWrite(MagTracks magTracks, MagWriteModeEnum eWriteMode)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;
	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	int ierr = 0;
	BOOL write_success_flag = FALSE;

	char magTrack1[1024]="";
	char magTrack2[1024]="";
	char magTrack3[1024]="";
	char *magList[10]={NULL};
	magList[1] = magTrack1;
	magList[2] = magTrack2;
	magList[4] = magTrack3;

	int magTrackStatus[10]={0};
	//磁道解析
	//Track1
	if ((magTracks.eRange&CI_TRACK_RANGE_1) == CI_TRACK_RANGE_1)
	{
		if (magTracks.track[CI_TRACK_SOURCE_1].dwSize != 0)
		{
			memset(magTrack1,0,sizeof(magTrack1));
			memcpy(magTrack1,magTracks.track[CI_TRACK_SOURCE_1].data,strlen((char *)magTracks.track[CI_TRACK_SOURCE_1].data));
			ierr = DRVCardDispenser->WriteTrack(CI_TRACK_RANGE_1,magList,magTrackStatus);
			if ((ierr == E_DRVBASE_SUCCESS)&&(magTrackStatus[1] == E_DRVBASE_SUCCESS))
			{
				write_success_flag = TRUE;
			}
		}
	}

	//Track2
	if ((magTracks.eRange&CI_TRACK_RANGE_2) == CI_TRACK_RANGE_2)
	{
		if (magTracks.track[CI_TRACK_SOURCE_2].dwSize != 0)
		{
			memset(magTrack2,0,sizeof(magTrack2));
			memcpy(magTrack2,magTracks.track[CI_TRACK_SOURCE_2].data,strlen((char *)magTracks.track[CI_TRACK_SOURCE_2].data));
			ierr = DRVCardDispenser->WriteTrack(CI_TRACK_RANGE_2,magList,magTrackStatus);
			if ((ierr == E_DRVBASE_SUCCESS)&&(magTrackStatus[2] == E_DRVBASE_SUCCESS))
			{
				write_success_flag = TRUE;
			}
		}
	}

	//Track3
	if ((magTracks.eRange&CI_TRACK_RANGE_3) == CI_TRACK_RANGE_3)
	{
		if (magTracks.track[CI_TRACK_SOURCE_3].dwSize != 0)
		{
			memset(magTrack3,0,sizeof(magTrack3));
			memcpy(magTrack3,magTracks.track[CI_TRACK_SOURCE_3].data,strlen((char *)magTracks.track[CI_TRACK_SOURCE_3].data));
			ierr = DRVCardDispenser->WriteTrack(CI_TRACK_RANGE_3,magList,magTrackStatus);
			if ((ierr == E_DRVBASE_SUCCESS)&&(magTrackStatus[4] == E_DRVBASE_SUCCESS))
			{
				write_success_flag = TRUE;
			}
		}
	}

	if (write_success_flag == FALSE)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SetRetractCounter(DWORD dwCount)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;

	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	int ierr = 0;

	//清空回收箱计数
	if (dwCount == 0)
	{
		ierr = DRVCardDispenser->SetRetainCount(0);

		if (ierr < 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
		}
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SetIssuerCounter(DWORD dwCount, int hopperNo )
{
	int iRet = 0 ;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::ActiveICCard()
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;

	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	unsigned char sATR[1024] = "";
	int iATR = 0;

	int ierr = 0;
	iRet = DRVCardDispenser->ICCPower(2, (char*)sATR, &iATR);

	if (iRet < 0)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::ContactIC()
{

	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;

	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	unsigned char sATR[1024] = "";
	int iATR = 0;
	int ierr = 0;

	iRet = DRVCardDispenser->ICCPower(1, (char*)sATR, &iATR);

	if (iRet  < 0)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::ReleaseIC()
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;

	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	iRet = DRVCardDispenser->ICCPower(4, NULL, NULL);

	if (iRet < 0)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::WarmReset()
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;
	
	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	unsigned char sATR[1024] = "";
	int iATR = 0;
	char sErrMsg[100] = "";

	iRet = DRVCardDispenser->ICCPower(12, NULL, NULL);

	iRet = DRVCardDispenser->ICCPower(3, (char*)sATR, &iATR);

	if (iRet < 0)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;

	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::ICCommand(CmdInfo sendBuf, CmdInfo &recvBuf)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = 0;

	try
	{
		memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

		unsigned char szSendData[1024] = "";
		memset(szSendData,0,sizeof(szSendData));
		int iSendLength = 0;
		memcpy(szSendData,sendBuf.data,sendBuf.dwSize);
		iSendLength = sendBuf.dwSize;
		unsigned char szRecvData[1024] = "";
		int iRecvLength = 0;
TRANSMIT:

		memset(szRecvData,0,sizeof(szRecvData));
		iRet = DRVCardDispenser->ICCTransmit(0, (char*)szSendData, iSendLength, (char*)szRecvData, &iRecvLength);

		if (iRet < 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}
		if (szRecvData[iRecvLength-2] == 0x61)
		{
			memset(szSendData,0,sizeof(szSendData));
			szSendData[0]=0x00;
			szSendData[1]=0xC0;
			szSendData[2]=0x00;
			szSendData[3]=0x00;	 
			szSendData[4]=szRecvData[iRecvLength-1];
			iSendLength=5;
			goto  TRANSMIT;
		}
		else if (szRecvData[iRecvLength-2] == 0x6C)
		{
			szSendData[iSendLength-1]=szRecvData[iRecvLength-1];
			goto  TRANSMIT;
		}
		memcpy(recvBuf.data,szRecvData,iRecvLength);
		recvBuf.dwSize = iRecvLength;

	}catch(int eret){iRet = eret;}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::DeactivateICCard()
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;

	memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));

	char sErrMsg[100] = "";

	iRet = DRVCardDispenser->ICCPower(8, NULL, NULL);

	if (iRet < 0)
	{
		strcpy(m_errorInfo.szErrMsg, "hardware error");
		m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
		iRet = Error_Hardware;
	}
	m_busy_flag = false;
	return (ErrorCodeEnum)iRet;
}

//非接部分
ErrorCodeEnum CardIssuerClassImpl::ActiveContactlessICCard(char fstType, char scdType, char thdType, char &outType)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::DeactContactlessICCard()
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::MifareCommand(MifareFuctionEnum eFunType, CmdInfo sendBuf, CmdInfo &recvBuf)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::RFTypeABCommand(CmdInfo sendBuf, CmdInfo &recvBuf)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}

///以下是便携式卡机特有API，接口实现中其他机型直接返回Error_NotImpl即可//
/////////////////////////////////////////////////////////////////////////
ErrorCodeEnum CardIssuerClassImpl::DevOpenEx(DWORD dwPort, DWORD dwBaudRate, BYTE btOpenType, const char *pDevSN, BYTE &btType)
{
	m_busy_flag = true;
	WAITING_LOOP();

	int iRet = Error_Succeed;
	char *CapInfo[10];
	for (int i = 0; i < 10; i++)
	{
		CapInfo[i] = new char[20];
		memset(CapInfo[i], 0, 20);
	}
	try
	{
		int iBaud = 38400;
		char szComPort[100];
		memset(szComPort,0,sizeof(szComPort));

		if(dwPort<0)strcpy(szComPort,"/dev/ttyXRUSB1");
		else sprintf(szComPort,"/dev/ttyXRUSB%d",dwPort - 1);
		
		memset(m_errorInfo.szErrMsg, 0, sizeof(m_errorInfo.szErrMsg));
		iRet = DRVCardDispenser->OpenDev(szComPort,(int)dwBaudRate);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "connect to device failed");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			m_isDevOpened = false;

			iRet =Error_DevConnFailed;
			throw(iRet);
		}
		m_isDevOpened = true ;

		char szErrorMsg[1024] = "";

		//复位设备
		char *sReset[10] = {NULL};
		char PowerOnFlag[10] ="1";
		char PowerOffFlag[10]="3";
		sReset[1] = PowerOnFlag;
		sReset[2] = PowerOffFlag;
		iRet = DRVCardDispenser->ResetDev(3,sReset);
		if(iRet != 0)
		{
			strcpy(m_errorInfo.szErrMsg, "hardware error");
			m_errorInfo.dwErrMsgLen = strlen(m_errorInfo.szErrMsg);
			iRet = Error_Hardware;
			throw(iRet);
		}	
		int mSupplyBin =2, mRetainBin =1, mHoldBin =0;

		DRVCardDispenser->GetDevCap(CapInfo);
		mSupplyBin = atoi(CapInfo[0]);
		mRetainBin = atoi(CapInfo[1]);
		mHoldBin = atoi(CapInfo[2]);
		iRet = Error_Succeed;
	}catch(int eret){iRet = eret;}
	btType = DEV_OPEN_TYPE_COM;
	m_busy_flag = false;
	for (int i = 0; i < 10; i++)
	{
		delete[]CapInfo[i];
	}
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::TransferEnInit(int &iStatus, BYTE *&Cr1, int &lenR1, BYTE *&Cr3, int &lenR3, BYTE *&dKey, int &lenKey)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SetR2(int &iStatus, BYTE *pCr2, int lenR2)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SendWorkingKey(const char *pWorkingKey)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMActive(BYTE vcc)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMDeactivate()
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMWarmReset()
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMCommand(CmdInfo sendBuf, CmdInfo& recvBuf)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMQueryStatus(SAMStatus& samStatus)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SAMSelect(const int sn)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::ActiveICCardATR(CmdInfo& atrBuf)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
    ////////////////卡面打印部分，部分机型有此功能//////////////////
ErrorCodeEnum CardIssuerClassImpl::Print(BYTE*& data, const int dataSize, const int side)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::QueryPrinterStatus()
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
//安全锁接口部分
ErrorCodeEnum CardIssuerClassImpl::SLLoadKey(const SCIKeyInfo key)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SLSetParam(SCIParamType eType, int value)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SLLock()
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SLUnLock(const SCICheckCode checkCode, bool bTemp )
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SLGetTempData(SCITempData &ksnData, SCITempData &ramData)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::SLOpenDoor(const SCITempData data)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
//蓝牙控制部分
ErrorCodeEnum CardIssuerClassImpl::BluetoothControl(SCIBluetoothCMD eCmd)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::BluetoothModifyKey(unsigned char *key)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::BluetoothModifyName(unsigned char *name)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::BluetoothGetVersion(char *&version)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::BluetoothGetConnectName(unsigned char *&name)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::BluetoothGetSignalStrength(unsigned char *&signal)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}

//控制灯光
ErrorCodeEnum CardIssuerClassImpl::LightControl(SCILightType eLight, bool bOnOff)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}
ErrorCodeEnum CardIssuerClassImpl::QueryBatteryPower(int &bat)
{
	int iRet = 0;
	return (ErrorCodeEnum)iRet;
}

void CardIssuerClassImpl::WAITING_LOOP()
{
	while (1)
	{

		if (m_signal_get_flag == false)
			break;

	}
}