myvtm/Module/mod_cardissuer/CardIssuerFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CardIssuerFSM.h"
#include "CardIssuerClass.h"
#include "mod_cardissuer.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"
#include "RVCComm.h"
#include "publicFunExport.h"
//oilyang@20200522 go on using
// deprecated!! [4/17/2020 16:15 @Gifur]
#include "CommDevEntityErrorCode.h"
#include "CardIssuer_msg_g.h"
#include "ModuleMix.h"
#include "fileutil.h"
#include <algorithm>

char tmpxx[1024];
char testIC[1024];

//oiltest@20200915 temp for GetTickCount
#ifdef RVC_OS_WIN
	#define _ATL_NO_AUTOMATIC_NAMESPACE
	#include <winsock2.h>
	#include <Ws2bth.h>
	// Link to Bthprops.lib
	#include <BluetoothAPIs.h>
	#pragma comment (lib, "Ws2_32.lib")
	#pragma comment (lib, "Bthprops.lib")
#else
	#include<sys/time.h>
#include <dlfcn.h>
#endif //RVC_OS_WIN
		unsigned long long GetTickCountRVC() {
#ifdef RVC_OS_WIN
		return GetTickCount64();
#else
		struct timespec ts;

		clock_gettime(CLOCK_MONOTONIC, &ts);

		return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
#endif //RVC_OS_WIN
	}
		
#define CARDREADER_INIT_COUNT 3
#define GET_DEV_STATUS_COUNT 1//oilyang@20180104 change from 3 to 1,no need to test 3 times

const int TIMER1 = 1;
const int TIMER_EJECT = 2;
const int INSERT_INTERVAL = 300;
const int EJECT_INTERVAL = 300;
const int INSERT_TRY_NUM = 200;
const int READ_TRY_NUM = 1;//oiltmp
const int RESET_TRY_NUM = 3;
const int WAIT_TRY_NUM = 120;
const int WAIT_INTERVAL = 500;
const int MAX_RESET_TIMEROUT = 5000;
const int MAX_RESET_TIMES_PERIOD = 0;//oiltmp configure to ini file?

const int READ_TRY_INTERVAL = 300;
const int INIT_TRY_NUM = 3;
const int ACCEPT_TRY_INTERVAL = 500;
const int ACCEPT_TRY_NUM = 110;
//const int MAX_TEST_SHOW = 1024;
CRITICAL_SECTION g_sciRecord;
const unsigned char hextable[] = { "0123456789ABCDEF" };
void ConvAscii(unsigned char* Hex, char* Ascii, unsigned int len)
{
	unsigned int i;
	for (i = 0; i < len; i++)
	{
		Ascii[2 * i] = hextable[Hex[i] >> 4];
		Ascii[2 * i + 1] = hextable[Hex[i] & 0xf];
	}
	Ascii[2 * len] = 0;
}
//*******************************************************************************
void AsciiToHex(char* Ascii, unsigned char* Hex, int len)
{
	int i;
	unsigned char ch;
	for (i = 0; i < len; i = i + 2)
	{
		ch = (Ascii[i] & 0xf);
		if (Ascii[i] > '9')
			ch += 9;

		Hex[i / 2] = ch << 4;

		ch = Ascii[i + 1] & 0xf;
		if (Ascii[i + 1] > '9')
			ch += 9;

		Hex[i / 2] += ch;
	}
}
class CCardIssuerEntity;
void CCardIssuerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 0;
	SetDevStateAndSendMsg(DEVICE_STATUS_NOT_READY);
	FSMEvent *e;
	//经典大机 或者卡库
	//oilyang@20200426 add "Desk2S 2.1","Desk1S 1.0"
	if (!_strnicmp("RVC.Stand2S", m_csMachineType, strlen("RVC.Stand2S"))
		|| !_strnicmp("RVC.CardStore", m_csMachineType, strlen("RVC.CardStore"))
		|| !_strnicmp("RVC.CardPrinter", m_csMachineType, strlen("RVC.CardPrinter"))
		|| (_strnicmp("RVC.Desk2S", m_csMachineType, strlen("RVC.Desk2S")) == 0 && m_majorVerion == 2 && m_minorVerion == 1)
		|| (_strnicmp("RVC.Desk1S", m_csMachineType, strlen("RVC.Desk1S")) == 0 && m_majorVerion == 1 && m_minorVerion == 0))
	{
		e = new FSMEvent(USER_EVT_INIT);
	}
	//如果配置了便携发卡机
	else if (QueryIfCfgSCI() >= 1)
	{
		m_machineType = 2;//oiltmp
		e = new FSMEvent(USER_EVT_CONNECT);
	}
	//不是经典大机，又没有配置便携发卡机，转到NoCfgDev状态
	else
	{
		m_machineType = 3;//oiltmp
		e = new FSMEvent(USER_EVT_TRANSFER_TO_NOCFGDEV);
	}
	PostEventFIFO(e);
}

void CCardIssuerFSM::s0_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CCardIssuerFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s0 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT:
	{
		InitTask* task = new InitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
		return 0;
	}
		break;
	case USER_EVT_CONNECT:
		break;
	case USER_EVT_TRANSFER_TO_NOCFGDEV:
		break;
	case USER_EVT_QUIT:
		break;
	case USER_EVT_TEST:
		break;
	default:
		break;
	}
	return 0;
}
//Initializing
void CCardIssuerFSM::s1_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 1;
	GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
}
void CCardIssuerFSM::s1_on_exit()
{
LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s1_on_event(FSMEvent* event)
{
	LOG_FUNCTION();
	if (event->iEvt == USER_EVT_INITFINISHED) {
		event->SetHandled();
		int err = event->param1;
		if (err == 0) {
			return 0;
		} else {
			return 1;
		}
	}else if (event->iEvt == USER_EVT_QUIT) {
		event->SetHandled();
		return 0;
	}
	return 0;
}
//Idle
void CCardIssuerFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 2;		
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_IDLE);
	SetDevStateAndSendMsg(DEVICE_STATUS_NORMAL, false);
	
	m_resetTimes = 0;
	m_testResult = Error_Succeed;
	m_bIssuingExit = false;
	m_scanCount = 0;

	if (m_connectType == DEV_OPEN_TYPE_BLUETOOTH && 0 == m_bBTChecking)
	{
		BluetoothCheckTask* task = new BluetoothCheckTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	else if(m_connectType != DEV_OPEN_TYPE_BLUETOOTH && 2 == m_bBTChecking) 
	{
		m_bBTChecking = 1;
	}
	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogWarnInfoAboutTerm(this, m_adapterInfo);
	}
}
void CCardIssuerFSM::s2_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s2_on_event(FSMEvent* pEvt)
{
	Dbg("s2 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_ACCEPT:
	{
		CardAcceptEvent *cae = dynamic_cast<CardAcceptEvent*>(pEvt);
		m_bCancelAccept = false;
		AcceptTask* task = new AcceptTask(this);
		task->ctx = cae->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_ISSUE:
	case USER_EVT_ISSUE_EX:
	{
		IssueTask* task = new IssueTask(this);
		CardIssueEvent *cie = NULL;
		CardIssueExEvent *ciee = NULL;
		if (pEvt->iEvt == USER_EVT_ISSUE)
		{
			cie = dynamic_cast<CardIssueEvent*>(pEvt);
			task->ctx = cie->ctx;
			task->ctxEx = NULL;
		}
		else
		{
			ciee = dynamic_cast<CardIssueExEvent*>(pEvt);
			task->ctxEx = ciee->ctx;
			task->ctx = NULL;
		}
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_EXIT:
	{
		m_captureReason = "4001";
		m_bExit = true;
		pEvt->SetHandled();
		DoExitWhenIdleTask *task = new DoExitWhenIdleTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_GET_MATERIAL:
	{
		pEvt->SetHandled();
		GetMaterialEvent *pGME = dynamic_cast<GetMaterialEvent*>(pEvt);
		pGME->ctx->Ans.captured = m_CardCaptured;
		pGME->ctx->Ans.remains = m_remainsEx[0];
		pGME->ctx->Ans.issued = m_issuedEx[0];
		pGME->ctx->Ans.mixed = m_mixedEx[0];
		pGME->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_SET_MATERIAL:
	{
		m_bSettingMaterial = true;
		pEvt->SetHandled();
		bool bR, bC, bI, bM;
		bR = bC = bI = bM = true;
		SetMaterialEvent *pSME = dynamic_cast<SetMaterialEvent*>(pEvt);
		if (pSME->ctx->Req.bRemains)
		{
			m_CardInitEx[0] = m_remainsEx[0] = pSME->ctx->Req.remains;
			bR = SetCardRemains(pSME->ctx->Req.remains, 1, true);
		}
		if (pSME->ctx->Req.bCaptured)
		{
			m_CardCaptured = pSME->ctx->Req.captured;
			bC = SetCardCaptured(pSME->ctx->Req.captured);
		}
		if (pSME->ctx->Req.bIssued)
		{
			m_issuedEx[0] = pSME->ctx->Req.issued;
			bI = SetCardIssued(pSME->ctx->Req.issued, 1);
		}
		if (pSME->ctx->Req.bMixed)
		{
			m_mixedEx[0] = pSME->ctx->Req.mixed;
			bM = SetCardMixed(pSME->ctx->Req.mixed, 1);
		}
		if (bR && bC && bI && bM)
			pSME->ctx->Answer(Error_Succeed);
		else
		{
			pSME->ctx->Answer(Error_Unexpect);
		}
		Dbg("case USER_EVT_SET_MATERIAL, bRemains:%d, bCaptured:%d, bIssued:%d, bMixed:%d, bR:%d, bC:%d, bI:%d, bM:%d",
			pSME->ctx->Req.bRemains, pSME->ctx->Req.bCaptured, pSME->ctx->Req.bIssued, pSME->ctx->Req.bMixed, bR, bC, bI, bM);
		m_bSettingMaterial = false;

	}
		break;
	case USER_EVT_GET_MATERIAL_EX:
	{
		pEvt->SetHandled();
		GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
		pGMEE->ctx->Ans.captured = m_CardCaptured;
		pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
		pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
		pGMEE->ctx->Ans.remains.Init(m_hopperNum);
		pGMEE->ctx->Ans.issued.Init(m_hopperNum);
		pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
		pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
			if (m_bHasHopper[i])
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
				pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
				pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
				pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
				pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
				pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
				pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
				pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
				pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
				//to be added maintain time oiltmp
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			else
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = "";
				pGMEE->ctx->Ans.PsbCode[i] = "";
				pGMEE->ctx->Ans.PsbName[i] = "";
				pGMEE->ctx->Ans.Maintainer[i] = "";
				pGMEE->ctx->Ans.CardInit[i] = 0;
				pGMEE->ctx->Ans.CardPercent[i] = 0;
				pGMEE->ctx->Ans.remains[i] = 0;
				pGMEE->ctx->Ans.issued[i] = 0;
				pGMEE->ctx->Ans.mixed[i] = 0;
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			Dbg("GetMaterial CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
				pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
				pGMEE->ctx->Ans.PsbCode[i].GetData(),
				pGMEE->ctx->Ans.PsbName[i].GetData(),
				pGMEE->ctx->Ans.CardInit[i],
				pGMEE->ctx->Ans.remains[i],
				pGMEE->ctx->Ans.issued[i],
				pGMEE->ctx->Ans.mixed[i]);
		}
		pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
		Dbg("captured:%d, szVendor:%s", m_CardCaptured, m_devCat.szVendor);
		pGMEE->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_SET_MATERIAL_EX:
	{
		m_bSettingMaterial = true;
		pEvt->SetHandled();
		
		CSmallDateTime currTime = CSmallDateTime::GetNow();
		SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
		bool bSetCapture = false;
		if (pSMEE->ctx->Req.SetCaptured == 1)
		{
			m_CardCaptured = pSMEE->ctx->Req.captured;
			m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
			m_MaintainTimeEx[0] = (DWORD)currTime;
			bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
										 
		}
		Dbg("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
			bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0].GetData(), pSMEE->ctx->Req.SetHopper.GetCount());
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		bool bNeedToSyncData = false;
		for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
		{
			bMaintain[i] = false;
			if (pSMEE->ctx->Req.SetHopper[i] == 1)
			{
				Dbg("do %d",i);
				bMaintain[i] = true;
				bNeedToSyncData = true;
				m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
				m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
				m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
				m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
				m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
				m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
				m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
				m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
				m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
				m_MaintainTimeEx[i] = (DWORD)currTime;
				m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

				Dbg("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
					pSMEE->ctx->Req.CardBoxNo[i].GetData(),
					pSMEE->ctx->Req.PsbCode[i].GetData(),
					pSMEE->ctx->Req.PsbName[i].GetData(),
					pSMEE->ctx->Req.CardInit[i],
					pSMEE->ctx->Req.remains[i],
					pSMEE->ctx->Req.issued[i],
					pSMEE->ctx->Req.mixed[i]);
			}
		}
		pSMEE->ctx->Ans.reserved1.Init(1);
		pSMEE->ctx->Ans.reserved2.Init(1);
		pSMEE->ctx->Ans.reserved1[0] = 1;
		pSMEE->ctx->Ans.reserved2[0] = "";
		UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
		pSMEE->ctx->Answer(Error_Succeed);
		m_bSettingMaterial = false;
		if (bNeedToSyncData)
		{
			Dbg("SetMaterial, need to SyncDataToDB.");
			if (pSMEE->ctx->Req.SetCaptured == 1)
				SyncDataToDB(bMaintain);
			else
				SyncDataToDB(bMaintain, false);
		}
										 
									 
	}
		break;
	case USER_EVT_OPEN_SAFELOCK:
	{
		pEvt->SetHandled();
		OpenSafeLockEvent *osle = dynamic_cast<OpenSafeLockEvent*>(pEvt);
		OpenSafeLockTask* task = new OpenSafeLockTask(this);
		task->ctx = osle->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_BLUETOOTH_DISCONNECT:
		pEvt->SetHandled();
		ret = 0;
		break;
	case USER_EVT_QUERY_SCI_LIST:
	{
		pEvt->SetHandled();
		QuerySCIListEvent *qsl = dynamic_cast<QuerySCIListEvent*>(pEvt);
		QuerySCIListTask *pTask = new QuerySCIListTask(this);
		pTask->ctx = qsl->ctx;
		pTask->fsmState = 2;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
		break;
	case USER_EVT_BIND_SCI:
	{
		pEvt->SetHandled();
		BindSCIEvent *bsl = dynamic_cast<BindSCIEvent*>(pEvt);
		BindSCITask *pTask = new BindSCITask(this);
		pTask->ctx = bsl->ctx;
		pTask->fsmState = 2;
		ErrorCodeEnum ec = GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
		break;
	case USER_EVT_PREONLINE:
	{
		pEvt->SetHandled();
		PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
		if (poe->ctx->Req.reserved1.GetLength() > 0 && _strnicmp("kaku#", (const char*)poe->ctx->Req.reserved1, 5) == 0)
		{
			PreOnlineTask* task = new PreOnlineTask(this);
			task->ctx = poe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			ret = 16;
		}
		break;
	}
	case USER_EVT_PREONLINE_ON_STORE:
	{
		pEvt->SetHandled();
		PreOnlineOnStoreEvent *bsl = dynamic_cast<PreOnlineOnStoreEvent*>(pEvt);
		PreOnlineOnStoreTask *pTask = new PreOnlineOnStoreTask(this);
		pTask->ctx = bsl->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
		break;
	case USER_EVT_QUERYCARDINFO_ON_STORE:
	{
		pEvt->SetHandled();
		QueryCardInfoOnStoreEvent* qce = dynamic_cast<QueryCardInfoOnStoreEvent*>(pEvt);
		QueryCardInfoOnStoreTask* qTask = new QueryCardInfoOnStoreTask(this);
		qTask->ctx = qce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(qTask);
	}
	break;
	default:
		break;
	}
	return ret;
}
//Accepting
void CCardIssuerFSM::s3_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 3;
}
void CCardIssuerFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s3_on_event(FSMEvent* pEvt)
{
	Dbg("s3 evt(%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_ACCEPTFINISHED:
		{
			pEvt->SetHandled();
			switch(pEvt->param1)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
				ret = pEvt->param1;
				break;
			default:
				ret = 1;
				break;
			}
		}
		break;
	case USER_EVT_ACCEPT_CANCEL:
		m_bCancelAccept = true;
		m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		pEvt->SetHandled();
		ret = 3;
		break;
	case USER_EVT_EXIT:
		m_captureReason = "4001";
		m_bExit = true;
		pEvt->SetHandled();
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
//Hold
void CCardIssuerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 4;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_HOLD);
}
void CCardIssuerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s4_on_event(FSMEvent* pEvt)
{
	Dbg("s4 evt(%d,%d)",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt){
		case USER_EVT_READEX:
			{
				CardReadExEvent* cre = dynamic_cast<CardReadExEvent*>(pEvt);
				ReadExTask* task = new ReadExTask(this);
				task->ctx = cre->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_READ_NEW:
			{
				CardReadEvent* crne = dynamic_cast<CardReadEvent*>(pEvt);
				ReadTask* task = new ReadTask(this);
				task->ctx = crne->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_PREONLINE:
			{
				PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
				PreOnlineTask* task = new PreOnlineTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_POSTONLINE:
			{
				PostOnlineEvent* poe = dynamic_cast<PostOnlineEvent*>(pEvt);
				PostOnlineTask* task = new PostOnlineTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_CAPTURE:
			{
				CardCaptureEvent *cce = dynamic_cast<CardCaptureEvent*>(pEvt);
				CaptureTask *task=  new CaptureTask(this);
				task->ctx = cce->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				//oilyang@20171215 经与郭丹汪磊东宋锐讨论，目前不存在4022的情况，暂时以4019代替
				//m_captureReason = "4022";
				m_captureReason = "4019";
				return 0;
			}
		case USER_EVT_EXIT:
		case USER_EVT_EJECT:
		case USER_EVT_ACCEPT:
		case USER_EVT_ACCEPT_CANCEL:
			{
				if (pEvt->iEvt == USER_EVT_ACCEPT)
				{
					Dbg("call insert card in holding state.capture it");
					CardAcceptEvent *cae = dynamic_cast<CardAcceptEvent*>(pEvt);
					CaptureTask *task=  new CaptureTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					cae->ctx->Answer(Error_Duplication);
					return 0;
				}
				if ((pEvt->iEvt == USER_EVT_EXIT) && m_issueStatus)
				{				
					m_captureReason = "4001";
					CardCaptureEvent *cce = dynamic_cast<CardCaptureEvent*>(pEvt);
					CaptureTask *task=  new CaptureTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 1;
				}
				CardEjectEvent *cee;
				if (pEvt->iEvt == USER_EVT_EJECT)
					cee = dynamic_cast<CardEjectEvent*>(pEvt);
				EjectTask *task=  new EjectTask(this);
				if (pEvt->iEvt == USER_EVT_EJECT)
					task->ctx = cee->ctx;
				else
					task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_QUIT:
			{
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_GET_MATERIAL:
		{
				pEvt->SetHandled();
				GetMaterialEvent *pGME = dynamic_cast<GetMaterialEvent*>(pEvt);
				pGME->ctx->Ans.captured = m_CardCaptured;
				pGME->ctx->Ans.remains = m_remainsEx[0];
				pGME->ctx->Ans.issued = m_issuedEx[0];
				pGME->ctx->Ans.mixed = m_mixedEx[0];
				pGME->ctx->Answer(Error_Succeed);
		}
			break;
		case USER_EVT_SET_MATERIAL:
		{
				m_bSettingMaterial = true;
				pEvt->SetHandled();
				bool bR, bC, bI, bM;
				bR = bC = bI = bM = true;
				SetMaterialEvent *pSME = dynamic_cast<SetMaterialEvent*>(pEvt);
				if (pSME->ctx->Req.bRemains)
				{
					m_CardInitEx[0] = m_remainsEx[0] = pSME->ctx->Req.remains;
					bR = SetCardRemains(pSME->ctx->Req.remains, 1, true);
				}
				if (pSME->ctx->Req.bCaptured)
				{
					m_CardCaptured = pSME->ctx->Req.captured;
					bC = SetCardCaptured(pSME->ctx->Req.captured);
				}
				if (pSME->ctx->Req.bIssued)
				{
					m_issuedEx[0] = pSME->ctx->Req.issued;
					bI = SetCardIssued(pSME->ctx->Req.issued, 1);
				}
				if (pSME->ctx->Req.bMixed)
				{
					m_mixedEx[0] = pSME->ctx->Req.mixed;
					bM = SetCardMixed(pSME->ctx->Req.mixed, 1);
				}
				if (bR && bC && bI && bM)
					pSME->ctx->Answer(Error_Succeed);
				else
				{
					Dbg("set material failed.r(%d),c(%d),i(%d),m(%d)", bR, bC, bI, bM);
					pSME->ctx->Answer(Error_Unexpect);
				}
				Dbg("case USER_EVT_SET_MATERIAL, bRemains:%d, bCaptured:%d, bIssued:%d, bMixed:%d, bR:%d, bC:%d, bI:%d, bM:%d",
					pSME->ctx->Req.bRemains, pSME->ctx->Req.bCaptured, pSME->ctx->Req.bIssued, pSME->ctx->Req.bMixed, bR, bC, bI, bM);
				m_bSettingMaterial = false;
		}
			break;
		case USER_EVT_GET_MATERIAL_EX:
		{
				pEvt->SetHandled();
				GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
				pGMEE->ctx->Ans.captured = m_CardCaptured;
				pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
				pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
				pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
				pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
				pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
				pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
				pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
				pGMEE->ctx->Ans.remains.Init(m_hopperNum);
				pGMEE->ctx->Ans.issued.Init(m_hopperNum);
				pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
				pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
				pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
				pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
				for (int i = 0; i < m_hopperNum; ++i)
				{
					pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
					if (m_bHasHopper[i])
					{
						pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
						pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
						pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
						pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
						pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
						pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
						pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
						pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
						pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
						//to be added maintain time oiltmp
						pGMEE->ctx->Ans.MaintainTime[i] = "";
						pGMEE->ctx->Ans.reserved1[i] = 0;
						pGMEE->ctx->Ans.reserved2[i] = "";
					}
					else
					{
						pGMEE->ctx->Ans.CardBoxNo[i] = "";
						pGMEE->ctx->Ans.PsbCode[i] = "";
						pGMEE->ctx->Ans.PsbName[i] = "";
						pGMEE->ctx->Ans.Maintainer[i] = "";
						pGMEE->ctx->Ans.CardInit[i] = 0;
						pGMEE->ctx->Ans.CardPercent[i] = 0;
						pGMEE->ctx->Ans.remains[i] = 0;
						pGMEE->ctx->Ans.issued[i] = 0;
						pGMEE->ctx->Ans.mixed[i] = 0;
						pGMEE->ctx->Ans.MaintainTime[i] = "";
						pGMEE->ctx->Ans.reserved1[i] = 0;
						pGMEE->ctx->Ans.reserved2[i] = "";
					}
					Dbg("GetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
						pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
						pGMEE->ctx->Ans.PsbCode[i].GetData(),
						pGMEE->ctx->Ans.PsbName[i].GetData(),
						pGMEE->ctx->Ans.CardInit[i],
						pGMEE->ctx->Ans.remains[i],
						pGMEE->ctx->Ans.issued[i],
						pGMEE->ctx->Ans.mixed[i]);
				}
				pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
				pGMEE->ctx->Answer(Error_Succeed);
		}
			break;
		case USER_EVT_SET_MATERIAL_EX:
		{
			m_bSettingMaterial = true;
			pEvt->SetHandled();
			//SetCardRemains???oiltmp
			CSmallDateTime currTime = CSmallDateTime::GetNow();
			SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
			bool bSetCapture = false;

			if (pSMEE->ctx->Req.SetCaptured == 1)
			{
				m_CardCaptured = pSMEE->ctx->Req.captured;
				m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
				m_MaintainTimeEx[0] = (DWORD)currTime;
				bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
			}
			Dbg("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
				bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0].GetData(), pSMEE->ctx->Req.SetHopper.GetCount());
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			bool bNeedToSyncData = false;
			for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
			{
				bMaintain[i] = false;
				if (pSMEE->ctx->Req.SetHopper[i] == 1)
				{
					bMaintain[i] = true;
					bNeedToSyncData = true;
					m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
					m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
					m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
					m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
					m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
					m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
					m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
					m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
					m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
					m_MaintainTimeEx[i] = (DWORD)currTime;
					m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

					Dbg("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
						pSMEE->ctx->Req.CardBoxNo[i].GetData(),
						pSMEE->ctx->Req.PsbCode[i].GetData(),
						pSMEE->ctx->Req.PsbName[i].GetData(),
						pSMEE->ctx->Req.CardInit[i],
						pSMEE->ctx->Req.remains[i],
						pSMEE->ctx->Req.issued[i],
						pSMEE->ctx->Req.mixed[i]);
				}
			}
			pSMEE->ctx->Ans.reserved1.Init(1);
			pSMEE->ctx->Ans.reserved2.Init(1);
			pSMEE->ctx->Ans.reserved1[0] = 0;
			pSMEE->ctx->Ans.reserved2[0] = "";
			UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
			pSMEE->ctx->Answer(Error_Succeed);
			m_bSettingMaterial = false;
			if (bNeedToSyncData)
			{
				Dbg("SetMaterial, need to SyncDataToDB.");
				if (pSMEE->ctx->Req.SetCaptured == 1)
					SyncDataToDB(bMaintain);
				else
					SyncDataToDB(bMaintain, false);
			}
										 
		}
			break;

		case USER_EVT_WRITE:
			{
				CardWriteEvent* cwe = dynamic_cast<CardWriteEvent*>(pEvt);
				WriteTask* task = new WriteTask(this);
				task->ctx = cwe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
			}
			break;
		case USER_EVT_BLUETOOTH_DISCONNECT:
			pEvt->SetHandled();
			break;
		case USER_EVT_SAM_IC:
		{
			SAMICCommandEvent* sice = dynamic_cast<SAMICCommandEvent*>(pEvt);
			SAMICCommandTask* task = new SAMICCommandTask(this);
			task->ctx = sice->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
		}
			break;
		case USER_EVT_PRINT:
		{
							   pEvt->SetHandled();
							   PrintEvent* pe = dynamic_cast<PrintEvent*>(pEvt);
							   PrintTask* task = new PrintTask(this);
							   task->ctx = pe->ctx;
							   GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		}
			break;
		case USER_EVT_PRINT_FINISHED:
		{
										pEvt->SetHandled();
		}
			break;
		case USER_EVT_ISSUE_EX:
		{
								  IssueTask* task = new IssueTask(this);
								  CardIssueExEvent *ciee = NULL;
								  ciee = dynamic_cast<CardIssueExEvent*>(pEvt);
								  task->ctxEx = ciee->ctx;
								  task->ctx = NULL;
								  GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
								  pEvt->SetHandled();
								  return pEvt->param1;
		}
			break;
		case USER_EVT_ISSUE_EX_FINISHED:
			pEvt->SetHandled();
			return pEvt->param1;
		case USER_EVT_PRINT_CARD_IM:
		{
			pEvt->SetHandled();
			PrintCardImEvent* pcie = dynamic_cast<PrintCardImEvent*>(pEvt);
			PrintCardImTask* qTask = new PrintCardImTask(this);
			qTask->ctx = pcie->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(qTask);
		}
		break;
		default:
			break;
	}
	return 0;
}
//Reading
void CCardIssuerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 5;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_READING);
}
void CCardIssuerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s5_on_event(FSMEvent* pEvt)
{
	Dbg("s5 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_READEX_FINISHED:
		{
			pEvt->SetHandled();
			CardReadExFinishedEvent *pCRFE = dynamic_cast<CardReadExFinishedEvent *>(pEvt);
			if (pCRFE->param1 == 0)
			{
				pCRFE->ctx->Answer(Error_Succeed);
				ret = 0;
			}else if (pCRFE->param1 == 2)
				ret = 2;
			else
			{
				pCRFE->ctx->Answer(AnswerErrCode(Error_Unexpect));
				ret = 1;
			}
		}
		break;
	case USER_EVT_READ_NEW_FINISHED:
		{
			pEvt->SetHandled();
			CardReadFinishedEvent *pCRNFE = dynamic_cast<CardReadFinishedEvent *>(pEvt);
			if (pCRNFE->param1 == 0)
			{
				pCRNFE->ctx->Answer(Error_Succeed);
				return 0;
			}
			else if (pCRNFE->param1 == 2)
			{
				pCRNFE->ctx->Answer(AnswerErrCode(Error_Unexpect));
				ret = 2;
			}
			else
			{
				SetErrPackage(m_errPkg, "Read finished", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus);
				pCRNFE->ctx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
				return 1;
			}
		}
		break;
	case USER_EVT_EXIT:
		{
			pEvt->SetHandled();
			m_captureReason = "4001";
		}
		break;
	case USER_EVT_QUIT:
		{
			pEvt->SetHandled();
			return 0;
		}
	default:
		break;
	}
	return 0;
}
//Ejecting
void CCardIssuerFSM::s6_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 6;
}
void CCardIssuerFSM::s6_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s6_on_event(FSMEvent* pEvt)
{
	Dbg("s6 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	if (pEvt->iEvt == USER_EVT_EJECTFINISHED){
		pEvt->SetHandled();
		int err = pEvt->param1;
		if (err == 0)
			return 0;
		else
			return 1;
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	return 0;
}
//Waiting fetch
void CCardIssuerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 7;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_WAITFETCHING);
	WaitFetchingTask* task = new WaitFetchingTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}
void CCardIssuerFSM::s7_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s7_on_event(FSMEvent* pEvt)
{
	Dbg("s7 evt (%d, %d)", pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
	case USER_EVT_WAITFINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			FetchCard evt;
			evt.status = 0;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
			m_currCardNo = "";
			Dbg("客户取走卡片msg发送");
			return 0;
		}
		else if (pEvt->param1 == 1) {
			FetchCard evt;
			evt.status = 1;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			Dbg("取卡时设备故障");
			return 1;
		}
		else {
			FetchCard evt;
			evt.status = 2;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			Dbg("客户未取卡超时msg发送");
			m_captureReason = "4019";
			LogWarn(Severity_Low, Error_NotInit, CardIssuer_UserErrorCode_Customer_Forget_Fectch_Card, "Customer forget fetch card.");
			CaptureTask* task = new CaptureTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_GET_MATERIAL:
	{
		pEvt->SetHandled();
		Dbg("captured:%d, remains:%d, issued:%d, mixed:%d",
			m_CardCaptured, m_remainsEx[0], m_issuedEx[0], m_mixedEx[0]);
		GetMaterialEvent* pGME = dynamic_cast<GetMaterialEvent*>(pEvt);
		pGME->ctx->Ans.captured = m_CardCaptured;
		pGME->ctx->Ans.remains = m_remainsEx[0];
		pGME->ctx->Ans.issued = m_issuedEx[0];
		pGME->ctx->Ans.mixed = m_mixedEx[0];
		pGME->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_GET_MATERIAL_EX:
	{
		pEvt->SetHandled();
		GetMaterialExEvent *pGMEE = dynamic_cast<GetMaterialExEvent*>(pEvt);
		pGMEE->ctx->Ans.captured = m_CardCaptured;
		pGMEE->ctx->Ans.hasHopper.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardBoxNo.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbCode.Init(m_hopperNum);
		pGMEE->ctx->Ans.PsbName.Init(m_hopperNum);
		pGMEE->ctx->Ans.Maintainer.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardInit.Init(m_hopperNum);
		pGMEE->ctx->Ans.CardPercent.Init(m_hopperNum);
		pGMEE->ctx->Ans.remains.Init(m_hopperNum);
		pGMEE->ctx->Ans.issued.Init(m_hopperNum);
		pGMEE->ctx->Ans.mixed.Init(m_hopperNum);
		pGMEE->ctx->Ans.MaintainTime.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved1.Init(m_hopperNum);
		pGMEE->ctx->Ans.reserved2.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			pGMEE->ctx->Ans.hasHopper[i] = m_bHasHopper[i];
			if (m_bHasHopper[i])
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = m_CardBoxNoEx[i];
				pGMEE->ctx->Ans.PsbCode[i] = m_PsbCodeEx[i];
				pGMEE->ctx->Ans.PsbName[i] = m_PsbNameEx[i];
				pGMEE->ctx->Ans.Maintainer[i] = m_MaintainerEx[i];
				pGMEE->ctx->Ans.CardInit[i] = m_CardInitEx[i];
				pGMEE->ctx->Ans.CardPercent[i] = m_CardPercentEx[i];
				pGMEE->ctx->Ans.remains[i] = m_remainsEx[i];
				pGMEE->ctx->Ans.issued[i] = m_issuedEx[i];
				pGMEE->ctx->Ans.mixed[i] = m_mixedEx[i];
				//to be added maintain time oiltmp
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			else
			{
				pGMEE->ctx->Ans.CardBoxNo[i] = "";
				pGMEE->ctx->Ans.PsbCode[i] = "";
				pGMEE->ctx->Ans.PsbName[i] = "";
				pGMEE->ctx->Ans.Maintainer[i] = "";
				pGMEE->ctx->Ans.CardInit[i] = 0;
				pGMEE->ctx->Ans.CardPercent[i] = 0;
				pGMEE->ctx->Ans.remains[i] = 0;
				pGMEE->ctx->Ans.issued[i] = 0;
				pGMEE->ctx->Ans.mixed[i] = 0;
				pGMEE->ctx->Ans.MaintainTime[i] = "";
				pGMEE->ctx->Ans.reserved1[i] = 0;
				pGMEE->ctx->Ans.reserved2[i] = "";
			}
			Dbg("GetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
				pGMEE->ctx->Ans.CardBoxNo[i].GetData(),
				pGMEE->ctx->Ans.PsbCode[i].GetData(),
				pGMEE->ctx->Ans.PsbName[i].GetData(),
				pGMEE->ctx->Ans.CardInit[i],
				pGMEE->ctx->Ans.remains[i],
				pGMEE->ctx->Ans.issued[i],
				pGMEE->ctx->Ans.mixed[i]);
		}
		pGMEE->ctx->Ans.reserved2[0] = m_devCat.szVendor;
		Dbg("captured:%d, szVendor:%s", m_CardCaptured, m_devCat.szVendor);
		pGMEE->ctx->Answer(Error_Succeed);
	}
		break;
	case USER_EVT_SET_MATERIAL_EX:
	{
		m_bSettingMaterial = true;
		pEvt->SetHandled();
		//SetCardRemains???oiltmp
		CSmallDateTime currTime = CSmallDateTime::GetNow();
		SetMaterialExEvent *pSMEE = dynamic_cast<SetMaterialExEvent*>(pEvt);
		bool bSetCapture = false;
		if (pSMEE->ctx->Req.SetCaptured == 1)
		{
			m_CardCaptured = pSMEE->ctx->Req.captured;
			m_MaintainerEx[0] = pSMEE->ctx->Req.Maintainer[0];
			m_MaintainTimeEx[0] = (DWORD)currTime;
			bSetCapture = SetCardCaptured(pSMEE->ctx->Req.captured,true);
		}
		Dbg("bSetCapture:%d, Req.SetCaptured:%d, Req.captured:%d, Req.Maintainer[0]:%s, Req.SetHopper.GetCount:%d",
			bSetCapture, pSMEE->ctx->Req.SetCaptured, pSMEE->ctx->Req.captured, pSMEE->ctx->Req.Maintainer[0], pSMEE->ctx->Req.SetHopper.GetCount());
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		bool bNeedToSyncData = false;
		for (int i = 0; i < pSMEE->ctx->Req.SetHopper.GetCount(); ++i)
		{
			bMaintain[i] = false;
			if (pSMEE->ctx->Req.SetHopper[i] == 1)
			{
				bMaintain[i] = true;
				bNeedToSyncData = true;
				m_CardBoxNoEx[i] = pSMEE->ctx->Req.CardBoxNo[i];
				m_PsbCodeEx[i] = pSMEE->ctx->Req.PsbCode[i];
				m_PsbNameEx[i] = pSMEE->ctx->Req.PsbName[i];
				m_MaintainerEx[i] = pSMEE->ctx->Req.Maintainer[i];
				m_CardInitEx[i] = pSMEE->ctx->Req.CardInit[i];
				m_CardPercentEx[i] = pSMEE->ctx->Req.CardPercent[i];
				m_remainsEx[i] = pSMEE->ctx->Req.remains[i];
				m_issuedEx[i] = pSMEE->ctx->Req.issued[i];
				m_mixedEx[i] = pSMEE->ctx->Req.mixed[i];
				m_MaintainTimeEx[i] = (DWORD)currTime;
				m_csMaintainTimeEx[i] = currTime.GetNow().ToTimeString();

				Dbg("SetMaterial, CardBoxNo:%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",
					pSMEE->ctx->Req.CardBoxNo[i].GetData(),
					pSMEE->ctx->Req.PsbCode[i].GetData(),
					pSMEE->ctx->Req.PsbName[i].GetData(),
					pSMEE->ctx->Req.CardInit[i],
					pSMEE->ctx->Req.remains[i],
					pSMEE->ctx->Req.issued[i],
					pSMEE->ctx->Req.mixed[i]);
			}
		}
		pSMEE->ctx->Ans.reserved1.Init(1);
		pSMEE->ctx->Ans.reserved2.Init(1);
		pSMEE->ctx->Ans.reserved1[0] = 0;
		pSMEE->ctx->Ans.reserved2[0] = "";
		UpdateLocalRunCfg(pSMEE->ctx->Req.SetHopper);
		pSMEE->ctx->Answer(Error_Succeed);
		m_bSettingMaterial = false;
		if (bNeedToSyncData)
		{
			Dbg("SetMaterial, need to SyncDataToDB.");
			if (pSMEE->ctx->Req.SetCaptured == 1)
				SyncDataToDB(bMaintain);
			else
				SyncDataToDB(bMaintain, false);
		}				 
	}
		break;

	default:
		break;
	}
	return 0;
}
void CCardIssuerFSM::s8_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 8;
}
void CCardIssuerFSM::s8_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s8_on_event(FSMEvent* pEvt)
{
	Dbg("s8 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	if (pEvt->iEvt == USER_EVT_CAPTUREFINISHED){
		pEvt->SetHandled();
		int err = pEvt->param1;
		if (err == 0)
			return 0;
		else
			return 1;
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	return 0;
}
//Failed
void CCardIssuerFSM::s9_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 9;
	Dbg("CardIssuer in fault state, need to reset.");
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_FAILED);
	SetDevStateAndSendMsg(DEVICE_STATUS_FAULT);
	FSMEvent *e = new FSMEvent(USER_EVT_RESET);
	PostEventFIFO(e);
}
void CCardIssuerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s9_on_event(FSMEvent* pEvt)
{
	Dbg("s9 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_RESET:
		{
			pEvt->SetHandled();
			m_resetTimes++;
			if (_strnicmp("RVC.Stand2S", m_csMachineType, strlen("RVC.Stand2S")) == 0 && m_resetTimes > MAX_RESET_TIMES_PERIOD)
			{
				Dbg("restart tried %d times,give up",m_resetTimes);
				m_testResult = Error_InvalidState;
				return 0;
			}
			ResetDeviceEvent* rde = dynamic_cast<ResetDeviceEvent*>(pEvt);
			ResetTask* task = new ResetTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);

			return 0;
		}
		break;
	case USER_EVT_RESETFINISHED:
		{
			ResetFinishedEvent *rfe = dynamic_cast<ResetFinishedEvent*>(pEvt);
			Dbg("reset finished, result:%d", rfe->param1);
			if (rfe->param1 == 0)
				return 0;
			else
			{
				m_testResult = Error_InvalidState;
				return 1;
			}
				
		}
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		return 0;
	case USER_EVT_ACCEPT_CANCEL:
		m_bCancelAccept = true;
		pEvt->SetHandled();
		break;
	case USER_EVT_BLUETOOTH_DISCONNECT:
		pEvt->SetHandled();
		return 0;
		break;
	default:
		break;
	}

	return 0;
}
//Issuing
void CCardIssuerFSM::s10_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 10;
}
void CCardIssuerFSM::s10_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s10_on_event(FSMEvent* pEvt)
{
	Dbg("s10 evt(%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_ISSUE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_ISSUE_EX_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bIssuingExit = true;
		break;
	case USER_EVT_ACCEPT_CANCEL:
		pEvt->SetHandled();
		m_bForHangzhouSongruiMenjinka = true;
		break;
	default:
		break;
	}
	return ret;
}
//Writing
void CCardIssuerFSM::s11_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 11;
}
void CCardIssuerFSM::s11_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s11_on_event(FSMEvent* pEvt)
{
	Dbg("s11(writing) evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_WRITE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bIssuingExit = true;
		break;
	default:
		break;
	}
	return ret;
}
//Connecting
void CCardIssuerFSM::s12_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 12;
	SetDevStateAndSendMsg(DEVICE_STATUS_CONNECTING, false);
	if (!m_bBTConnected && !m_bBTConncting)
	{
		ConnectTask *task = new ConnectTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	else {
		Dbg("do nothing to connect sci: btconnected: %d, btconnecting: %d", m_bBTConnected, m_bBTConncting);
	}
}
void CCardIssuerFSM::s12_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s12_on_event(FSMEvent* pEvt)
{
	Dbg("s12 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_CONNECT_FINISHED:
	{
		pEvt->SetHandled();
		if (QueryIfCfgSCI() == 0)//if remove bind relation
		{
			FSMEvent *e = new FSMEvent(USER_EVT_BACK_TO_INIT);
			PostEventFIFO(e);
			ret = 2;
		}
		else
		{
			if (pEvt->param1 != 0)
			{
				m_scanCount++;
				if (m_scanCount > 4)
				{
					SetDevStateAndSendMsg(DEVICE_STATUS_CONNECTING);
					m_scanCount = 0;
				}
				PeirodConnectTask *task = new PeirodConnectTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				ret = 1;
			}
		}
	}
	break;
	case USER_EVT_QUERY_SCI_LIST:
	{
		pEvt->SetHandled();
		QuerySCIListEvent *qsl = dynamic_cast<QuerySCIListEvent*>(pEvt);
		QuerySCIListTask *pTask = new QuerySCIListTask(this);
		pTask->ctx = qsl->ctx;
		pTask->fsmState = 12;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
	break;
	case USER_EVT_BIND_SCI:
	{
		pEvt->SetHandled();
		BindSCIEvent *bsl = dynamic_cast<BindSCIEvent*>(pEvt);
		BindSCITask *pTask = new BindSCITask(this);
		pTask->ctx = bsl->ctx;
		pTask->fsmState = 12;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
	case USER_EVT_BACK_TO_INIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
//NoCfgDev
void CCardIssuerFSM::s13_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 13;
	SetDevStateAndSendMsg(DEVICE_STATUS_NOCFG);
}
void CCardIssuerFSM::s13_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s13_on_event(FSMEvent* pEvt)
{
	Dbg("s13 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
		case USER_EVT_CONNECT:
		{
			m_scanCount = 0;
			PeirodConnectTask *task = new PeirodConnectTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		}
		break;
		case USER_EVT_QUERY_SCI_LIST:
		{
			pEvt->SetHandled();
			QuerySCIListEvent *qsl = dynamic_cast<QuerySCIListEvent*>(pEvt);
			QuerySCIListTask *pTask = new QuerySCIListTask(this);
			pTask->ctx = qsl->ctx;
			pTask->fsmState = 13;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
			break;
		case USER_EVT_BIND_SCI:
		{
			pEvt->SetHandled();
			BindSCIEvent *bsl = dynamic_cast<BindSCIEvent*>(pEvt);
			BindSCITask *pTask = new BindSCITask(this);
			pTask->ctx = bsl->ctx;
			pTask->fsmState = 13;
			ErrorCodeEnum ec = GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
			break;
		case USER_EVT_PREONLINE_ON_STORE:
		{
			pEvt->SetHandled();
			PreOnlineOnStoreEvent *bsl = dynamic_cast<PreOnlineOnStoreEvent*>(pEvt);
			PreOnlineOnStoreTask *pTask = new PreOnlineOnStoreTask(this);
			pTask->ctx = bsl->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
			break;
		default:
			break;
	}
	return ret;
}
//SAMIC
void CCardIssuerFSM::s14_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 14;
}
void CCardIssuerFSM::s14_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s14_on_event(FSMEvent* pEvt)
{
	Dbg("s14 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_SAM_IC_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
//Other
void CCardIssuerFSM::s15_on_entry()
{
	m_currentFSMState = 15;
}
void CCardIssuerFSM::s15_on_exit()
{

}
unsigned int CCardIssuerFSM::s15_on_event(FSMEvent* pEvt)
{
	Dbg("s15 %d,%d",pEvt->iEvt,pEvt->param1);
	switch (pEvt->iEvt)
	{
		case USER_EVT_QUERY_SCI_LIST_FINISHED:
		{
			pEvt->SetHandled();
			return pEvt->param1;
		}
		break;
		case USER_EVT_BIND_SCI_FINISHED:
		{
			pEvt->SetHandled();
			return pEvt->param1;
		}
		break;
		default:
			break;
	}
	return 0;
}
//PreOnlineOnStore
void CCardIssuerFSM::s16_on_entry()
{
	m_currentFSMState = 16;
}
void CCardIssuerFSM::s16_on_exit()
{
}
unsigned int CCardIssuerFSM::s16_on_event(FSMEvent* pEvt)
{
	Dbg("s16 evt %d,%d", pEvt->iEvt, pEvt->param1);
	switch (pEvt->iEvt)
	{
		case USER_EVT_PREONLINE_ON_STORE_FINISHED:
		{
			pEvt->SetHandled();
			return pEvt->param1;
		}
			break;
		default:
			break;
	}
	return 0;
}

void CCardIssuerFSM::s17_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 17;
}
void CCardIssuerFSM::s17_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s17_on_event(FSMEvent* pEvt)
{
	Dbg("s17 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	default:
		break;
	}
	return ret;
}
//PrintCardIm
void CCardIssuerFSM::s18_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 18;
}
void CCardIssuerFSM::s18_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s18_on_event(FSMEvent* pEvt)
{
	Dbg("s18 evt (%d,%d)", pEvt->iEvt, pEvt->param1);

	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_PRINT_CARD_IM_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
ErrorCodeEnum CCardIssuerFSM::OnInit()
{
	LOG_FUNCTION();
	GET_DEV_ENTITY_BASE_POINTER()->InitializeVendorLogSwitch();

#ifdef TWINKLE_LOCAL_DEBUG
	LOG_CARDISSUER_ERROR_MSG_MACRO(Error_Unexpect, QuerySlotsStatus);
#endif

	//MessageBoxA(0, 0, 0, 0);
	m_pCardProcess = new CCardProcess();
	if (m_pCardProcess == NULL)//almost no use...
	{
		Dbg("create card process failed.");
		return Error_Resource;
	}
	Load();
	CSystemStaticInfo sysInfo;
	//oilyang 20160331
	//so many function always return Error_Succeed,so is useless to process it.
	m_csMachineType = m_csSite = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_terminalNo = sysInfo.strTerminalID;
	m_majorVerion = sysInfo.MachineVersion.GetMajor();
	m_minorVerion = sysInfo.MachineVersion.GetMinor();
	Dbg("CardIssuer, MachineType:%s, Site:%s, TerminalNo:%s, MachineVersion:%d.%d",
		m_csMachineType.GetData(), m_csSite.GetData(), m_terminalNo.GetData(), m_majorVerion, m_minorVerion);
	m_devStatus.eMedia = CI_MEDIA_NOTPRESENT;
	m_bHasHopper[0] = false;
	m_bHasHopper[1] = false;
	m_bHasHopper[2] = false;
	InitializeCriticalSectionAndSpinCount(&g_sciRecord, 100);
	return Error_Succeed;
}
ErrorCodeEnum CCardIssuerFSM::OnExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum eExit;
	if (m_hDevHelper != NULL)
	{
		eExit = m_hDevHelper->GetDevStatus(m_devStatus);
		Dbg("OnExit, m_devStatus.eMedia:%d, m_issueStatus:%d", m_devStatus.eMedia, m_issueStatus);

		if (eExit == Error_Succeed)
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT){
				if (m_issueStatus)
				{
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "OnExit, issue flag is 1, to capture card");
					eExit = MachineMoveCardBackNotHold();
					if (eExit != Error_Succeed) {
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Capture_Failed, "OnExit::MachineMoveCardBackNotHold, capture card failed.");
					}
					m_CardCaptured++;
					SetCardCaptured(m_CardCaptured);
				}
				else
				{
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard, "OnExit, issue flag is 0, to eject card");
					eExit = MachineMoveCardFrontGate();
					if (eExit != Error_Succeed) {
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_Failed, "OnExit::MachineMoveCardFrontGate, eject card failed.");
					}
				}
			}
		}
		eExit = m_hDevHelper->DevClose();
		if (eExit == Error_Succeed)
			Dbg("OnExit,读卡器关闭成功");
		else
			Dbg("OnExit,读卡器关闭失败(%d)",eExit);
	}
	FSMImpl<CCardIssuerFSM>::OnExit();
	return Error_Succeed;
}


void TestShowRecvData(PBYTE hexBuf,DWORD len)
{
	char* show = new char[MAX_TEST_SHOW];
	ZeroMemory(show,MAX_TEST_SHOW);
	HexBuf2StrBuf(hexBuf,&show,len);
	delete[] show;
}

int FindHexCharPosition(LPBYTE data, BYTE hexChar, int len)
{
	int notExist = -1,ret = 1,pos = 0;
	for (; pos < len; ++pos)
	{

		BYTE high = (*(data+pos))&0xf0;
		BYTE low = (*(data+pos))&0x0f;

		if ((high>>4) != hexChar)
			ret++;
		else
			return ret;

		if (low != hexChar)
			ret++;
		else
			return ret;
	}
	ret = notExist;
	return ret;
}


bool CCardIssuerFSM::GetDevStatus()
{
	//LOG_FUNCTION();
	int getDevInfoCount = 0;
	static unsigned int lightStatus = 0;
	ErrorCodeEnum err;
	do{
		err = m_hDevHelper->GetDevStatus(m_devStatus);
		Dbg("GetDevStatus, GetDevStatus::eMedia: %d", m_devStatus.eMedia);

		if (Error_Succeed == err) 
		{
			if (_strnicmp("RVC.CardPrinter", m_csMachineType, strlen("RVC.CardPrinter")) == 0)
				Dbg("kaku tape(flat%d,concave:%d,gold:%d,silver:%d", m_devStatus.eKakuTape[0]
					, m_devStatus.eKakuTape[1], m_devStatus.eKakuTape[2], m_devStatus.eKakuTape[3]);
			return true;
		}
		else
		{
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			Dbg("GetDevStatus errMsg:%s", devErrInfo.szErrMsg);
			getDevInfoCount++;
			Sleep(3000);
		}
	} while (getDevInfoCount < GET_DEV_STATUS_COUNT);
	return false;
}
int CCardIssuerFSM::Reset()
{
	LOG_FUNCTION();
	if (m_hDevHelper == NULL)
	{
		Dbg("Maybe the m_hDevHelper have been released,switch to s0 to restart.");
		return 2;
	}
	ErrorCodeEnum ec = m_hDevHelper->Reset();
	if (ec == Error_Succeed)
	{
		if(GetDevStatus())
		{
			Dbg("m_issueStatus: %d, m_CardCaptured:%d, m_devStatus.eMedia:%d, in Reset.",
				m_issueStatus, m_CardCaptured, m_devStatus.eMedia);
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT || m_devStatus.eMedia == CI_MEDIA_ENTERING)
			{
				ErrorCodeEnum eMoveErr;
				if (m_issueStatus)
				{
					//oiltmp to add 20131212
					eMoveErr = MachineMoveCardBackNotHold();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "issue flag is 1, to capture card.");
					if (eMoveErr != Error_Succeed)
					{
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Capture_Failed, "Reset, capture card failed.");
					}
					m_CardCaptured++;
					if (!SetCardCaptured(m_CardCaptured))
						Dbg("set card captured failed.");
				}
				else
				{
					//oiltmp to add 20131212
					eMoveErr = MachineMoveCardFrontGate();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard, "issue flag is 0, to eject card.");
					if (eMoveErr != Error_Succeed)
					{
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_Failed, "Reset, eject card failed.");
					}
				}
				if (eMoveErr == Error_Succeed)
				{
					return 0;
				}
			}
			else if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT) {
				return 0;
			}
			else
			{
				Dbg("media position %d", m_devStatus.eMedia);
				return 1;
			}
		}
		else
		{
			return 1;
		}
	}
	else {
		SetErrPackage(m_errPkg, "Reset::Reset", m_csDevSN, ec, MEC_DEVAPI_CARDISSUER_Reset);
		AlarmDEC(m_errPkg);
		return 1;
	}
	return 0;
}
bool isnostr(const char *str)
{
	int len = strlen(str);
	if (len == 0)
		return true;
	for (int i = 0; i < len; ++i)
	{
		if (*(str+i) != ' ')
			return false;
	}
	return true;
}
bool CCardIssuerFSM::LoadCMBPrint(CSimpleStringA csBinPath)
{
	if (cmdDecodeEx == NULL) {
		CSimpleStringA csCMBPrint("");
#ifdef RVC_OS_LINUX
		csCMBPrint = "libCMBPrint.so";
		csCMBPrint = csBinPath + "/" + csCMBPrint;
		Dbg("cmbpath %s", (const char*)csCMBPrint);
		void* hr = NULL;
		hr = dlopen(csCMBPrint, RTLD_LAZY);
		if (hr == NULL)
		{
			Dbg("Load CMBPrint failed(%s).", dlerror());
			return false;
		}
		//pfunc_unpack = (PF_unpack)dlsym(hLib, "_Z6unpackPcS_i");
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)dlsym(hr, "CMBdecodeMag2")) == NULL)
		{
			Dbg("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)dlsym(hr, "CMBdecodeEx")) == NULL)
		{
			Dbg("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#else
		csCMBPrint = "CMBPrint.dll";
		csCMBPrint = csBinPath + SPLIT_SLASH_STR + csCMBPrint;
		Dbg("cmbpath %s", (const char*)csCMBPrint);
		HMODULE hr = LoadLibraryA(csCMBPrint);
		if (hr == NULL)
		{
			Dbg("Load CMBPrint failed(%d).", hr);
			return false;
		}
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)GetProcAddress(hr, "CMBdecodeMag2")) == NULL)
		{
			Dbg("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)GetProcAddress(hr, "CMBdecodeEx")) == NULL)
		{
			Dbg("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#endif
		Dbg("Load %s suc.", (const char*)csCMBPrint);
	}
	
	return true;
}
ErrorCodeEnum CCardIssuerFSM::OpenDevice(BYTE btOpenType, const char *pDevSN)
{
	LOG_FUNCTION();

	m_devOpenFailedCount++;
	
	int initTries = 0;
	ErrorCodeEnum eErrDev;
	CSimpleString errMsg(true);
	CSimpleStringA dllName;
	GetVendorDllName(dllName);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_RootInfo, dllName.GetData());

	eErrDev = m_hDevHelper.LoadUp(dllName);
	m_adapterInfo.adapterFileName = dllName;

	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;

	CSimpleStringA csBinPath, csBackslash("\\");
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed)
	{
		Dbg("GetBasePath failed (%d).", eErrPath);
		return Error_Param;
	}
	for (int i = 0; i < HOPPER_NUM; ++i)
	{
		m_CardBoxNoEx[i] = "";
		m_PsbCodeEx[i] = "";
		m_PsbNameEx[i] = "";
		m_MaintainerEx[i] = "";
		m_CardInitEx[i] = 0;
		m_CardPercentEx[i] = 0;
		m_remainsEx[i] = 0;
		m_issuedEx[i] = 0;
		m_mixedEx[i] = 0;
		m_csMaintainTimeEx[i] = "";
		m_MaintainTimeEx[i] = 0;
	}
	
	do{
		if(m_bUnbindType3) {
			Dbg("Detect unbind type is true, return previously");
			return Error_Cancel;
		}
		Dbg("Start to invoke DevOpenEx func with %d, %d, %s...", m_port, m_baudRate, pDevSN);
		eErrDev = m_hDevHelper->DevOpenEx(m_port, m_baudRate, btOpenType, pDevSN, m_connectType);
		Dbg("DevOpenEx returned hr[%d], %d, connectType[%d]", eErrDev, btOpenType, m_connectType);
		if (eErrDev == Error_Succeed)
		{
			m_bOpened = true;
			m_devOpenFailedCount = 0;
			//DevCategoryInfo devCat;
			ZeroMemory(m_devCat.szModel, sizeof(m_devCat.szModel));
			ZeroMemory(m_devCat.szType, sizeof(m_devCat.szType));
			ZeroMemory(m_devCat.szVendor, sizeof(m_devCat.szVendor));
			eErrDev = m_hDevHelper->GetDevCategory(m_devCat);
			if (eErrDev == Error_Succeed)
			{
				CSimpleStringA tmpVersion = CSimpleStringA::Format("%d.%d.%d.%d", m_devCat.version.wMajor, m_devCat.version.wMinor, m_devCat.version.wRevision, m_devCat.version.wBuild);
				int ret = SplitDevModelInfo();
				Dbg("OpenDevice, szVendor:%s, szType:%s, szModel:%s, version:%s, ret:%d",
						m_devCat.szVendor, m_devCat.szType, m_devCat.szVendor, tmpVersion.GetData(), ret);
				m_adapterInfo.devCatInfo = m_devCat;
				Dbg("m_adapterInfo:%s,%s,%s", m_adapterInfo.devCatInfo.szModel, m_adapterInfo.devCatInfo.szType);
			}
			else
			{
				SetErrPackage(m_errPkg, "OpenDevice::GetDevCategory", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetDevCategory);
				AlarmDEC(m_errPkg);
				Dbg("CardIssuer启动失败(GetDevCategory failed.)");
				return Error_Unexpect;
			}
			if (m_csMachineType.Compare("RVC.CardStore") == 0
				|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
			{
				eErrDev = m_hDevHelper->GetSlotSum(m_maxSlot);
				errMsg = CSimpleStringA::Format("max slot num:%d", m_maxSlot);
				LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardStore_SlotNum, errMsg.GetData());

				m_maxSlot = (m_maxSlot < 0) ? 0 : m_maxSlot;
			}
			else
			{
				char *pDevSN = new char[128];
				ZeroMemory(pDevSN, 128);
				ErrorCodeEnum eErr;
				eErr = m_hDevHelper->GetDeviceSN(pDevSN);
				if (eErr == Error_Succeed)
				{
					//m_csDevSN only for SCI/CIA (bluetooth)
					if (IsValidSCIName(pDevSN, strlen(pDevSN)) > 0)
						m_csDevSN = pDevSN;
					Dbg("OpenDevice, pDevSN：%s", pDevSN);
				}
				else
				{
					SetErrPackage(m_errPkg, "获取设备唯一号失败", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetDeviceSN);
					AlarmDEC(m_errPkg);
				}
				if (pDevSN != NULL)
					delete[]pDevSN;
				if (eErrDev != Error_Succeed) {
					Dbg("CardIssuer启动失败(GetDeviceSN failed.)");
					return Error_Unexpect;
				}
			}
			if (!LoadCMBPrint(csBinPath))
			{
				errMsg = CSimpleStringA::Format("CardIssuer启动失败:Load CMBPrint failed.");
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_LoadLibraryA_CMBPrint_Failed, errMsg.GetData());
				return Error_DevLoadFileFailed;
			}
			initTries = 0;
			break;
		}
		else {
			SetErrPackage(m_errPkg, "OpenDevice::DevOpenEx", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_DevOpenEx);
			AlarmDEC(m_errPkg);
			Dbg("CardIssuer启动失败:DevOpenEx failed.重试:%d", initTries);
			initTries++;
		}
	}while(initTries < INIT_TRY_NUM);
	Dbg("inittries[%d]",initTries);
	if (initTries != 0)
	{
		return Error_DevCommFailed;
	}
	else
	{
		LoadCMBBin();//load cmb bin for detect card type info
		eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
		if (eErrDev != Error_Succeed) {
			Dbg("CardIssuer启动失败:open run cfg file failed in OpenDevice.");
			CloseAndClearDevObj(false);
			return eErrDev;
		}
		int ret = 0,isIssue = 99;
		spConfig->ReadConfigValueInt("all", "IsIssue", isIssue);
		spConfig->ReadConfigValueInt("all", "HopperNum", m_hopperNum);
		spConfig->ReadConfigValueInt("all", "CardCaptured", m_CardCaptured);
		if (btOpenType == DEV_OPEN_TYPE_COM)
		{
			//oiltest@20201118 for songrui 
			if (m_csMachineType.Compare("RVC.CardPrinter") == 0)
				m_hopperNum = 5;
			else
			{
				if (m_connectType >= 1 && m_connectType <= 3)
					m_hopperNum = m_connectType;
				else
				{
					//oiltmp if "RVC.CardPrinter" the m_hopperNum is 6,where can this num come from?
					if (m_csMachineType.Compare("RVC.CardPrinter") == 0)
						m_hopperNum = 5;
					else
						m_hopperNum = 3;
				}
			}
			for (int i = 0; i < m_hopperNum; ++i)
				m_bHasHopper[i] = true;
		}
		else
		{
			if (IsValidSCIName(pDevSN, strlen(pDevSN)) == 2) {
				m_hopperNum = 1;
				m_bHasHopper[0] = true;
			}
			else {
				//oiltmp 便携发卡目前都为2个
				m_hopperNum = 2;
				m_bHasHopper[0] = true;
				m_bHasHopper[1] = true;
			}
		}
		Dbg("has %d hopper.", m_hopperNum);
		char sec[2];
		for (int i = 0; i < m_hopperNum; ++i)
		{
			ZeroMemory(sec, 2);
			_itoa(i + 1, (char*)sec, 10);
			Dbg("sec:%s",sec);
			spConfig->ReadConfigValue(sec, "CardBoxNo", m_CardBoxNoEx[i]);
			spConfig->ReadConfigValue(sec, "PsbCode", m_PsbCodeEx[i]);
			spConfig->ReadConfigValue(sec, "PsbName", m_PsbNameEx[i]);
			spConfig->ReadConfigValueInt(sec, "CardInit", m_CardInitEx[i]);
			spConfig->ReadConfigValueInt(sec, "CardRemains", m_remainsEx[i]);
			spConfig->ReadConfigValueInt(sec, "CardIssued", m_issuedEx[i]);
			spConfig->ReadConfigValueInt(sec, "CardMixed", m_mixedEx[i]);
			spConfig->ReadConfigValueInt(sec, "CardPercent", m_CardPercentEx[i]);
			spConfig->ReadConfigValue(sec, "Maintainer", m_MaintainerEx[i]);
			spConfig->ReadConfigValue(sec, "MaintainTime", m_csMaintainTimeEx[i]);
			Dbg("init cardbox, CardBoxNo:%s, PsbCodeEx:%s, PsbNameEx:%s, CardInit:%d, CardRemains:%d, CardIssued:%d, CardMixed:%d",
				m_CardBoxNoEx[i].GetData(),
				m_PsbCodeEx[i].GetData(),
				m_PsbNameEx[i].GetData(),
				m_CardInitEx[i],
				m_remainsEx[i],
				m_issuedEx[i],
				m_mixedEx[i]);
		}
		if (m_hopperNum == 1 && btOpenType == DEV_OPEN_TYPE_COM)//oilyang 如果没有配置，使用原来的配置
		{
			Dbg("use old record.");
			spConfig->ReadConfigValueInt("RunInfo", "CardRemains", m_remainsEx[0]);
			spConfig->ReadConfigValueInt("RunInfo", "CardIssued", m_issuedEx[0]);
			spConfig->ReadConfigValueInt("RunInfo", "CardCaptured", m_CardCaptured);
			spConfig->ReadConfigValueInt("RunInfo", "IsIssue", isIssue);
			spConfig->ReadConfigValueInt("RunInfo", "CardMixed", m_mixedEx[0]);
			spConfig->ReadConfigValueInt("RunInfo", "CardInit", m_CardInitEx[0]);
			spConfig->ReadConfigValueInt("RunInfo", "CardPercent", m_CardPercentEx[0]);
			Dbg("use old record, CardRemains:%d, CardIssued:%d, CardCaptured:%d, IsIssue:%d, CardMixed:%d, CardInit:%d",
				m_remainsEx[0], m_issuedEx[0], m_CardCaptured, isIssue, m_mixedEx[0], m_CardInitEx[0]);
		}
		//oilyang 回写卡机配置
		spConfig->WriteConfigValueInt("all", "IsIssue", isIssue);
		spConfig->WriteConfigValueInt("all", "HopperNum", m_hopperNum);
		spConfig->WriteConfigValueInt("1", "CardPercent", m_CardPercentEx[0]);
		spEntityFunction->OpenConfig(Config_CenterSetting, spConfig);
		{
			int tmpValue = 0;
			//oilyang 20160520
			//no need now according to Song Rui & xkm
			m_bCaptureCfgFlag = true;

			spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "ScanSlot", tmpValue);
			Dbg("ScanSlot:%d, tmpValue:%d", m_scanSlot, tmpValue);
			if (tmpValue > 0 && tmpValue <= 60)
			{
				m_scanSlot = tmpValue;
			}
		}
		{
			if (btOpenType != DEV_OPEN_TYPE_COM)
			{
				int rt = -1;
				//oilyang@20201126 comment the following line for nantian sci
				//if (m_csCM.GetLength() > 3 && _strnicmp(m_csCM, "V2.0", strlen("V2.0")) == 0)
				{
					rt = DataTransferInitEx();
				}
				Dbg("DataTransferInit(Ex) rt:%d", rt);
				if (rt == 0)
				{
					Dbg("安全通道建立成功。");
					m_bChannelOK = true;
				}
				else
				{
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Safe_Channel_Build_Failed, "安全通道建立失败.");
					return Error_Unexpect;
				}
			}
			LoadSafeLockDll();
			m_issueStatusFromFile = m_issueStatus = isIssue;
			ret = UnAcceptCard();
			Dbg("ret: %d, isIssue: %d, m_hasCardWhileDevOpen:%d, m_issueStatusFromFile:%d",
				ret, isIssue, m_hasCardWhileDevOpen, m_issueStatusFromFile);
		}
		if (ret == 0)
		{
			if (m_hasCardWhileDevOpen && m_issueStatusFromFile > 0)
			{
				//oilyang@20171220 遗留卡片已经被吞，重置数据
				m_issueStatusFromFile = 0;
				m_currCardNo = m_addCardNo = "";
				FSMSetIssueFlag(0);
			}
			if (m_connectType == DEV_OPEN_TYPE_BLUETOOTH)
			{
				m_bBTConnected = true;
			}
			//oilyang@20191219 获取吞卡箱容量，目前有便携卡机，大机
			//超过5，认为是脏数据，用默认值3
			CardIssuerStatus cis;
			if ((eErrDev = m_hDevHelper->GetDevStatus(cis)) != Error_Succeed) {
				SetErrPackage(m_errPkg, "OpenDevice::GetDevStatus", m_csDevSN, eErrDev, MEC_DEVAPI_CARDISSUER_GetDevStatus);
				AlarmDEC(m_errPkg);
			}
			else
			{
				Dbg("device max retain count:%d, cis.eRetainBin:%d", cis.dwRetainCount, cis.eRetainBin);
				if (cis.dwRetainCount > 0 && cis.dwRetainCount <= 5)
					m_maxRetainCount = cis.dwRetainCount;
				else
					m_maxRetainCount = 3;

				if (cis.eRetainBin == CI_RETAINBIN_FULL)
				{
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_RETAIN_BIN_IS_FULL_SENSOR, "硬件检测：回收箱满了，请及时清理！");
				}
			}
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Open_Success, "CardIssuer Open Success.");
			return Error_Succeed;
		}
		else
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Open_Failed, "CardIssuer Open Failed.");
			return Error_Unexpect;
		}
	}
}
void CCardIssuerFSM::LoadCMBBin()
{
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Software, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("LoadCMBBin, open module cfg file failed!");
		return;
	}
	int dmCount,diCount,cmCount,ciCount;
	dmCount=diCount=cmCount=ciCount=0;
	spConfig->ReadConfigValueInt("CMBDebitMag","count",dmCount);
	spConfig->ReadConfigValueInt("CMBDebitIC","count",diCount);
	spConfig->ReadConfigValueInt("CMBCreditMag","count",cmCount);
	spConfig->ReadConfigValueInt("CMBCreditIC","count",ciCount);
	for (int i = 1; i <= dmCount; ++i)
	{
		CMBBin bin;
		char tmp[64] = {0};
		_itoa(i,tmp,10);
		spConfig->ReadConfigValue("CMBDebitMag",tmp,bin.bin);
		bin.bDC = true;
		bin.bIC = false;
		m_vBin.push_back(bin);
	}
	for (int i = 1; i <= diCount; ++i)
	{
		CMBBin bin;
		char tmp[64] = {0};
		_itoa(i,tmp,10);
		spConfig->ReadConfigValue("CMBDebitIC",tmp,bin.bin);
		bin.bDC = true;
		bin.bIC = true;
		m_vBin.push_back(bin);
	}
	for (int i = 1; i <= cmCount; ++i)
	{
		CMBBin bin;
		char tmp[64] = {0};
		_itoa(i,tmp,10);
		spConfig->ReadConfigValue("CMBCreditMag",tmp,bin.bin);
		bin.bDC = false;
		bin.bIC = false;
		m_vBin.push_back(bin);
	}
	for (int i = 1; i <= ciCount; ++i)
	{
		CMBBin bin;
		char tmp[64] = {0};
		_itoa(i,tmp,10);
		spConfig->ReadConfigValue("CMBCreditIC",tmp,bin.bin);
		bin.bDC = false;
		bin.bIC = true;
		m_vBin.push_back(bin);
	}
}
void CCardIssuerFSM::Load()
{
	LOG_FUNCTION();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfig);
	if (spConfig == NULL)
	{
		Dbg("<Load>, open root.ini failed.");
		return;
	}
	int smflag, onlineOnly;
	CSimpleStringA csVendor("");
	spConfig->ReadConfigValueInt("Device.CardIssuer", "Baudrate", m_baudRate);
	spConfig->ReadConfigValueInt("Device.CardIssuer", "Port", m_port);
	spConfig->ReadConfigValue("Device.CardIssuer", "Vendor", csVendor);
	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, csVendor);	
	//oiltmp 20161116 余下两项有必要迁移到运行时配置？
	spConfig->ReadConfigValueInt("Device.Utility", "SMSupport", smflag);
	spConfig->ReadConfigValueInt("Device.Utility", "OnlineOnly", onlineOnly);
	Dbg("m_baudRate:%d, m_port:%d, csVendor:%s, SMSupport:%d, OnlineOnly:%d",
		m_baudRate, m_port, csVendor.GetData(), smflag, onlineOnly);
	m_bSM = smflag;
	//oiltmp 20160506 no offline business now
	//m_bOnlineOnly = onlineOnly;
	m_bOnlineOnly = true;
	m_csDevSN = "";
	//for data migrate after dynamic bind SCI
	CSmartPointer<IConfigInfo> spConfigRun;
	eErrDev = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	if (eErrDev != Error_Succeed) {
		Dbg("<Load>, open cfg file failed!");
	}
	else
	{
		CSimpleStringA tmpNameRun(""), tmpNameRoot(""), tmpVendor("");
		spConfigRun->ReadConfigValue("SCI", "name", tmpNameRun);
		spConfig->ReadConfigValue("Terminal", "DevSN", tmpNameRoot);
		spConfigRun->ReadConfigValue("SCI", "Vendor", tmpVendor);
		Dbg("tmpNameRun:%s, tmpNameRoot:%s, tmpVendor:%s",
			tmpNameRun.GetData(), tmpNameRoot.GetData(), tmpVendor.GetData());
		// 如果运行时没有厂商名称，则将Root配置的厂商名称写到运行时，后面应该会改变？
		if (tmpVendor.IsNullOrEmpty())
		{
			if (!csVendor.IsNullOrEmpty())
				spConfigRun->WriteConfigValue("SCI", "Vendor", csVendor);
		}
		// 处理设备序列号，只有运行时有设备名称才赋值
		if (tmpNameRun.GetLength() > 2)//runcfg has sci name
		{
			Dbg("runcfg has sci name");
			m_csDevSN = tmpNameRun;
			//after migrate from root.ini to runcfg,clear the setting in root.ini
			//no privilege,hehe
			if (tmpNameRoot.GetLength() > 2)
				spConfig->WriteConfigValue("Terminal", "DevSN", ""); //清空掉配置？
		}
		else
		{
			//oilyang@20181129 no need to move data to RunCfg now...
			//if (IsValidSCIName(tmpNameRoot,tmpNameRoot.GetLength()))//root.ini has DevSN
			//{
			//	m_csDevSN = tmpNameRoot;
			//	spConfigRun->WriteConfigValue("SCI", "name", m_csDevSN);
			//}
		}
	}
}
int CCardIssuerFSM::Initial()
{
	ErrorCodeEnum errCode = OpenDevice(DEV_OPEN_TYPE_COM,"");
	if (errCode != Error_Succeed)
	{
		Dbg("OpenDevice in Initial return failed with errCode:%d(0x%x)", errCode, errCode);
		CloseAndClearDevObj(false);
	}
	return errCode;
}
int CCardIssuerFSM::UnAcceptCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	if (GetDevStatus()){
		if (m_devStatus.eMedia == CI_MEDIA_PRESENT){
			m_hasCardWhileDevOpen = true;
			JustReadCardNo();
			CSimpleStringA preFixNo("");
			CSimpleStringA suffixNo("");
			if (!m_currCardNo.IsNullOrEmpty() && m_currCardNo.GetLength() > 10)
			{
				preFixNo = m_currCardNo.SubString(0, 6);
				suffixNo = m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4);
			}
			errMsg = CSimpleStringA::Format("读卡器有卡:%d, CardNoLength:%d, CardNo:%s****%s",
				m_issueStatus, m_currCardNo.GetLength(), preFixNo.GetData(), suffixNo.GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_HasCard_In_Machine, errMsg.GetData());

			if (m_currCardNo.GetLength() > 1)
				m_captureReason = "4014";
			else
				m_captureReason = "0000";
			if (m_issueStatus) {
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "读卡器有卡(吞卡)");
				return CaptureCard(NULL);
			}
			else {
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard, "读卡器有卡(吐卡)");
				return EjectCard(NULL);
			}
		} 
		else{
			eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
			if (Error_Succeed != eErr) {
				SetErrPackage(m_errPkg, "UnAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
				AlarmDEC(m_errPkg);
			}
			if (GetDevStatus())
				return 0;
			else
				return 1;
		}
	}
	else
	{
		DevErrorInfo devErrorInfo;
		m_hDevHelper->GetLastErr(devErrorInfo);
		Dbg("UnAcceptCard, GetDevStatus failed errMsg:%s", devErrorInfo.szErrMsg);
	}
	return 1;
}
int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx)
{
	LOG_FUNCTION();
//#ifdef TWINKLE_LOCAL_DEBUG
	//oiltest@20190725 便携卡机压力测试，仅供开发环境测试
	if (ctxEx != NULL)
	{
		if (ctxEx->Req.hopper == 199)
		{
			Dbg("issue card no-stop begin");
			oiltestSCI(false);
			Dbg("issue card no-stop end");
			return 0;
		}
	}
//#endif
	if ((_strnicmp("RVC.PAD", m_csMachineType, strlen("RVC.PAD")) == 0 
		|| (_strnicmp("RVC.Desk2S", m_csMachineType, strlen("RVC.Desk2S")) == 0 && m_majorVerion == 1 && m_minorVerion == 0))
		&& !m_bChannelOK)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Has_Not_Build_SafeChannel, "发卡前还未建立安全通道");
		Dbg("IssueCard, 未建立安全通道");
		if (ctxEx != NULL)
			ctxEx->Answer(AnswerErrCode(Error_Unexpect), CardIssuer_UserErrorCode_No_Encryted_Channel);
		else if (ctx != NULL)
			ctx->Answer(AnswerErrCode(Error_Unexpect), CardIssuer_UserErrorCode_No_Encryted_Channel);
		return 2;
	}
	//如果有盘库记录则清理掉（@zjw20190809）
	if (m_csMachineType.Compare("RVC.CardStore") == 0
		|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
	{
		ErrorCodeEnum eErr = Error_Succeed;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if(eErr != Error_Succeed)
		{
			LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Open_RunCfgFile_Failed, "IssueCard::OpenConfig failed.");
			ctx->Answer(AnswerErrCode(Error_Unexpect), CardIssuer_UserErrorCode_Open_RunCfgFile_Failed);
			return 2;
		}
		if(CheckHasPanKuRecord(spConfigRun))
		{
			ClearLocalRecord(spConfigRun);
		}
	}

	CSimpleStringA errMsg(true);
	if (ctxEx != NULL)
	{
		//Req.hopper
		//89:从加卡箱移卡读卡
		//88:卡片加到卡槽
		//87:吞卡
		//99:移卡读卡
		//98:手工取卡
		//100:清空卡库、卡库盘库吞到吞卡箱
		Dbg("IssueCard, issue type:%d", ctxEx->Req.hopper);
		ctxEx->Ans.reserved1.Init(2);
		//oiltmp@20180521
		//from 宋锐：存储门禁卡
		if (ctxEx->Req.hopper == 86)
		{
			ErrorCodeEnum eGateForbid = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
			if (eGateForbid != Error_Succeed)
			{
				SetErrPackage(m_errPkg, "IssueCard::SetCardInType(CI_CARD_IN_TYPE_ALL)", m_csDevSN, eGateForbid, MEC_DEVAPI_CARDISSUER_SetCardInType);
				AlarmDEC(m_errPkg);
				ctxEx->Answer(Error_Unexpect);
				m_bForHangzhouSongruiMenjinka = false;
				return 2;
			}
			INT64 start = GetTickCountRVC();
			while (1)
			{
				if (m_bForHangzhouSongruiMenjinka)
				{
					Dbg("<IssueCard>, front cancel insert card.");
					m_bForHangzhouSongruiMenjinka = false;
					ctxEx->Answer(Error_Cancel);
					return 2;
				}
				if (QueryCardInfo() == 2)
				{
					//oiltest@20180704 for songrui
					
					CardNo cardtmp;
					ErrorCodeEnum eErr = m_hDevHelper->ReadAccount(cardtmp);
					if (Error_Succeed != eErr) {
						SetErrPackage(m_errPkg, "IssueCard::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
						AlarmDEC(m_errPkg);
					}

					ctxEx->Ans.reserved1[1] = 0;
					ctxEx->Answer(Error_Succeed);
					Dbg("add gate forbid card suc.");
					m_bForHangzhouSongruiMenjinka = false;
					return 0;
				}
				Sleep(1000);
				INT64 end = GetTickCountRVC();
				if ((end - start) > 60 * 1000)
				{
					Dbg("<IssueCard>, time elapsed, but can't find card.");
					m_bForHangzhouSongruiMenjinka = false;
					ctxEx->Answer(Error_TimeOut);
					return 2;
				}
			}
		}
		m_bForHangzhouSongruiMenjinka = false;
		if (ctxEx->Req.hopper == 100 || ctxEx->Req.hopper == 99 || ctxEx->Req.hopper == 98 ||ctxEx->Req.hopper == 97)//卡库
		{
			if (!IsValidSlotNum(ctxEx->Req.reserved1[0]))
			{
				errMsg = CSimpleStringA::Format("Invalid slot(%d), req.hopper=%d", ctxEx->Req.reserved1[0], ctxEx->Req.hopper);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invalid_Slot, errMsg.GetData());
				ctxEx->Ans.reserved1[0] = 1;
				ctxEx->Answer(Error_Succeed);
				return 2;
			}
			if (!IsSlotHasCard(ctxEx->Req.reserved1[0]))
			{
				errMsg = CSimpleStringA::Format("slot %d has no card, req.hopper=%d", ctxEx->Req.reserved1[0], ctxEx->Req.hopper);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Slot_Has_No_Card, errMsg.GetData());
				
				ctxEx->Ans.reserved1[0] = 2;
				ctxEx->Answer(Error_Succeed);
				return 2;
			}
			FSMSetIssueFlag(1);
			bool bSpec = false;
			if (ctxEx->Req.hopper == 98 || ctxEx->Req.hopper == 100)
				bSpec = true;		
			return IssueCardFromStore(ctxEx,bSpec);
		}
		else if (ctxEx->Req.hopper == 89)//加卡步骤一
		{
			FSMSetIssueFlag(1);
			return AddCardToStoreStepFirst(ctxEx);
		}
		else if (ctxEx->Req.hopper == 88)//加卡步骤二
		{
			return AddCardToStoreStepLast(ctxEx);
		}
		else if (ctxEx->Req.hopper == 87)//签发失败，吞卡
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "sign failed, to capture card.");
			RegistCardWhileCaptureCard();
			MachineMoveCardBackNotHold();
			ctxEx->Answer(Error_Succeed);
			return 2;
		}
		
		//param Req.hopper is wrong
		if (ctxEx->Req.hopper < 1 || ctxEx->Req.hopper > 6) {
			errMsg = CSimpleStringA::Format("Issuer Card, the hopperNo(%d) is wrong!!!", ctxEx->Req.hopper);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invalid_Hopper, errMsg.GetData());
			return Error_Param;
		}
		
		Dbg("IssueCard, m_bHasHopper[ctxEx->Req.hopper - 1]:%d", m_bHasHopper[ctxEx->Req.hopper - 1]);

		if (!m_bHasHopper[ctxEx->Req.hopper - 1])
		{
			switch (ctxEx->Req.hopper)
			{
			case 1:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper1);
				break;
			case 2:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper2);
				break;
			case 3:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper3);
				break;
			case 4:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper4);
				break;
			case 5:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper5);
				break;
			case 6:
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper6);
				break;
			}
			return 2;
		}
		m_currentHopper = ctxEx->Req.hopper;
	}
	else
		m_currentHopper = 1;
	Dbg("IssueCard, current hopper:%d", m_currentHopper);
	m_pCardProcess->DataInit();
	if (m_mixedEx[m_currentHopper-1] >= 3)
	{
		//all of the hoppers are wrong
		if (((m_bHasHopper[0] && m_mixedEx[0] >= 3) || !m_bHasHopper[0])
			&& ((m_bHasHopper[1] && m_mixedEx[1] >= 3) || !m_bHasHopper[1])
			&& ((m_bHasHopper[2] && m_mixedEx[2] >= 3) || !m_bHasHopper[2])
			&& ((m_bHasHopper[3] && m_mixedEx[1] >= 3) || !m_bHasHopper[3])
			&& ((m_bHasHopper[4] && m_mixedEx[1] >= 3) || !m_bHasHopper[4])
			&& ((m_bHasHopper[5] && m_mixedEx[1] >= 3) || !m_bHasHopper[5]))
			SetDevStateAndSendMsg(DEVICE_STATUS_MAINTAINCE);

		errMsg = CSimpleStringA::Format("the current card hopper may be wrong. has hopper?, hopper0:%d, hopper1:%d, hopper2:%d, mixedEx[0]:%d, mixedEx[1]:%d, mixedEx[2]:%d",
			m_bHasHopper[0], m_bHasHopper[1], m_bHasHopper[2], m_mixedEx[0], m_mixedEx[1], m_mixedEx[2]);
		LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Hopper_Mixed_Too_Much, errMsg.GetData());
		
		if (ctx != NULL)
			ctx->Answer(AnswerErrCode(Error_DevMedia), CardIssuer_UserErrorCode_Hopper_Mixed_Too_Much);
		else
			ctxEx->Answer(AnswerErrCode(Error_DevMedia), CardIssuer_UserErrorCode_Hopper_Mixed_Too_Much);
		return 2;
	}
	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	memset(&cis, 0, sizeof(CardIssuerStatus));
	bool bEmpty = false;

	errCode = m_hDevHelper->GetDevStatus(cis);
	if (errCode != Error_Succeed) {
		SetErrPackage(m_errPkg, "IssueCard::GetDevStatus", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus);
		AlarmDEC(m_errPkg);
	}
	else
	{
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY || cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
			bEmpty = true;
	}
	if (bEmpty || m_remainsEx[m_currentHopper - 1] <= 0)
	{
		CSimpleStringA warnInfo = CSimpleStringA::Format("IssuerCard, hopper%d no more cards to issue. LocalRecord CardremainsEx:%d, Vendor return:NoCard(%d), CardCount(%d)",
			m_currentHopper, m_remainsEx[m_currentHopper - 1], cis.eIssuerBin[m_currentHopper - 1], cis.dwIssuerCount[m_currentHopper - 1]);
		LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_No_More_Card_Issue, warnInfo.GetData());

		DWORD dwUsrErrCode = 0;
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
		{
			if (m_currentHopper == 1)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper1;
			else if (m_currentHopper == 2)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper2;
			else if (m_currentHopper == 3)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper3;
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper6;
		}
		else if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY)
		{
			if (m_currentHopper == 1)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper1;
			else if (m_currentHopper == 2)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper2;
			else if (m_currentHopper == 3)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper3;
			else if (m_currentHopper == 4)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper4;
			else if (m_currentHopper == 5)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper5;
			else if (m_currentHopper == 6)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper6;
		}
		else if (m_remainsEx[m_currentHopper - 1] <= 0)
		{
			if (m_currentHopper == 1)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper1;
			else if (m_currentHopper == 2)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper2;
			else if (m_currentHopper == 3)
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper3;
		}
		if (ctx != NULL)//TODO:web需要根据userCode给出具体的提示
			ctx->Answer(AnswerErrCode(Error_Unexpect), dwUsrErrCode);
		else
			ctxEx->Answer(AnswerErrCode(Error_Unexpect), dwUsrErrCode);

		return 2;
	}
	//forbid front enter
	Dbg("forbid front enter");
	errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	if (errCode != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "IssueCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_SetCardInType);
		if (ctx != NULL)
			ctx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
		else
			ctxEx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
		return 1;
	}
	Dbg("move card to holder");
	FSMSetIssueFlag(1);
	//move card to holder
	errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER,m_currentHopper);
	Dbg("move card result %d, %s.", m_currentHopper, SpStrError(errCode));

	if (errCode != Error_Succeed)
	{
		FSMSetIssueFlag(2);
		SetErrPackage(m_errPkg, "IssueCard::MoveCard", m_csDevSN, errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER);
		if (ctx != NULL)
			ctx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
		else
			ctxEx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
		return 1;
	}
	Dbg("set issue data");
	m_issuedEx[m_currentHopper - 1]++;
	m_remainsEx[m_currentHopper - 1]--;
	//oilyang@20180809 增加对单卡槽多卡槽机器的使用及闲置的适配
	if ((!m_bHasHopper[0] || m_CardPercentEx[0] == 0 || m_CardInitEx[0] == 0 || (100 * m_remainsEx[0] < m_CardPercentEx[0] * m_CardInitEx[0]))
		&& (!m_bHasHopper[1] || m_CardPercentEx[1] == 0 || m_CardInitEx[1] == 0 || (100 * m_remainsEx[1] < m_CardPercentEx[1] * m_CardInitEx[1]))
		&& (!m_bHasHopper[2] || m_CardPercentEx[2] == 0 || m_CardInitEx[2] == 0 || (100 * m_remainsEx[2] < m_CardPercentEx[2] * m_CardInitEx[2])))
	{
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_FEW_CARD_REMAINS, "Few card remains.");
	}
	m_bSettingMaterial = true;//oilyang 借用于延迟同步，紧接着设置remains时更新到后台数据库
	if (!SetCardIssued(m_issuedEx[m_currentHopper - 1], m_currentHopper))
		Dbg("IssueCard, Set card issued failed.");
	m_bSettingMaterial = false;
	if (!SetCardRemains(m_remainsEx[m_currentHopper - 1], m_currentHopper))
		Dbg("IssueCard, Set card remains failed.");
	Dbg("IssueCard success.");
	ctxEx->Ans.reserved1[0] = ctxEx->Ans.reserved1[1] = 0;
	//oilyang@20170929 根据讨论结果，去掉调用

	//GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;
	//errCode = Error_Unexpect;
	//pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
	//if (pGuiConsoleClient != NULL)
	//	errCode = pGuiConsoleClient->Connect();
	//else
	//	Dbg("pGuiConsoleClient is null?");
	//if (errCode == Error_Succeed)
	//{
	//	if (pGuiConsoleClient)
	//	{
	//		GUIConsoleService_AddMaterialCounter_Req req;
	//		GUIConsoleService_AddMaterialCounter_Ans ans;
	//		req.strMaterialCode = "DebitCard";
	//		errCode = pGuiConsoleClient->AddMaterialCounter(req, ans, 10000);
	//		Dbg("%d",errCode);
	//		if (pGuiConsoleClient != NULL)
	//		{
	//			pGuiConsoleClient->GetFunction()->CloseSession();
	//			pGuiConsoleClient->SafeDelete();
	//			pGuiConsoleClient = NULL;
	//		}
	//	}
	//}

	if (m_bIssuingExit)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "Issuing exit, to capture card.");
		CaptureCard(NULL);
	}
	if (ctx != NULL)
		ctx->Answer(Error_Succeed);
	else
		ctxEx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	int ret = 0;
	//hr = m_pIDCard->IDC_Capture();
	eErr = MachineMoveCardBackNotHold();
	Dbg("asked to capture %d",eErr);
	if (eErr == Error_Succeed)
	{
		bool bCaptured = RegistCardWhileCaptureCard();
		Dbg("to capture card.regist %d", bCaptured);
		m_currCardNo = m_addCardNo = "";
	}
	else
		ret = 1;
	m_CardCaptured++;
	/**TODO(Gifur@8/20/2021): 吞卡失败是否仍需要继续累增记录吞卡次数 */
	if (!SetCardCaptured(m_CardCaptured))
		Dbg("<CaptureCard>, set card captured failed.");
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "CaptureCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
			AlarmDEC(m_errPkg);
		}
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
	}
	else {
		if (ctx != NULL) {
			LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Capture_Failed, "CaptureCard failed.");
			ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_Failed);
		}
	}
	Dbg("Captured, ret:%d", ret);
	return ret;
}
int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	ErrorCodeEnum eErr;
	eErr = MachineMoveCardFrontGate();
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "EjectCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
			AlarmDEC(m_errPkg);
		}
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
		ret = 0;
	}
	else {
		if (ctx != NULL) {
			LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_Failed, "EjectCard failed.");
			SetErrPackage(m_errPkg, "ReadCard::MachineMoveCardFrontGate", m_csDevSN, eErr, CardIssuer_UserErrorCode_MoveCardToGate_Failed);
			ctx->Answer(Error_Exception, AlarmDEC(m_errPkg, true));
		}
		ret = 1;
	}
	Dbg("EjectCard, ret: %d", ret);
	return ret;
}
int CCardIssuerFSM::WaitFetchingCard()
{
	LOG_FUNCTION();
	//int waitTries = 0;
	DWORD dwStart, dwEnd;
	dwStart = GetTickCountRVC();
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON,"CardReader(fetch) warning on");
	do {
		if (GetDevStatus()){
			dwEnd = GetTickCountRVC();
			if (m_devStatus.eMedia == CI_MEDIA_ENTERING){
				Sleep(WAIT_INTERVAL);
				//waitTries++;
			}
			else{
				//waitTries = 0;
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
				return 0;
			}
		}else
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
			return 1;
		}
	}while ((dwEnd-dwStart) < 60*1000);
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
	return 2;
}
int CCardIssuerFSM::InternalAcceptCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	int acceptTries = 0, err = 0;
	DWORD64 dwStart = GetTickCountRVC();
	DWORD64 dwEnd = dwStart;
	m_bWaitingAccept = true;
	bool bHasSetCardInType = false;
	Dbg("InternalAcceptCard, m_bExit:%d, m_bCancelAccept:%d, m_bWaitAccepteMore:%d, m_bCancelByRFIC:%d",
		m_bExit, m_bCancelAccept, m_bWaitAccepteMore, m_bCancelByRFIC);

	do {
		if (m_bExit)
		{
			m_bCancelAccept = true;
			break;
		}
		if (m_bCancelAccept)
		{
			err = 3;
			goto Err;
		}
		if (m_bWaitAccepteMore)
		{
			acceptTries = 0;
			dwEnd = dwStart = GetTickCountRVC();
			m_bWaitAccepteMore = false;
		}
		if (GetDevStatus())
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle,LOG_EVT_CARDISSUER_OP,"CardIssuer op.");
				acceptTries = 0;
				goto Err;
			}
			if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				acceptTries++;
				Sleep(ACCEPT_TRY_INTERVAL);
				//hr = m_pIDCard->IDC_Accept(IDC_ALL_CARD,&lpCardData);
				if (!m_bCancelAccept && !bHasSetCardInType)
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
				if (Error_Succeed != eErr) {
					SetErrPackage(m_errPkg, "InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_ALL)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
					AlarmDEC(m_errPkg);
				}
				else
					bHasSetCardInType = true;
					//LogErrInfo("err while accepting card,open shutter");
			}
		}
		else
		{
			err = 1;
			goto Err;
		}
		dwEnd = GetTickCountRVC();
	}while ((dwEnd - dwStart) < 58*1000);
	err = 2;

Err:
	m_bExit = false;
	m_bWaitingAccept = false;
	eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	if (Error_Succeed != eErr)
	{
		SetErrPackage(m_errPkg, "InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
		AlarmDEC(m_errPkg);
	}
	if (m_bCancelAccept && err != 1)
	{
		//oilyang@20181210 add "if (!m_bCancelByRFIC)" 
		//oilyang@20170612
		if (!m_bCancelByRFIC)
			Sleep(500);
		if (GetDevStatus())
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				err = 4;
				Dbg("<InternalAcceptCard>, Cancel InterAccept, eject card.");
				eErr = MachineMoveCardFrontGate();

				if (Error_Succeed == eErr){
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
					if (eErr != Error_Succeed) {
						SetErrPackage(m_errPkg, "InternalAcceptCard::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
						AlarmDEC(m_errPkg);
					}
				}
				else
				{
					LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_Failed, "InternalAcceptCard::MachineMoveCardFrontGate failed.");
					err = 2;
				}
			}
		}
		else
			err = 2;
	}
	return err;
}
int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	m_bCancelByRFIC = false;
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON,"CardReader warning on");
	m_bWaitAccepteMore = false;
	int rc = InternalAcceptCard();
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader warning off");
	if (rc == 0) {
		FSMSetIssueFlag(0);
		if (ctx != NULL)
		{
			Dbg("AcceptCard, insert succeed");
			ctx->Answer(Error_Succeed);
		}
	}
	else if(rc == 2)
	{
		if (ctx != NULL) {
			Dbg("AcceptCard, insert timeout");
			ctx->Answer(Error_TimeOut);
		}
	}
	else if(rc == 3 || rc == 4)
	{
		if (ctx != NULL)
		{
			Dbg("insert cancel (%d)",rc);
			ctx->Answer(Error_Cancel);
		}
	}else 
	{
		if (ctx != NULL) {
			SetErrPackage(m_errPkg, "AcceptCard::InternalAcceptCard", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus);
			ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		}
	}
	return rc;
}
static CSimpleStringA GetStrData(TrackInfo trackInfo)
{
	//LOG_FUNCTION();
	CSimpleStringA strRet;
	switch (trackInfo.eStatus) {
		case CI_DATA_OK:
			strRet = (char*)trackInfo.data;
			break;
		case CI_DATA_INVALID:
			strRet = "无效数据";
			break;
		//case CI_DATA_MISSING:
		default:
			strRet = "数据丢失";
	}
	return strRet;
}
int CCardIssuerFSM::SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData)
{
	LOG_FUNCTION();
	
	int dataLen = strlen(pTrack2);
	Dbg("<SplitTrack2>, pTrack2.len:%d", dataLen);

	if (pTrack2.GetLength() == 0)
		return -1;

	switch(dataLen)
	{
	case 28:
		decodeData.t2Region = CSimpleString(pTrack2,4);
		decodeData.t2Account = pTrack2.SubString(4,8);
		decodeData.t2CardSerial = pTrack2.SubString(14,8);//oilyang for 8 onecard
		decodeData.t2CVC = pTrack2.SubString(22,6);
		decodeData.t2ExpireDate = "";
		break;
	case 31:
		decodeData.t2Account = CSimpleString(pTrack2,16);
		decodeData.t2CardSerial = pTrack2.SubString(16,1);
		decodeData.t2CVC = pTrack2.SubString(17,6);
		decodeData.t2Region = pTrack2.SubString(23,4);
		decodeData.t2ExpireDate = pTrack2.SubString(27,4);
		break;
	case 25://AE Card
		decodeData.t2Account = CSimpleString(pTrack2, 15);
		decodeData.t2CardSerial = pTrack2.SubString(15, 1);
		decodeData.t2CVC = pTrack2.SubString(16, 5);
		decodeData.t2ExpireDate = pTrack2.SubString(21, 4);
		decodeData.t2Region = "";
		break;
	case 38:
		break;
	default:
		return -1;
	}
	decodeData.status = 0;
	return 0;
}
int SplitUnionPayTrack2(CSimpleStringA pTrack2,Track2Data &decodeData)
{
	if (strlen(pTrack2) != 37)
	{
		Dbg("wrong track2 len %d[%s]", strlen(pTrack2), (LPCTSTR)pTrack2);
		return -1;
	}
	//“16位卡号(19A)” + “=” + “expiry_date YYMM(4N)” + 
	//“106(3N，服务代码)” + “PVV(5N)” + “00(2N)” + “CVV(3A)”
	//6225885710172339=49121200541300175361 
	//oiltmp
	//decodeData.t2Account = CSimpleString(pTrack2,16);
	//decodeData.t2CardSerial = pTrack2.SubString(16,1);
	//decodeData.t2CVC = pTrack2.SubString(17,6);
	//decodeData.t2Region = pTrack2.SubString(23,4);
	//decodeData.t2ExpireDate = pTrack2.SubString(27,4);
	return 0;
}


//0:unknown 1:本行借记磁卡；2 本行借记IC；3 本行贷记磁卡；4 本行贷记IC；5 他行卡
int CCardIssuerFSM::DetectCardTypeInfoByAccount(char *pAccount, int len, char *pT3, int t3Len)
{
	Dbg("DetectCardTypeInfoByAccount, in param len:%d", len);

	if (len < 6)
		return 0;
	if (!memcmp(pAccount,"95555",5))
		return 1;
	if (pT3 != NULL)
	{
		char tmpMag2_3[512] = {0},tmpMag2[256] = {0};
		memcpy(tmpMag2_3,pAccount,len);
		memcpy(tmpMag2_3+len,"A",1);
		memcpy(tmpMag2_3+len+1,pT3,t3Len);
		char cardType[8] = {0};
		cmdDecodeEx(tmpMag2_3,cardType,tmpMag2);

		if (_strnicmp(cardType,"ODCD",4) == 0)
		{
			Dbg("old one card tong...");
			return 1;
		}
	}

	char bin[7] = {0};
	memcpy(bin,pAccount,6);
	vector<CMBBin>::iterator it;
	for (it = m_vBin.begin(); it != m_vBin.end(); ++it)
	{
		if (!memcmp(bin,it->bin,6))
		{
			if (it->bDC)
			{
				if (it->bIC)
					return 2;
				else
					return 1;
			}
			else
			{
				if (it->bIC)
					return 4;
				else
					return 3;
			}
		}
	}
	return 5;//all the other cards
}
//ReadCardEx 废弃不用 oilyang
int CCardIssuerFSM::ReadCardEx(SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx)
{
return 0;
}
int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_currCardNo = "";
	ctx->Ans.ICType = 0;
	ErrorCodeEnum eErr;
	int activeCardType;
	bool bIC(false), bICSuc(false), bReadCardInfo(false);
	CSimpleString errMsg("");
	errMsg = CSimpleString::Format("ReadCard, inParam: reserved1 for lightPos:%d, m_issueStatus:%d, m_currentHopper:%d",
		ctx->Req.reserved1, m_issueStatus, m_currentHopper);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_ReadCard_Process, errMsg.GetData());

	if ((ctx->Req.reserved1&0x32) == 0x32)//只需要磁条
	{

	}
	else
	{
		bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
		Dbg("<ReadCard::DetectIfICCard>, bIC:%d", bIC);
		if (bIC)
		{
			eErr = m_hDevHelper->DeactivateICCard();
			if (eErr != Error_Succeed) {
				SetErrPackage(m_errPkg, "ReadCard::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
				AlarmDEC(m_errPkg);
			}

			eErr = m_hDevHelper->ReleaseIC();
			if (eErr != Error_Succeed) {
				SetErrPackage(m_errPkg, "ReadCard::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
				AlarmDEC(m_errPkg);
			}
		}
	}
	DWORD dwStart = GetTickCountRVC();
	MagTracks magTracks;
	int readTries = 0;
	memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
	memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
	memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));
	{
		magTracks.eRange = CI_TRACK_RANGE_2_3;
		do {
			eErr = m_hDevHelper->MagRead(magTracks);
			Dbg("t2Status:%d, t3Status:%d, t2Len:%d, t3Len:%d",
				magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[1].dwSize, magTracks.track[2].dwSize);

			ctx->Ans.t2Account = ctx->Ans.ICData = "";
			readTries++;

			if (magTracks.track[1].dwSize > sizeof(magTracks.track[1].data) || magTracks.track[2].dwSize > sizeof(magTracks.track[2].data))
			{
				errMsg = CSimpleString::Format("MagRead, trackSize maybe wrong:t2Size:%d(%d), t3Size:%d(%d)",
					magTracks.track[1].dwSize, sizeof(magTracks.track[1].data),
					magTracks.track[2].dwSize, sizeof(magTracks.track[2].data));
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_TrackSize_Wrong, errMsg.GetData());
				break;
			}


			if (Error_Succeed == eErr && magTracks.track[1].eStatus == CI_DATA_OK)
			{
				if (bIC)
					ctx->Ans.ICType = 1;
				else
					ctx->Ans.ICType = 2;
				LogEvent(Severity_Middle,LOG_EVT_CARDISSUER_OP,"CardIssuer op.");
				if (magTracks.track[1].dwSize > 40)
				{
					errMsg = CSimpleString::Format("MagRead, track2Size maybe wrong:t2Size:%d", magTracks.track[1].dwSize);
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Track2Size_Wrong, errMsg.GetData());
					ctx->Ans.status = 1;
					break;
				}
				ctx->Ans.track2 = (char*)magTracks.track[1].data;
				bool bT3OK = false;
				if (magTracks.track[2].eStatus == CI_DATA_OK)
				{
					bT3OK = true;
					ctx->Ans.track3 = (char*)magTracks.track[2].data;
				}
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char *tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				DecodeTracksData((const char*)magTracks.track[1].data, magTracks.track[1].dwSize, (const char*)magTracks.track[2].data, magTracks.track[2].dwSize, tmpMag2,true,bT3OK);
				
				int pos = 0;
				for (int i = 0; i < magTracks.track[1].dwSize; ++i,++pos)
				{
					// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					if (magTracks.track[1].data[i] == 0x3d 
						|| magTracks.track[1].data[i] == 0x3e 
						|| magTracks.track[1].data[i] == 0x44)
					break;
				}
				Dbg("<ReadCard::MagRead>, split pos:%d", pos);
				if (pos <= 0 || pos == magTracks.track[1].dwSize)
				{
					ctx->Ans.status = 1;
					if (tmpMag2 != NULL)
					{
						delete[]tmpMag2;
						tmpMag2 = NULL;
					}
					break;
				}
				char *ddd = new char[40];
				memset(ddd,0,40);
				memcpy(ddd,magTracks.track[1].data,pos);

				if (SplitTrack2(tmpMag2,track2Data) == 0)
				{
					ctx->Ans.status = track2Data.status;
					ctx->Ans.t2Account = track2Data.t2Account;
					ctx->Ans.t2Region = track2Data.t2Region;
					ctx->Ans.t2CardSerial = track2Data.t2CardSerial;
					ctx->Ans.t2CVC = track2Data.t2CVC;
					ctx->Ans.t2ExpireDate = track2Data.t2ExpireDate;

					Dbg("done.");
					bReadCardInfo = true;
					if (m_issueStatus)
					{
						m_mixedEx[m_currentHopper - 1] = 0;
						bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
						Dbg("set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
					}
					//break;
				}
				if (_strnicmp(track2Data.t2Account,ddd,strlen(ddd)) && (track2Data.t2Account.GetLength() != 8))
				{

					ctx->Ans.status = 0;
					ctx->Ans.t2Account = (char*)ddd;
					ctx->Ans.t2Region = "";
					ctx->Ans.t2CardSerial = "";
					ctx->Ans.t2CVC = "";
					ctx->Ans.t2ExpireDate = "";
					bReadCardInfo = true;
					delete []ddd;
				}
				if (tmpMag2 != NULL)
				{
					delete[]tmpMag2;
					tmpMag2 = NULL;
				}
				Dbg(CSimpleStringA::Format("<ReadCard::MagRead>, t2Account len:%d, %s****%s, status:%d, t2CardSerial:%s, t2CVC:%s",
					ctx->Ans.t2Account.GetLength(), (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6),
					(LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4),
					ctx->Ans.status, ctx->Ans.t2CardSerial.GetData(), ctx->Ans.t2CVC.GetData()));

				CSimpleStringA cardInfo(true);
				if (!ctx->Ans.track2.IsNullOrEmpty() && (pos + 8) < magTracks.track[1].dwSize)
				{
					cardInfo = CSimpleStringA::Format("cardServiceCode:%s", (ctx->Ans.track2.SubString(pos + 1, 7)).GetData());
					LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Track2_ServiceCode, cardInfo.GetData());
				}
				cardInfo = CSimpleStringA::Format("cardBin:%s****%s", (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4));
				LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

				break;
			}
			else
			{
				if (bIC)
				{
					bReadCardInfo = true;
					ctx->Ans.ICType = 3;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MaybeIC_Only, "<ReadCard>, maybe ic only.");
				}
				else
				{
					SetErrPackage(m_errPkg, "ReadCard::MagRead", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagRead);
					AlarmDEC(m_errPkg);
				}
			}

		}while(readTries < READ_TRY_NUM);
	}
	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ctx->Ans.ICType);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardType, cardType.GetData());

	m_currCardNo = ctx->Ans.t2Account;
	DWORD dwEnd = GetTickCountRVC();
	DWORD dwCollapse = dwEnd-dwStart;
	if ((dwCollapse < 8000) && (!bReadCardInfo))
	{
		bReadCardInfo = true;
		ctx->Ans.status = 1;
		//maybe cannot read mag
		if (m_issueStatus)
		{
			m_mixedEx[m_currentHopper - 1]++;
			bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
			Dbg("set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
		}
	}
	bool bEjectSelf = false;
	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
		if (!m_issueStatus)
		{
			Dbg("ReadCarad failed, eject self");
			ErrorCodeEnum errEject = MachineMoveCardFrontGate();
			if (errEject == Error_Succeed)
			{
				Dbg("read failed.eject self");
				bEjectSelf = true;
			}
			else
				LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_Failed, "ReadCard::MachineMoveCardFrontGate failed.");
		}
	}
	if (GetDevStatus())
	{
		if (bEjectSelf)
			return 2;
		else
			return 0;
	}else
		return 1;
}
int CCardIssuerFSM::WriteCard(SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	int ret = 0;
	Dbg("WriteCard，t1Len:%d, t2Len:%d, t3Len:%d", ctx->Req.track1.GetLength(), ctx->Req.track2.GetLength(), ctx->Req.track3.GetLength());
	if (ctx->Req.track1.GetLength() <= 0 && ctx->Req.track2.GetLength() <= 0 && ctx->Req.track3.GetLength() <= 0)
	{
		Dbg("<WriteCard>, write card param is null.");
		ctx->Answer(Error_Param);
		return ret;
	}
	else
	{
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_MAG_POSITION);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "WriteCard::MoveCard(CI_MOVECARD_MAG_POSITION)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_MAG_POSITION);
			ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
			return ret;
		}
	}
	MagTracks magTrack;
	ZeroMemory(magTrack.track[0].data,MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[1].data,MAX_MAG_TRACK_SIZE);
	ZeroMemory(magTrack.track[2].data,MAX_MAG_TRACK_SIZE);
	magTrack.track[0].dwSize = magTrack.track[1].dwSize = magTrack.track[2].dwSize = 0;
	magTrack.track[0].eStatus = magTrack.track[1].eStatus = magTrack.track[2].eStatus = CI_DATA_INVALID;
	TrackRange iT1,iT2,iT3;
	iT1 = iT2 = iT3 = CI_TRACK_RANGE_START;
	if (ctx->Req.track1.GetLength() > 0)
	{
		iT1 = CI_TRACK_RANGE_1;
		CSimpleStringA csT1 = CSimpleStringW2A(ctx->Req.track1);
		strncpy((char*)magTrack.track[0].data,csT1,csT1.GetLength());
		magTrack.track[0].eSource = CI_TRACK_SOURCE_1;
		magTrack.track[0].eStatus = CI_DATA_OK;
		magTrack.track[0].dwSize = csT1.GetLength();
	}
	if (ctx->Req.track2.GetLength() > 0)
	{
		iT2 = CI_TRACK_RANGE_2;
		CSimpleStringA csT2 = CSimpleStringW2A(ctx->Req.track2);
		strncpy((char*)magTrack.track[1].data,csT2,csT2.GetLength());
		magTrack.track[1].eSource = CI_TRACK_SOURCE_2;
		magTrack.track[1].eStatus = CI_DATA_OK;
		magTrack.track[1].dwSize = csT2.GetLength();
	}
	if (ctx->Req.track3.GetLength() > 0)
	{
		iT3 = CI_TRACK_RANGE_3;
		CSimpleStringA csT3 = CSimpleStringW2A(ctx->Req.track3);
		strncpy((char*)magTrack.track[2].data,csT3,csT3.GetLength());
		magTrack.track[2].eSource = CI_TRACK_SOURCE_3;
		magTrack.track[2].eStatus = CI_DATA_OK;
		magTrack.track[2].dwSize = csT3.GetLength();
	}

	//TrackRange eAll = iT2 | iT2;
	magTrack.eRange = TrackRange(iT1|iT2|iT3);
	Dbg("to write...(%d)",magTrack.eRange);
	eErr = m_hDevHelper->MagWrite(magTrack,AUTO_CO);
	Dbg("after write %d",eErr);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "WriteCard::MagWrite", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagWrite);
		AlarmDEC(m_errPkg);
		ret = 1;
	}
	ctx->Ans.result = ret;
	ctx->Answer(Error_Succeed);
	return ret;
}
int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_findCard = m_cardPos = 0;//just for RVC.CardStore
	bool bCrossPreOnline = false;
	//如果有盘库记录则清理掉（@zjw20190809）
	if (m_csMachineType.Compare("RVC.CardStore") == 0
		|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
	{
		ErrorCodeEnum eErr = Error_Succeed;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if(eErr != Error_Succeed)
		{
			LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Open_RunCfgFile_Failed, "PreOnline::OpenConfig failed.");
			ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Open_RunCfgFile_Failed);
			return 2;
		}
		if(CheckHasPanKuRecord(spConfigRun))
		{
			ClearLocalRecord(spConfigRun);
		}
	}

	Dbg("PreOnline, bussiness data[%s], req.reserved1:%s", ctx->Req.businessData.GetData(), ctx->Req.reserved1.GetData());
	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	if (ctx->Req.reserved1.GetLength() > 0 && _strnicmp("kaku#",(const char*)ctx->Req.reserved1,5) == 0)
	{
		bCrossPreOnline = true;
		GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "Y");
		CSimpleStringA csSlot("");
		csSlot = ctx->Req.reserved1.SubString(5, ctx->Req.reserved1.GetLength() - 5);
		slot = atoi((const char*)csSlot);
		CSimpleStringA errMsg("");

		if (!IsValidSlotNum(slot))
		{
			errMsg = CSimpleStringA::Format("PreOnline, web give a invalid slot num(%d)", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Slot_Is_Invalid, errMsg.GetData());
			m_findCard = 1;
			GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
			ctx->Answer(Error_Succeed);
			return 0;
		}
		if (!IsSlotHasCard(slot))
		{
			errMsg = CSimpleStringA::Format("PreOnline, the slot(%d) has no card.", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Slot_Has_No_Card, errMsg.GetData());
			m_findCard = 2;
			GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
			ctx->Answer(Error_Succeed);
			return 0;
		}
		ErrorCodeEnum eErr = Error_Unexpect;
		eErr = m_hDevHelper->MoveCardFromSlot(slot);
		Dbg("PreOnline, slot:%d", slot);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "PreOnline::MoveCardFromSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot);
			AlarmDEC(m_errPkg);
			m_findCard = 4;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			ctx->Answer(Error_Succeed);
			return 0;
		}

		CardNo card;
		ZeroMemory(card.account, sizeof(card.account));
		ZeroMemory(card.track2, sizeof(card.track2));
		ZeroMemory(card.track3, sizeof(card.track3));

		eErr = m_hDevHelper->ReadAccount(card);
		Dbg("t2Size:%d(%d),t3Size:%d(%d), reserved2 len:%d, account len:%d",
			card.dwTrack2Size, strlen(card.track2), card.dwTrack3Size, strlen(card.track3), ctx->Req.reserved2.GetLength(), strlen(card.account));

		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "PreOnline::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
			AlarmDEC(m_errPkg);
			m_findCard = 4;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			ctx->Answer(Error_Succeed);
			return 0;
		}

		string strAccount = card.account;
		int reserved2Len = ctx->Req.reserved2.GetLength();
		int cardAccountLen = strlen(card.account);
		if (reserved2Len > 10 && cardAccountLen > 10)
		{
			Dbg("<PreOnline::ReadAccount>, req.reserved2:%s****%s, card.account:%s****%s", (ctx->Req.reserved2.SubString(0, 6)).GetData(), (ctx->Req.reserved2.SubString(reserved2Len - 4, 4)).GetData(),
				(strAccount.substr(0, 6)).c_str(), (strAccount.substr(cardAccountLen - 4, 4)).c_str());
		}

		if (ctx->Req.reserved2.GetLength() > 0 && ctx->Req.reserved2.Compare(card.account) != 0)
		{
			m_findCard = 3;
			AfterPreOnlineOnStore(Error_Unexpect, slot);
			ctx->Answer(Error_Succeed);
			return 0;
		}
		if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
		{
			if (card.track2[card.dwTrack2Size - 1] == 'F') {
				Dbg("<PreOnline>, track2 data has F in the end.");
				card.track2[card.dwTrack2Size - 1] = '\0';
			}
			csMagT2Track = card.track2;
		}
		if (card.dwTrack3Size > 0 && card.dwTrack3Size < 108)
		{
			if (card.track3[card.dwTrack3Size - 1] == 'F')
			{
				Dbg("<PreOnline>, track3 data has F in the end.");
				card.track3[card.dwTrack3Size - 1] = '\0';
			}
			csMagT3Track = card.track3;
		}
		//oilyang@20180516 add for kaku
		//split track 2&3 data
		char* pTmpMag2 = new char[128];
		ZeroMemory(pTmpMag2, 128);
		Track2Data track2Data;
		bool bT2OK, bT3OK;
		bT2OK = bT3OK = false;
		if (card.dwTrack2Size > 8 && strlen(card.track2) > 8)
			bT2OK = true;
		if (card.dwTrack3Size > 8 && strlen(card.track3) > 8)
			bT3OK = true;
		DecodeTracksData((const char*)csMagT2Track, card.dwTrack2Size, (const char*)csMagT3Track, card.dwTrack3Size, pTmpMag2, bT2OK, bT3OK);
		if ((SplitTrack2(pTmpMag2, track2Data) == 0))
		{
			csMagAccout = track2Data.t2Account;
			csMagRegion = track2Data.t2Region;
			csMagCardSerial = track2Data.t2CardSerial;
			csMagCVC = track2Data.t2CVC;
			csMagExpireDate = track2Data.t2ExpireDate;
		}
		delete[]pTmpMag2;
		m_pCardProcess->DataInit();
	}
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData,ctx->Req.businessData.GetLength());
	if (m_bSM)
	{
		Dbg("<PreOnline>, We support sm.");
		m_pCardProcess->SplitBusinessData("DF690101",strlen("DF690101"));
	}
	int activeCardType;
	//oilyang@20201014 add emv card support
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		Dbg("<PreOnline>, the front BusinessData han't provide aid data.");

		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList, activeCardType);
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		Dbg("<PreOnline>, the aid from bussiness is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, preAIDs, activeCardType);
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	Dbg("<PreOnline>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		if ((m_csMachineType.Compare("RVC.CardStore") == 0|| m_csMachineType.Compare("RVC.CardPrinter") == 0)
			&& bCrossPreOnline)
			AfterPreOnlineOnStore(Error_Unexpect, slot);
		if (retDetectAndRead == -1) {
			SetErrPackage(m_errPkg, "PreOnline::DetectAndReadICData:DetectIfICCard", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ActiveICCard);
			ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		}
		else if (retDetectAndRead == -2) {
			SetErrPackage(m_errPkg, "PreOnline::DetectAndReadICData:GetICDataFromCard", m_csDevSN, Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand);
			ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		}
		return 0;
	}
	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER,m_hDevHelper,taaResult,m_bOnlineOnly,m_bCDA,bt9f27);
	Dbg("<PreOnline>, TermActionAnalyze, retTAA:%d, taaResult:%s", retTAA, taaResult.GetData());
	switch(retTAA)
	{//to be added oiltmp 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.result = taaResult;
	//	Dbg("[%d,%d,%d,%d]",m_TVR[0],m_TVR[1],m_TVR[2],m_TVR[3]);
	//}
	if (ctx->Ans.result.GetLength() == 0)
	{
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0)
			&& bCrossPreOnline)
			AfterPreOnlineOnStore(Error_Unexpect, slot);
		ctx->Answer(Error_Succeed);
		return 0;
	}
	
	//char tmpResult[1024,]result[1024];
	//ZeroMemory(tmpResult,sizeof(tmpResult));
	//ZeroMemory(result,sizeof(result));
	//memcpy(tmpResult,ctx->Ans.result,ctx->Ans.result.GetLength());
	string tmpResult,actionType,result = "",baseICData = "";
	tmpResult = ctx->Ans.result;
	char *pSomeICData = new char[ONE_K];
	ZeroMemory(pSomeICData, ONE_K);
	int lenRet = m_pCardProcess->ConstructARQCData(tmpResult.substr(6,4).c_str(),m_pDataToARQC,pSomeICData);
	baseICData = pSomeICData;
	if (pSomeICData != NULL)
		delete []pSomeICData;
	char arqcLen[8];
	ZeroMemory(arqcLen,sizeof(arqcLen));
	_itoa(lenRet,arqcLen,10);
	ICData appExpiryDate(false,0x5f,0x24);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,appExpiryDate,false,0) == -1)
	{
		Dbg("<PreOnline>, can't find expire date");
		if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0)
			&& bCrossPreOnline)
			AfterPreOnlineOnStore(Error_Unexpect, slot);
		return 0;
	}
	char *pExpireDate = new char[12];
	ZeroMemory(pExpireDate,12);
	HexBuf2StrBuf(appExpiryDate.value,&pExpireDate,appExpiryDate.lenth);
	ICData track2(false,0x57,0x00),ICCardSerial(false,0x5f,0x34);
	ErrorCodeEnum eErr = Error_Unexpect;
	string t2ICAccount(""),t2ICCardSerial(""),t2ICCVC(""),t2ICTrack2(""),cardType("0");
	char *pICCardSerial = new char[4];
	ZeroMemory(pICCardSerial,4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,ICCardSerial,false) == -1)
	{
		Dbg("<PreOnline>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value,&pICCardSerial,ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,track2,false,0) == -1)
	{
		Dbg("<PreOnline>, [ic]no track2 data");
		eErr = m_hDevHelper->ReleaseIC();
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "PreOnline::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
			AlarmDEC(m_errPkg);
		}
	}
	else
	{
		int pos = FindHexCharPosition(track2.value,0x0d,track2.lenth);
		
		char *pICTrack2 = new char[128];
		ZeroMemory(pICTrack2,128);
		HexBuf2StrBuf(track2.value,&pICTrack2,track2.lenth);
		pICTrack2[37] = '\0';
		Dbg("ic.track2,pos:%d",pos);
		Dbg("pos:%d",pos);

		char *ddd = new char[40];
		memset(ddd,0,40);
		memcpy(ddd,pICTrack2,pos-1);

		char icTrack2Data[128];
		ZeroMemory(icTrack2Data,sizeof(icTrack2Data));

		Track2Data track2Data;
		track2Data.status = 0;
		track2Data.t2Account = "";
		cmdDecodeMag2(pICTrack2,icTrack2Data);
		if (SplitTrack2(icTrack2Data,track2Data) == 0)
		{
			t2ICAccount = track2Data.t2Account;
			//t2ICCardSerial = track2Data.t2CardSerial;
			t2ICCVC = track2Data.t2CVC;
			t2ICTrack2 = pICTrack2;
			Dbg("done(ic).");
			if (m_issueStatus)
			{
				m_mixedEx[m_currentHopper - 1] = 0;
				bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
				Dbg("<PreOnline>, set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
			}
		}
		if (_strnicmp(track2Data.t2Account,ddd,strlen(ddd)))
		{

			t2ICCVC = "";
			t2ICTrack2 = pICTrack2;
			t2ICAccount = (char*)ddd;
			Dbg("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length()-4, 4).c_str());
		}
		t2ICCardSerial = pICCardSerial;
		delete []ddd;
		delete []pICTrack2;
	}

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		Dbg("<PreOnline>, actionType:%s", actionType.c_str());
		actionType = "ARQC";
	}
	else
		actionType = "";
	//【55域】
	//	基本域：
	//	9F26	8b	应用密文AC
	//	9F27	1b	密文信息数据
	//	9F10	max.32b	发卡行应用数据IAD
	//	9F37	4b	不可预知数
	//	9F36	2b	应用交易计数器ATC
	//	95	5b	终端验证结果TVR
	//	9A	3cn	交易日期（6位有效数字，YYMMDD）
	//	9C	1cn	交易类型（2位有效数字）
	//	9F02	6cn	授权金额（12位有效数字）
	//	5F2A	2cn	交易货币代码（3位有效数字）
	//	82	2b	应用交互特征AIP
	//	9F1A	2cn	终端国家代码（3位有效数字）
	//	9F03	6cn	其他金额（12位有效数字）
	//	9F33	3b	终端性能 "E0C900"

	//	可选域：
	//添加9F26,9F27,9F10,9F33的数据
	char *pCID = new char[4];
	ZeroMemory(pCID, 4);
	HexBuf2StrBuf(&bt9f27, &pCID, 1);
	char *pIssueBankLen = new char[4];
	ZeroMemory(pIssueBankLen, 4);
	int len9f10 = tmpResult.length() - 26 - 4;
	int lenHigh, lenLow;
	len9f10 = len9f10 / 2;
	lenHigh = len9f10 / 16;
	lenLow = len9f10 % 16;
	BYTE bt9f10;
	bt9f10 = (lenHigh<<4) + lenLow;
	HexBuf2StrBuf(&bt9f10, &pIssueBankLen, 1);
	baseICData += "9F2608" + tmpResult.substr(10, 16) + "9F2701" + pCID +"9F10" + pIssueBankLen + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "9F3303" + "E0C900";
	result = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6,4) + "|" + "ARQCCODE," + tmpResult.substr(10,16) + "|"
		+ "MAC," + tmpResult.substr(26,tmpResult.length()-26-4) + "|" + "ARQCSIZE," + string(arqcLen) + "|" 
		+ "ARQCDATA," + m_pDataToARQC + "|EXPIREDATE," + pExpireDate + "|T2ACCOUNT," + t2ICAccount + "|T2CARDSERIAL," + t2ICCardSerial
		+ "|T2CVC," + t2ICCVC + "|T2TRACK2," + t2ICTrack2 + "|CARDCAT," + cardType + "|ICTAGS," + baseICData + "|MAGT2," + (const char*)csMagT2Track
		+ "|MAGT3," + (const char*)csMagT3Track + "|MAGACCOUNT," + (const char*)csMagAccout + "|MAGREGION," + (const char*)csMagRegion
		+ "|MAGCARDSERIAL," + (const char*)csMagCardSerial+ "|MAGCVC," + (const char*)csMagCVC+ "|MAGEXPIREDATAE," + (const char*)csMagExpireDate;
	ctx->Ans.result = result.c_str();
	string txtresult = "";
	txtresult = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6,4) + "|" + "ARQCCODE," + tmpResult.substr(10,16) + "|"
		+ "MAC," + tmpResult.substr(26,tmpResult.length()-26-4) + "|" + "ARQCSIZE," + string(arqcLen) + "|" 
		+ "ARQCDATA," + m_pDataToARQC + "|T2ACCOUNT(F6)," + t2ICAccount.substr(0, 6) + "|T2ACCOUNT(L4)," + t2ICAccount.substr(t2ICAccount.length()-4, 4)
		+ "|T2CARDSERIAL(len)," + t2ICCardSerial + "|CARDCAT," + cardType;
	m_currCardNo = t2ICAccount.c_str();
	Dbg("<PreOnline>, data to host(less)[%s],baseICData length:%d", txtresult.c_str(), baseICData.length());

	if (pCID != NULL)
		delete[]pCID;
	if (pIssueBankLen != NULL)
		delete[]pIssueBankLen;
	if (pExpireDate != NULL)
		delete []pExpireDate;

	if (m_pDataToARQC != NULL)
	{
		delete []m_pDataToARQC;
		m_pDataToARQC = NULL;
	}
	if ((m_csMachineType.Compare("RVC.CardStore") == 0 || m_csMachineType.Compare("RVC.CardPrinter") == 0)
		&& bCrossPreOnline)
		AfterPreOnlineOnStore(Error_Succeed, slot);
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	Dbg("<PostOnline>, post online data[%s]", (LPCTSTR)ctx->Req.data);
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data,strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER,m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER,m_hDevHelper,m_bCDA);
		if (transEnd == 0)
			csTransEnd = "TRANSEND,0";
		else if (transEnd == 1)
			csTransEnd = "TRANSEND,1";
	}
	else
		csTransEnd = "TRANSEND,1";
	ctx->Ans.result = csTransEnd;
	Dbg("<PostOnline>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	//PBYTE pData = new BYTE[MAX_IC_BUFFER_SIZE];
	//ZeroMemory(pData,MAX_IC_BUFFER_SIZE);
	//int size = StrBuf2HexBuf(ctx->Req.data,&pData);
	//if (size > 0)
	//m_pCardProcess->ExecuteIssuerScript(CARD_MACHINE_ISSUER,m_hDevHelper);
	//else
	//{
	//	Dbg("Wrong post on line data[%s]",ctx->Req.data);
	//	ctx->Answer(Error_Unexpect);
	//}
	ctx->Answer(Error_Succeed);
	return 0;
}

void CCardIssuerFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}
//void CCardIssuerFSM::LogErrInfo(const char* msgHead)
//{
//	DevErrorInfo errInfo;
//	ErrorCodeEnum eErr = m_hDevHelper->GetLastErr(errInfo);
//	if (eErr == Error_Succeed)
//		Dbg("%s,%s",msgHead,errInfo.szErrMsg);
//}
bool CCardIssuerFSM::FSMSetIssueFlag(int value)
{
	Dbg("FSMSetIssueFlag, value:%d,from file:%d", value, m_issueStatusFromFile);
	if (value == 0 && m_issueStatusFromFile >1)
	{
		//oilyang@20171220 如果曾经卡片卡住，但启动时没有发现卡片，则更新本次发卡方向但不写文件，以防后续卡片被移动到卡槽
		if (!m_hasCardWhileDevOpen)
		{
			Dbg("card jamed havn't been process.");
			m_issueStatus = 0;
		}
		else
			Dbg("insert succeed,but there maybe some card jamed...");
		return true;
	}
	
	m_issueStatus = value;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("(set issue)open cfg file failed!");
		return false;
	}
	if (spConfig->WriteConfigValueInt("RunInfo", "IsIssue", value) == Error_Succeed && spConfig->WriteConfigValueInt("all", "IsIssue", value) == Error_Succeed)
		return true;
	else
		return false;
}
bool CCardIssuerFSM::SetCardCaptured(const int num,bool bClear)
{
	Dbg("<SetCardCaptured>, num:%d, bClear:%d, m_maxRetainCount:%d, m_bSettingMaterial:%d",
		num, bClear, m_maxRetainCount, m_bSettingMaterial);
	if (num < 0)
	{
		Dbg("<SetCardCaptured>, wrong reset card captured");
		return false;
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("<SetCardCaptured>, open cfg file failed!");
		return false;
	}
	m_CardCaptured = num;
	if (num >= m_maxRetainCount)
	{
		//oilyang@20201223 according to rongyiheng,if is RVC.CardPrinter,no need to judge on retain count
		if (m_csMachineType.Compare("RVC.CardPrinter") != 0 && m_csMachineType.Compare("RVC.CardStore") != 0)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_RETAIN_BIN_IS_FULL, "<SetCardCaptured>, 回收箱满了，请及时清理!");
		}
	}
	if (spConfig->WriteConfigValueInt("RunInfo", "CardCaptured", num) == Error_Succeed
		&& spConfig->WriteConfigValueInt("all", "CardCaptured", num) == Error_Succeed)
	{
		if (bClear && !m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain);
		}
		return true;
	}
	else
		return false;
}
bool CCardIssuerFSM::SetCardIssued(const int num, const int hopper)
{
	Dbg("<SetCardIssued>, num :%d, hopper: %d, m_bSettingMaterial:%d", num, hopper, m_bSettingMaterial);
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("<SetCardIssued>, open cfg file failed!");
		return false;
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardIssued", num);
	if (eErrDev == Error_Succeed)
	{
		if (section.Compare("1") == 0)
			spConfig->WriteConfigValueInt("RunInfo", "CardIssued", num);
		//oilyang 回写新section
		if (hopper == 1)
		{
			int xNum = 0;
			spConfig->ReadConfigValueInt("all", "HopperNum", xNum);
			Dbg("<SetCardIssued>, xNum:%d", xNum);
			if (xNum == 0)
				spConfig->WriteConfigValueInt("all", "HopperNum", 1);
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		//if (m_hopperNum != 1 && !m_bSettingMaterial)
		if (!m_bSettingMaterial)
		{

			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
		return true;
	}
	else
	{
		Dbg("<SetCardIssued>, write CardIssued err:%d", eErrDev);
		return false;
	}
}
bool CCardIssuerFSM::SetCardRemains(const int num, const int hopper,bool bInit)
{
	Dbg("<SetCardRemains>, num:%d,, hopper:%d, bInit:%d, m_currentHopper:%d, m_bSettingMaterial:%d",
		num, hopper, bInit, m_currentHopper, m_bSettingMaterial);
	if (num == 0)
	{
		switch (hopper)
		{
		case 1:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper1, "Hopper 1 No card remains.");
			break;
		case 2:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper2, "Hopper 2 No card remains.");
			break;
		case 3:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper3, "Hopper 3 No card remains.");
			break;
		case 4:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper4, "Hopper 4 No card remains.");
			break;
		case 5:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper5, "Hopper 5 No card remains.");
			break;
		case 6:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NoCardRemains_Hopper6, "Hopper 6 No card remains.");
			break;
		default:
			break;
		}
		
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("<SetCardRemains>, open cfg file failed!");
		return false;
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardRemains", num);
	if (eErrDev == Error_Succeed)
	{
		if (bInit)
		{
			if (section.Compare("1") == 0)
				spConfig->WriteConfigValueInt("RunInfo", "CardInit", num);
			eErrDev = spConfig->WriteConfigValueInt(section, "CardInit", num);
		}
		if (section.Compare("1") == 0)
			spConfig->WriteConfigValueInt("RunInfo", "CardRemains", num);
		if (eErrDev != Error_Succeed)
		{
			Dbg("<SetCardRemains>, write CardInit err:%d", eErrDev);
			return false;
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		//if (m_hopperNum != 1 && !m_bSettingMaterial)
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
	}
	else
	{
		Dbg("<SetCardRemains>, write CardRemains err:%d", eErrDev);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::SetCardMixed(const int num, const int hopper)
{
	Dbg("<SetCardMixed>, num:%d, hopper:%d, m_bSettingMaterial:%d", num, hopper, m_bSettingMaterial);
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("<SetCardMixed>, open cfg file failed!");
		return false;
	}
	if (num == 0)
		SetDevStateAndSendMsg(DEVICE_STATUS_NORMAL);
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardMixed", num);
	if (section.Compare("1") == 0)
		spConfig->WriteConfigValueInt("RunInfo", "CardMixed", num);
	if (eErrDev != Error_Succeed)
	{
		Dbg("<SetCardMixed>, write CardMixed err:%d", eErrDev);
		return false;
	}
	//oilyang@20170428 汪磊东要求单卡箱也要同步数据
	//if (m_hopperNum != 1 && !m_bSettingMaterial)
	if (!m_bSettingMaterial)
	{
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		SyncDataToDB(bMaintain,false);
	}
	return true;

}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardBackNotHold()
{
	LOG_FUNCTION();
	ErrorCodeEnum eMoveNotHold = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
	Dbg("capture card:%d",eMoveNotHold);
	//2016-11-10 14:30:54 joseph
	if (eMoveNotHold != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "MachineMoveCardBackNotHold::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)", m_csDevSN, eMoveNotHold, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD);
		AlarmDEC(m_errPkg);
		return eMoveNotHold;
	}
	//oilyang@20170929 根据讨论结果，去掉调用

	//2016-11-10 14:34:44 joseph
	//GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;

	//pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
	//ErrorCodeEnum eAddMaterial = pGuiConsoleClient->Connect();
	//if (eAddMaterial == Error_Succeed)
	//{
	//	if (pGuiConsoleClient)
	//	{
	//		Dbg("to add material counter.");
	//		GUIConsoleService_AddMaterialCounter_Req req;
	//		GUIConsoleService_AddMaterialCounter_Ans ans;
	//		req.strMaterialCode = "RetainCard";
	//		eAddMaterial = pGuiConsoleClient->AddMaterialCounter(req, ans, 10000);
	//		Dbg("%d", eAddMaterial);
	//		if (pGuiConsoleClient != NULL)
	//		{
	//			pGuiConsoleClient->GetFunction()->CloseSession();
	//			pGuiConsoleClient->SafeDelete();
	//			pGuiConsoleClient = NULL;
	//		}
	//	}
	//}
	return eMoveNotHold;
}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardFrontGate()
{
	LOG_FUNCTION();
	ErrorCodeEnum eMoveFrontGate = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
	if (eMoveFrontGate != Error_Succeed) {
		SetErrPackage(m_errPkg, "MachineMoveCardFrontGate::MoveCard(CI_MOVECARD_FRONT_GATE)", m_csDevSN, eMoveFrontGate, MEC_DEVAPI_CARDISSUER_MoveCard);
		AlarmDEC(m_errPkg);
	}
	return eMoveFrontGate;
}
int CCardIssuerFSM::QueryCardInfo()
{
	int ret;
	if (m_hDevHelper == NULL)
		ret = 1;
	else {
		if (GetDevStatus())
			ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 2 : 0;
		else
			ret = 1;
	}
	Dbg("QueryCardInfo, ret:%d", ret);
	return ret;
		
}

int CCardIssuerFSM::ConnectSCI()
{
	LOG_FUNCTION();
	Dbg("ConnectSCI, m_bDoingQueryListOrBindSCI:%d, m_bUnbindType3:%d, m_csDevSN:%s",
		m_bDoingQueryListOrBindSCI, m_bUnbindType3, m_csDevSN.GetData());
	if (m_bDoingQueryListOrBindSCI || m_bUnbindType3)
	{
		Dbg("in doing query list or bind sci or have unbind:(doingOrBind)%d,(unbind)%d",
			m_bDoingQueryListOrBindSCI, m_bUnbindType3);
		return Error_InvalidState;
	}
	ErrorCodeEnum errCode = Error_Unexpect;
	CSimpleStringA errMsg(true);
	BYTE btOpenType = DEV_OPEN_TYPE_BLUETOOTH | DEV_OPEN_TYPE_USB;//oiltmp for change
	if ((btOpenType & DEV_OPEN_TYPE_BLUETOOTH) == DEV_OPEN_TYPE_BLUETOOTH) {
		m_bBTConncting = true;
	}
	if (IsValidSCIName(m_csDevSN, m_csDevSN.GetLength()))
	{
		errCode = OpenDevice(btOpenType, m_csDevSN);
		if (errCode != Error_Succeed) {
			errMsg = CSimpleStringA::Format("ConnectSCI::OpenDevice failed:%d(0x%x)", errCode, errCode);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ConnecetSCI_OpenDevice_Failed, errMsg.GetData());
			CloseAndClearDevObj(false);
		}
	} else {
		errMsg = CSimpleStringA::Format("ConnectSCI, Invalid DeviceSN name(%s)", m_csDevSN.GetData());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ConnecetSCI_Invalid_SCI_Name, errMsg.GetData());
		errCode = Error_DataCheck;
	}
	m_bBTConncting = false;
	return errCode;
}
//判断是否配置了便携发卡机
int CCardIssuerFSM::QueryIfCfgSCI()
{
	Dbg("QueryIfCfgSCI, m_csDevSN:%s", m_csDevSN.GetData());
	if (m_csDevSN.GetLength() > 2)
		return 1;
	else
		return 0;
}
int CCardIssuerFSM::SetDevStateAndSendMsg(const DevStateEnum eState, bool bForceSend)
{
	Dbg("SetDevStateAndSendMsg, m_eDevState:%d, eState:%d, bForceSend:%d", m_eDevState, eState, bForceSend);
	if(m_eDevState != eState || bForceSend) {
		SCIConnect evt;
		evt.status = m_eDevState = eState;
		SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(SCIConnect), SP_MSG_SIG_OF(SCIConnect), evt);
	}
	return 0;
}
int CCardIssuerFSM::DataTransferInitEx()
{
	LOG_FUNCTION();
	AccessAuthService_ClientBase *pAccessAuthClient = new AccessAuthService_ClientBase(GetEntityBase());
	if (pAccessAuthClient == NULL)
	{
		Dbg("<DataTransferInitEx>, Create AccessAuthService_ClientBase failed.");
		return -1;
	}
	ErrorCodeEnum eErr = pAccessAuthClient->Connect();
	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Connect_Access_Failed, "DataTransferInitEx::Connect failed.");
		return -1;
	}
	Dbg("Connect to AccessAuth ok.");
	ZeroMemory(m_priKey, ONE_K / 2);
	//AsciiToHex("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45", m_priKey, strlen("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45"));
	memcpy(m_priKey, "16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45", strlen("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45"));
	int iStatus;
	BYTE *Cr1, *Cr3, *dKey;
	Cr1 = new BYTE[ONE_K / 4];
	Cr3 = new BYTE[ONE_K / 4];
	dKey = new BYTE[ONE_K / 4];
	ZeroMemory(Cr1, ONE_K / 4);
	ZeroMemory(Cr3, ONE_K / 4);
	ZeroMemory(dKey, ONE_K / 4);
	int lenCr1, lenCr3, lenDKey;
	bool bFirstFailed = false;
	Dbg("TransferEnInit start...");
	eErr = m_hDevHelper->TransferEnInit(iStatus, Cr1, lenCr1, Cr3, lenCr3, dKey, lenDKey);
	Dbg("DataTransferInitEx, iStatus:%d, lenCr1:%d,lenCr3:%d,lenDKey:%d",
		iStatus, lenCr1, lenCr3, lenDKey);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "DataTransferInitEx::TransferEnInit", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_TransferEnInit);
		AlarmDEC(m_errPkg);
		return 1;
	}

	if (lenCr1 < 0 || lenCr3 < 0 || lenDKey < 0)
		return 1;
	ZeroMemory(m_r1, ONE_K / 8);
	char tmpCr1[2048], tmpCr3[2048], tmpDKey[2048];
	ZeroMemory(tmpCr1, ONE_K * 2);
	ConvAscii(Cr1, tmpCr1, lenCr1);
	ZeroMemory(tmpCr3, ONE_K * 2);
	ConvAscii(Cr3, tmpCr3, lenCr3);
	ZeroMemory(tmpDKey, ONE_K * 2);
	ConvAscii(dKey, tmpDKey, lenDKey);

	char random_key[128];
	unsigned char tbuf[4096];
	char encrnd[1024];
	int encdatalen;
	int iloop;
	//取随机因子
	srand((int)time(NULL));
	for (iloop = 0; iloop < 32; iloop++)
		tbuf[iloop] = rand() % 256;
	ConvAscii(tbuf, random_key, 32);
	//随机数2

	BYTE r2[16];
	ZeroMemory(r2, 16);
	for (int i = 0; i < 15; ++i)
	{
		srand((int)time(NULL));
		unsigned int ram = rand();
		r2[i] = ram % 256;
		r2[15] ^= r2[i];
		m_r2[i] = r2[i];
	}
	m_r2[15] = r2[15];
	char *xxxR2 = new char[256];
	ZeroMemory(xxxR2, 256);
	ConvAscii(r2, xxxR2, 16);

	AccessAuthService_InitDev_Req req;
	AccessAuthService_InitDev_Ans ans;
	req.EncR1 = tmpCr1;
	req.EncR3 = tmpCr3;
	req.EncDevPubKey = tmpDKey;
	req.R2 = xxxR2;
	req.Vendor = m_devCat.szVendor;
	Dbg("to InitDev(%s).", m_devCat.szVendor);
	eErr = pAccessAuthClient->InitDev(req, ans, 5000);
	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invoke_Access_IniDev_Failed, "DataTransferInitEx::InitDev failed.");
		if (Cr1 != NULL)
			delete[]Cr1;
		if (Cr3 != NULL)
			delete[]Cr3;
		if (dKey != NULL)
			delete[]dKey;
		return -1;
	}
	
	if (Cr1 != NULL)
		delete[]Cr1;
	if (Cr3 != NULL)
		delete[]Cr3;
	if (dKey != NULL)
		delete[]dKey;
	//Dbg("Cr2:%d,%s",ans.EncR2.GetLength(),(const char*)ans.EncR2);
	//Dbg("oiltest %s,%s",(const char*)ans.R1,(const char*)ans.R3);
	unsigned char *xxxCR2 = new unsigned char[512];
	ZeroMemory(xxxCR2, 512);
	AsciiToHex(const_cast<char*>(ans.EncR2.GetData()), xxxCR2, ans.EncR2.GetLength());
	eErr = m_hDevHelper->SetR2(iStatus, xxxCR2, ans.EncR2.GetLength() / 2);
	Dbg("DataTransferInitEx, iStatus:%d, encR2.length:%d",
		iStatus, ans.EncR2.GetLength());
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "DataTransferInitEx::SetR2", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetR2);
		AlarmDEC(m_errPkg);
		return 3;
	}
	
	AsciiToHex(const_cast<char*>(ans.R1.GetData()), m_r1, ans.R1.GetLength());
	AsciiToHex(const_cast<char*>(ans.R3.GetData()), m_r3, ans.R3.GetLength());
	int lenrandom1, lenrandom2, lenrandom3;
	lenrandom1 = lenrandom2 = lenrandom3 = 16;

	int ilen = 0;
	char databuf[2048];
	char key[128];

	memset(databuf, 0, sizeof(databuf));
	memset(tbuf, 0, sizeof(tbuf));

	memcpy(databuf, m_r2, lenrandom2);
	for (iloop = 0; iloop < 64; iloop++)
		databuf[iloop] ^= 0x5C;
	memcpy(tbuf, m_r2, lenrandom2);
	for (iloop = 0; iloop < 64; iloop++)
		tbuf[iloop] ^= 0x36;
	ilen = 64;
	memcpy(tbuf + ilen, "KEY", strlen("KEY"));
	ilen += strlen("KEY");
	memcpy(tbuf + ilen, m_r1, lenrandom1);
	ilen += lenrandom1;
	memcpy(tbuf + ilen, m_r3, lenrandom3);
	ilen += lenrandom3;
	SM3Hash((unsigned char *)tbuf, ilen, (unsigned char *)(databuf + 64));
	SM3Hash((unsigned char *)databuf, 96, (unsigned char *)key);
	char *sessionKey = new char[1024];
	ZeroMemory(sessionKey, 1024);
	HexBuf2StrBuf((unsigned char *)key, &sessionKey, 16);
	//Dbg("oiltest key[%s]", sessionKey);

	eErr = m_hDevHelper->SendWorkingKey(sessionKey);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "DataTransferInitEx::SendWorkingKey", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SendWorkingKey);
		AlarmDEC(m_errPkg);
		return 4;
	}
	return 0;
}
int CCardIssuerFSM::LoadSafeLockDll()
{
#ifdef RVC_OS_WIN
	CSimpleStringA csDepPath, csBackslash("\\"), csSafelockDll, csSafelockDllDukpt;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
	csSafelockDll = csDepPath + csBackslash + "JNIDUKPT.dll";
	csSafelockDllDukpt = csDepPath + csBackslash + "Dukpt.dll";
	HMODULE m_hModule = LoadLibraryA(csSafelockDll);
	if (m_hModule == NULL)
	{
		Dbg("load JNIDUKPT.dll failed with errCode %d", GetLastError());
	}
	if ((EncypteDukptHSM = (pfEncryptDukptHSM)GetProcAddress(m_hModule, "EncryptDukptHSM")) == NULL)
	{
		Dbg("Get function EncryptDukptHSM failed.%d", GetLastError());
	}
	HMODULE m_hModuleDukpt = LoadLibraryA(csSafelockDllDukpt);
	if (m_hModuleDukpt == NULL)
	{
		Dbg("load Dukpt.dll failed.%d", GetLastError());
	}
	if ((GetEncrypedData = (pfGetEncrypedData)GetProcAddress(m_hModuleDukpt, "GetEncrypedData")) == NULL)
	{
		Dbg("Get function GetEncrypedData failed.%d", GetLastError());
	}
	Dbg("Load SafeLock dll ok.");
#endif //RVC_OS_WIN
	return 0;
}
void two_one(unsigned char *in, int in_len, unsigned char *out) {
	unsigned char tmpc;
	int i;

	for (i = 0; i<in_len; i += 2) {
		tmpc = in[i];
		tmpc = toupper(tmpc);
		if ((tmpc < '0' || tmpc > '9') && (tmpc < 'A' || tmpc > 'F'))
			tmpc = 'F';
		if (tmpc > '9')
			tmpc = toupper(tmpc) - 'A' + 0x0A;
		else
			tmpc -= '0';
		tmpc <<= 4;
		out[i / 2] = tmpc;

		tmpc = in[i + 1];
		tmpc = toupper(tmpc);
		if ((tmpc < '0' || tmpc > '9') && (tmpc < 'A' || tmpc > 'F'))
			tmpc = 'F';
		if (tmpc > '9')
			tmpc = toupper(tmpc) - 'A' + 0x0A;
		else
			tmpc -= '0';
		out[i / 2] |= tmpc;
	}
}
void one_two(unsigned char *in, int in_len, unsigned char *out) {
	unsigned char  i;
	static unsigned char TAB[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
	for (i = 0; i < in_len; i++) {
		out[i * 2] = TAB[in[i] >> 4];
		out[i * 2 + 1] = TAB[in[i] & 0x0f];
	}
}
static char DecCh2HexCh(BYTE c)
{
	if (c >= 0x0 && c <= 0x9)
		return c + '0';
	else if (c >= 0xa && c <= 0xf)
		return c + 'a' - 10;
	else
		return 0;
}
int CCardIssuerFSM::EncryptData(SCITempData ramData, SCITempData bdk, SCITempData curksn, SCITempData &encryptedData)
{
	BYTE ram[64];
	ZeroMemory(ram, 64);
	Dbg("<EncryptData>, ramData:%d, bdk:%d, curksn:%d", ramData.dwSize, bdk.dwSize, curksn.dwSize);
	for (int i = 0, j = 0; i < ramData.dwSize; ++i)
	{
		ram[j++] = DecCh2HexCh((ramData.data[i] & 0xf0) >> 4);
		ram[j++] = DecCh2HexCh(ramData.data[i] & 0x0f);
	}
	//PBYTE pTmpBDK = new BYTE[64];
	//PBYTE pTmpKSN = new BYTE[64];
	BYTE pTmpBDK[64], pTmpKSN[64];
	ZeroMemory(pTmpBDK, 64);
	ZeroMemory(pTmpKSN, 64);
	//HexBuf2StrBuf(bdk.data, (char**)&pTmpBDK, bdk.dwSize);
	//HexBuf2StrBuf(curksn.data, (char**)&pTmpKSN, curksn.dwSize);
	//PBYTE pData = new BYTE[64];
	one_two(bdk.data, bdk.dwSize, pTmpBDK);
	one_two(curksn.data, curksn.dwSize, pTmpKSN);
	BYTE pData[64];
	ZeroMemory(pData, 64);
	Dbg("to EncypteDukptHSM");
	if (EncypteDukptHSM != NULL)
		EncypteDukptHSM(ram, pTmpBDK, pTmpKSN, pData);
	Dbg("to two_one");
	two_one(pData, 16, encryptedData.data);
	Dbg("end two_one");
	//if (pTmpBDK != NULL)
	//{
	//	delete[]pTmpBDK;
	//	pTmpBDK = NULL;
	//}
	//if (pTmpKSN != NULL)
	//{
	//	delete[]pTmpKSN;
	//	pTmpKSN = NULL;
	//}
	//if (pData != NULL)
	//{
	//	delete[]pData;
	//	pData = NULL;
	//}
	Dbg("encrypt ok.");
	encryptedData.dwSize = 8;
	return 0;
}
int CCardIssuerFSM::OpenSafeLock(SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	bool bOpenSuc = false;
	SCITempData ksnData, ramData;
	ErrorCodeEnum eErr = Error_Succeed;
	eErr = m_hDevHelper->SLGetTempData(ksnData, ramData);
	//ksnData.dwSize = 7;
	//ksnData.data[0] = 0x00;
	//ksnData.data[1] = 0x00;
	//ksnData.data[2] = 0x00;
	//ksnData.data[3] = 0x01;
	//ksnData.data[4] = 0x00;
	//ksnData.data[5] = 0x00;
	//ksnData.data[6] = 0x2B;
	//ramData.dwSize = 4;
	//ramData.data[0] = 0xA8;
	//ramData.data[1] = 0x25;
	//ramData.data[2] = 0x36;
	//ramData.data[3] = 0x84;
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "OpenSafeLock::SL_GetTempData", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SLGetTempData);
		AlarmDEC(m_errPkg);
	}
	Dbg("Get temp data ok %d,%d.",ksnData.dwSize,ramData.dwSize);
	//char *tmpStr = new char[128];
	//ZeroMemory(tmpStr, 128);
	//HexBuf2StrBuf(ksnData.data, (char**)&tmpStr, ksnData.dwSize);
	//ZeroMemory(tmpStr, 128);
	//HexBuf2StrBuf(ramData.data, (char**)&tmpStr, ramData.dwSize);
	const int cmdSize = 26;
	BYTE tmp[cmdSize] = { 0xaa, 0xaa, 0xaa, 0xaa, 0xbb, 0xbb, 0xbb, 0xbb, 0xcc, 0xcc, 0xcc, 0xcc, 0xdd, 0xdd, 0xdd, 0xdd,
		0x11, 0x22, 0x33, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00 };
	ZeroMemory(m_bdk, sizeof(m_bdk));
	ZeroMemory(m_ksn, sizeof(m_ksn));
	memcpy(m_bdk, tmp, 16);
	memcpy(m_ksn, tmp + 16, 10);


	//SCITempData bdk, ksn, enData;
	//memcpy(bdk.data, m_bdk, 16);
	//bdk.dwSize = 16;
	//memcpy(ksn.data, m_ksn, 3);
	//memcpy(ksn.data + 3, ksnData.data, 7);
	//ksn.dwSize = 10;
	BYTE ramAllData[64];
	ZeroMemory(ramAllData, 64);
	memcpy(ramAllData, ksnData.data, 7);
	memcpy(ramAllData + 7, ramData.data, 4);
	SCITempData enData;
	int ret;
	Dbg("to encrypt data");
	ZeroMemory(enData.data, 64);
	//ret = EncryptData(ramData, bdk, ksn, enData);
	if (GetEncrypedData != NULL)
		ret = GetEncrypedData(m_bdk, m_ksn, ramAllData, enData.data);
	enData.dwSize = 8;
	//if (eErr == Error_Succeed)
	{
		Dbg("to open door");
		eErr = m_hDevHelper->SLOpenDoor(enData);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "OpenSafeLock:SLOpenDoor", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SLOpenDoor);
			AlarmDEC(m_errPkg);
		}
		else
		{
			bOpenSuc = true;
			Dbg("Open SafeLock ok.");
		}
	}
	//else
	//{
	//	Dbg("EncryptData failed.%d", eErr);
	//	LogDevErrorInfo();
	//}
	if (ctx != NULL)
	{
		if (bOpenSuc)
			ctx->Answer(Error_Succeed);
		else {
			SetErrPackage(m_errPkg, "OpenSafeLock::SLOpenDoor", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SLOpenDoor);
			ctx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
		}
	}
	return 0;
}
int CCardIssuerFSM::GetSCIInfo(char *&devSN)
{
	Dbg("<GetSCIInfo>, m_machineType:%d, m_bBTConnected:%d", m_machineType, m_bBTConnected);
	if (m_machineType == 3)
	{
		Dbg("No CFG SCI");
		return -1;
	}
	else if (m_machineType == 2 && !m_bBTConnected)
	{
		Dbg("SCI not connected.");
		return -2;
	}
	//if (m_csDevSN.GetLength() > 1)
	if(QueryIfCfgSCI()) {
		strncpy(devSN, (const char*)m_csDevSN, m_csDevSN.GetLength());
	}
	else {
		//devSN = "";
		strcpy(devSN, "");
	}
	return 0;
}
int CCardIssuerFSM::UpdateLocalRunCfg(CAutoArray<int> hopperArr)
{
	LOG_FUNCTION();
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("(UpdateLocalRunCfg)open cfg file failed!");
		return false;
	}
	Dbg("hopperArr num:%d", hopperArr.GetCount());
	char sec[2];
	for (int i = 0; i < hopperArr.GetCount(); ++i)
	{
		ZeroMemory(sec, 2);
		_itoa(i + 1, (char*)sec, 10);
		if (hopperArr[i] == 1)
		{
			spConfig->WriteConfigValue(sec, "CardBoxNo", m_CardBoxNoEx[i]);
			spConfig->WriteConfigValue(sec, "PsbCode", m_PsbCodeEx[i]);
			spConfig->WriteConfigValue(sec, "PsbName", m_PsbNameEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardInit", m_CardInitEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardRemains", m_remainsEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardIssued", m_issuedEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardMixed", m_mixedEx[i]);
			spConfig->WriteConfigValueInt(sec, "CardPercent", m_CardPercentEx[i]);
			spConfig->WriteConfigValue(sec, "Maintainer", m_MaintainerEx[i]);
			spConfig->WriteConfigValue(sec, "MaintainTime", m_csMaintainTimeEx[i]);
			if (i == 0 && hopperArr[0] == 1)
			{
				spConfig->WriteConfigValueInt("RunInfo", "CardInit", m_CardInitEx[i]);
				spConfig->WriteConfigValueInt("RunInfo", "CardRemains", m_remainsEx[i]);
				spConfig->WriteConfigValueInt("RunInfo", "CardIssued", m_issuedEx[i]);
				spConfig->WriteConfigValueInt("RunInfo", "CardMixed", m_mixedEx[i]);
				spConfig->WriteConfigValueInt("RunInfo", "CardPercent", m_CardPercentEx[i]);
			}
			Dbg("UpdateLocalRunCfg, sec:%s,CardBoxNo:%s,CardInit:%d,CardRemains:%d,CardIssued:%d",
				sec, m_CardBoxNoEx[i].GetData(), m_CardInitEx[i], m_remainsEx[i], m_issuedEx[i]);
		}
	}
	return 0;
}
int CCardIssuerFSM::SyncDataToDB(bool bMaintain[12], bool bSetCaptured)
{
	LOG_FUNCTION();
	GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;
	//pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
	pGuiConsoleClient = new GUIConsoleService_ClientBase((GetEntityBase()));
	ErrorCodeEnum eConn = Error_Unexpect;
	if (pGuiConsoleClient != NULL)
	{
		eConn = pGuiConsoleClient->Connect();
		if (eConn != Error_Succeed) {
			Dbg("<SyncDataToDB>, Connect to GUIConsole failed:%d", eConn);
			pGuiConsoleClient->SafeDelete();
		}
	}
	else
		Dbg("<SyncDataToDB>, create a guiconsole pointer failed.");
	if (eConn != Error_Succeed)
	{
		Dbg("SyncDataToDB can't connect to GUIConsole.");
		pGuiConsoleClient = NULL;
		return -1;
	}

	GUIConsoleService_SyncMaterialCount_Info info = {};
	info.dwCardBoxNum = m_hopperNum;
	if (_strnicmp("RVC.Stand2S", m_csMachineType, strlen("RVC.Stand2S")) == 0
		|| _strnicmp("RVC.CardStore", m_csMachineType, strlen("RVC.CardStore")) == 0
		|| _strnicmp("RVC.CardPrinter", m_csMachineType, strlen("RVC.CardPrinter")) == 0)
	{
		Dbg("%s",(const char*)m_csMachineType);
		info.strDeviceNo = m_terminalNo;
	}
	else
		info.strDeviceNo = m_csDevSN;
	//if (pDevSN != NULL)
	//	delete[]pDevSN;
	Dbg("<SyncDataToDB>, to init sync info[%d][%s]", info.dwCardBoxNum,(const char*)info.strDeviceNo);
	info.arrMaintainFlag.Init(m_hopperNum+1);
	info.arrMaintainer.Init(m_hopperNum+1);
	info.arrMaintainTime.Init(m_hopperNum+1);
	info.arrCardBoxNo.Init(m_hopperNum+1);
	info.arrPsbCode.Init(m_hopperNum+1);
	info.arrPsbName.Init(m_hopperNum+1);
	info.arrCardInit.Init(m_hopperNum+1);
	info.arrCardRemains.Init(m_hopperNum+1);
	info.arrCardIssued.Init(m_hopperNum+1);
	info.arrCardMixed.Init(m_hopperNum+1);
	info.arrCardPercent.Init(m_hopperNum+1);
	
	for (int i = 0; i < m_hopperNum; ++i)
	{
		//[17:36 : 30.353][DEBUG] Debug: {0, SP01010101, 0, NX00000002, 47N2, IC金卡2, 100, 10, 1, 0, 10}
		info.arrMaintainFlag[i] = bMaintain[i];
		info.arrMaintainer[i] = m_MaintainerEx[i];
		info.arrMaintainTime[i] = m_MaintainTimeEx[i];
		info.arrCardBoxNo[i] = m_CardBoxNoEx[i];
		info.arrPsbCode[i] = m_PsbCodeEx[i];
		info.arrPsbName[i] = m_PsbNameEx[i];
		info.arrCardInit[i] = m_CardInitEx[i];
		info.arrCardRemains[i] = m_remainsEx[i];
		info.arrCardIssued[i] = m_issuedEx[i];
		info.arrCardMixed[i] = m_mixedEx[i];
		info.arrCardPercent[i] = m_CardPercentEx[i];

		Dbg("hopper(%d), Maintain:%d, MaintainerEx:%s, MaintainTimeEx:%d, CardBoxNoEx:%s, PsbCodeEx:%s, PsbNameEx:%s, CardInitEx:%d, RemainsEx:%d, IssuedEx:%d, MixedEx:%d, CardPercentEx:%d",
			i, bMaintain[i],
			m_MaintainerEx[i].GetData(),
			m_MaintainTimeEx[i],
			m_CardBoxNoEx[i].GetData(),
			m_PsbCodeEx[i].GetData(),
			m_PsbNameEx[i].GetData(),
			m_CardInitEx[i],
			m_remainsEx[i],
			m_issuedEx[i],
			m_mixedEx[i],
			m_CardPercentEx[i]);
	}
	
	{
		if (bSetCaptured) {
			Dbg("<SyncDataToDB>, bSetCaptured:%d", bSetCaptured);
			info.arrMaintainFlag[m_hopperNum] = 1;
		}
		else
			info.arrMaintainFlag[m_hopperNum] = 0;
		info.arrCardRemains[m_hopperNum] = m_CardCaptured;
		info.arrMaintainer[m_hopperNum] = m_MaintainerEx[0];
		info.arrMaintainTime[m_hopperNum] = m_MaintainTimeEx[0];

		info.arrCardBoxNo[m_hopperNum] = "";
		info.arrPsbCode[m_hopperNum] = "";
		info.arrPsbName[m_hopperNum] = "";
		info.arrCardInit[m_hopperNum] = 0;
		info.arrCardIssued[m_hopperNum] = 0;
		info.arrCardMixed[m_hopperNum] = 0;
		info.arrCardPercent[m_hopperNum] = 0;
		Dbg("MaintainFlag:%d, CardRemains:%d, Maintainer:%s, MaintainTime:%d",
			info.arrMaintainFlag[m_hopperNum],
			info.arrCardRemains[m_hopperNum],
			info.arrMaintainer[m_hopperNum].GetData(),
			info.arrMaintainTime[m_hopperNum]);
	}
	
	if (pGuiConsoleClient != NULL)
	{
		eConn = pGuiConsoleClient->SyncMaterialCount(info);
		pGuiConsoleClient->GetFunction()->CloseSession();
		pGuiConsoleClient = NULL;

		if (eConn != Error_Succeed) {
			CSimpleStringA errMsg = CSimpleStringA::Format("<SyncDataToDB>, SyncMaterialCount returned with errCode:%d", eConn);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, errMsg.GetData());
			return -2;
		}
	}
	else
	{
		Dbg("pGuiConsoleClient is null? unexpect error.");
		return -3;
	}
	return 0;
}
void CCardIssuerFSM::SetHopperNum(int hopperNum)
{
	Dbg("SetHopperNum, hopperNum:%d", hopperNum);
	m_hopperNum = hopperNum;
}
int CCardIssuerFSM::BluetoothCheck()
{
	m_bBTChecking = 2;
	ErrorCodeEnum eErr = Error_Unexpect;
	int count = 0;
	BYTE *pSig = new BYTE[3];
	Dbg("<BluetoothCheck>, m_bBTConnected:%d, m_bInMainPage:%d", m_bBTConnected, m_bInMainPage);
	while (2 == m_bBTChecking)
	{
		Sleep(5000);
		if (m_hDevHelper != NULL && m_bBTConnected && m_bInMainPage)
		{
			ZeroMemory(pSig, 3);
			eErr = m_hDevHelper->BluetoothGetSignalStrength(pSig);
			Dbg("BluetoothGetSignalStrength, %d,%d,%d", eErr, pSig[0],pSig[1]);
			if (eErr != Error_Succeed)
			{
				SetErrPackage(m_errPkg, "BluetoothCheck::BluetoothGetSignalStrength", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_BluetoothGetSignalStrength);
				AlarmDEC(m_errPkg);
				count++;
				if (count >= 2)
				{
					Dbg("CardIssuer(SCI) device disconnecetd, DevClose returned %d, send bluetooth disonnect event!", m_hDevHelper->DevClose());
					m_bBTConnected = false;
					count = 0;
					FSMEvent *pEvt = new FSMEvent(USER_EVT_BLUETOOTH_DISCONNECT);
					PostEventFIFO(pEvt);
					assert(m_bBTConncting == FALSE);
				}
			}
		}
	}
	if(pSig) {
		delete pSig;
	}
	m_bBTChecking = 0;
	return 0;
}
void CCardIssuerFSM::DoExitWhenIdle()
{
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	Dbg("DoExitWhenIdle, m_devStatus.eMedia:%d", m_devStatus.eMedia);
	if (eErr == Error_Succeed)
	{
		if (m_devStatus.eMedia == CI_MEDIA_PRESENT || m_devStatus.eMedia == CI_MEDIA_ENTERING)
		{
			JustReadCardNo();
			m_captureReason = "4001";
			errMsg = CSimpleStringA::Format("DoExitWhenIdle, has card in machine, to capture card, CardNo:%s****%s",
				m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, errMsg.GetData());

			eErr = MachineMoveCardBackNotHold();
			if (eErr == Error_Succeed)
			{
				bool bCaptured = RegistCardWhileCaptureCard();
				m_CardCaptured++;
				bool bSetCapture = SetCardCaptured(m_CardCaptured);
				Dbg("DoExitWhenIdle, to capture card. result:%d, m_CardCaptured:%d, bSetCapture:%d",
					bCaptured, m_CardCaptured, bSetCapture);
			}
		}
	}
}
bool CCardIssuerFSM::JustReadCardNo()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	m_currCardNo = "";
	bool bHasAccount = false;
	int activeCardType;
	bool bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
	Dbg("DetectIfICCard， bIC:%d, activeCardType:%d", bIC, activeCardType);

	if (bIC)
	{
		//oilyang@20201014 add emv support
		bool bGetICData = false;
		bGetICData = m_pCardProcess->GetICDataFromCard(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList);
		ICData track2(false, 0x57, 0x00);
		string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
		if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
		{
			Dbg("JustReadCardNo::FindTagValue, can't find track2 in ic data");
		}
		else
		{
			int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
			char *pICTrack2 = new char[128];
			ZeroMemory(pICTrack2, 128);
			HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
			pICTrack2[37] = '\0';

			char *ddd = new char[128];
			memset(ddd, 0, 128);
			memcpy(ddd, pICTrack2, pos - 1);
			m_currCardNo = ddd;
			if (m_currCardNo.GetLength() > 1)
				bHasAccount = true;
			Dbg("<JustReadCardNo>, FindHexCharPosition， pos：%d, track2.lenth:%d， m_currCardNo.Len:%d",
				pos, track2.lenth, m_currCardNo.GetLength());
			delete[]ddd;
			delete[]pICTrack2;
		}
		eErr = m_hDevHelper->DeactivateICCard();
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "JustReadCardNo::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
			AlarmDEC(m_errPkg);
		}
		eErr = m_hDevHelper->ReleaseIC();
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "JustReadCardNo::ReleaseIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC);
			AlarmDEC(m_errPkg);
		}
	}
	if (!bHasAccount)
	{
		MagTracks magTracks;
		memset(magTracks.track[0].data, 0, sizeof(magTracks.track[0].data));
		memset(magTracks.track[1].data, 0, sizeof(magTracks.track[1].data));
		memset(magTracks.track[2].data, 0, sizeof(magTracks.track[2].data));

		eErr = m_hDevHelper->MagRead(magTracks);
		Dbg("JustReadCardNo, track[1].eStatus:%d, track[2].sStatus:%d, t2.dwSize:%d, t3.dwSize:%d, t2Len:%d, t3Len:%d",
			magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[1].dwSize, magTracks.track[2].dwSize,
			strlen((const char*)magTracks.track[1].data), strlen((const char*)magTracks.track[2].data));

		if (eErr == Error_Succeed)
		{
			if (magTracks.track[1].eStatus == CI_DATA_OK)
			{
				int pos = 0;
				for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
				{
					//运通卡考虑 = 和 D 
					if (magTracks.track[1].data[i] == 0x3d ||
						magTracks.track[1].data[i] == 0x3e ||
						magTracks.track[1].data[i] == 0x44) 
						break;
				}
				char buf[128];
				ZeroMemory(buf, 128);
				strncpy(buf, (char*)magTracks.track[1].data, pos);
				m_currCardNo = buf;
				Dbg("<JustReadCardNo::MagRead>, split pos:%d, m_currCardNo.Len:%d", pos, m_currCardNo.GetLength());
				if (m_currCardNo.GetLength() > 1)
					bHasAccount = true;
			}
		}
		else {
			SetErrPackage(m_errPkg, "JustReadCardNo::MagRead", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MagRead);
			AlarmDEC(m_errPkg);
		}
	}
	if (m_currCardNo.GetLength() > 8)
		Dbg("JustReadCardNo, record the account (%d):%s****%s", m_currCardNo.GetLength(),
			m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
	else {
		CSimpleStringA errMsg = CSimpleStringA::Format("JustReadCardNo, AccountNo maybe wrong:%s(len:%d)", m_currCardNo.GetData(), m_currCardNo.GetLength());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CardNo_Maybe_Wrong, errMsg.GetData());
		Dbg(errMsg.GetData());
	}
		
	return true;
}
bool CCardIssuerFSM::RegistCardWhileCaptureCard()
{
	CSmallDateTime currTime;

	CSimpleStringA csCurrTime = currTime.GetNow().ToTimeString();
	CAutoArray<CSimpleStringA> arrTime;
	arrTime = csCurrTime.Split(' ');
	CSimpleStringA csDate, csTime;
	csDate = arrTime[0].SubString(0, 4) + arrTime[0].SubString(5, 2) + arrTime[0].SubString(8, 2);
	csTime = arrTime[1].SubString(0, 2) + arrTime[1].SubString(3, 2) + arrTime[1].SubString(6, 2);
	GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;
	ErrorCodeEnum eErr = Error_Unexpect;
	pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
	if (pGuiConsoleClient != NULL)
		eErr = pGuiConsoleClient->Connect();
	else
	{
		Dbg("<RegistCardWhileCaptureCard>, pGuiConsoleClient is null?");
		return false;
	}
	if (eErr == Error_Succeed)
	{
		if (pGuiConsoleClient != NULL)
		{
			GUIConsoleService_RegistSwallowedCard_Req req;
			GUIConsoleService_RegistSwallowedCard_Ans ans;
			req.strCardNo = m_currCardNo;
			if (IsValidCardNo((const char*)m_currCardNo, m_currCardNo.GetLength()))
			{
				if (m_currCardNo.GetLength() > 0)
					req.strReasonCode = m_captureReason;
				else
					req.strReasonCode = "0000";
			}
			else
				req.strReasonCode = "0001";
				
			req.strSwallowDate = csDate;
			req.strSwallowTime = csTime;
			req.strDeviceSciNo = m_csDevSN;
			Dbg("<RegistCardWhileCaptureCard>, SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s****%s, m_captureReason:%s, m_bCaptureCfgFlag：%d",
				csDate.GetData(), csTime.GetData(), m_currCardNo.GetLength(), m_currCardNo.SubString(0, 6).GetData(),
				m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData(), m_captureReason.GetData(), m_bCaptureCfgFlag);
			if (m_bCaptureCfgFlag)
			{
				eErr = pGuiConsoleClient->RegistSwallowedCard(req, ans, 10000);
				Dbg("<RegistCardWhileCaptureCard::RegistSwallowedCard>, eErr:%d(0x%x)", eErr, eErr);
			}
			if (pGuiConsoleClient != NULL)
			{
				pGuiConsoleClient->GetFunction()->CloseSession();
				pGuiConsoleClient = NULL;
			}
		}
	}
	else
		return false;
	return true;
}
bool CCardIssuerFSM::IsValidCardNo(const char *pCardNo,int len)
{
	//oilyang@20170207 卡号长度有限
	len = (len > 32) ? 32 : len;
	for (int i = 0; i < len; ++i)
	{
		if (pCardNo[i] < 0x30 || pCardNo[i] > 0x39)
		{
			//not '0'-'9'
			Dbg("<IsValidCardNo>, CardNo is Invalid with illegal charactor:%c", pCardNo[i]);
			return false;
		}
	}
	return true;
}
int CCardIssuerFSM::IsValidSCIName(const char *pSCIName, int len)
{
	//设备唯一标识：10位，厂商简称（两个字母，需报备行方） + SCI + 5位顺序序号
	//怡化：YH；广电：YT；中航：ZH；南天：NT，中世顺：ZS；
	//如：YHSCI00001
	Dbg("<IsValidSCIName>, SCIName:%d", pSCIName);
	if (len < 10 || len > 11)
		return 0;
	//oiltmp 20170713 需要增加配置，然后格式判断
	if ((*(pSCIName + 2) == 'S') && (*(pSCIName + 3) == 'C') && (*(pSCIName + 4) == 'I'))
		return 1;
	else if((*(pSCIName + 2) == 'C') && (*(pSCIName + 3) == 'I') && (*(pSCIName + 4) == 'L')) {
		//设备唯一标识：10位，厂商简称（两个字母，需报备行方）+ CIL +5位顺序序号
		return 2;
	} else
		return 0;
}
int CCardIssuerFSM::SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
{
	Dbg("<SAMICCommand, inParam<cmdType:%d>", ctx->Req.cmdType);

	ErrorCodeEnum eErr = Error_Unexpect;

	switch (ctx->Req.cmdType)
	{
	case SAMICCommand_SAM_Select:
		eErr = m_hDevHelper->SAMSelect(ctx->Req.param1[0]);
		Dbg("SAMSelect, req.param1:%d", ctx->Req.param1[0]);
		if(eErr) {
			SetErrPackage(m_errPkg, "SAMICCommand::SAMSelect", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMSelect);
			AlarmDEC(m_errPkg);
		}
		break;
	case SAMICCommand_SAM_Active:
		eErr = m_hDevHelper->SAMActive(ctx->Req.param1[0]);
		Dbg("SAMActive, req.param1:%d", ctx->Req.param1[0]);
		if(eErr) {
			SetErrPackage(m_errPkg, "SAMICCommand::SAMActive", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMActive);
			AlarmDEC(m_errPkg);
		}
		break;
	case SAMICCommand_SAM_Deactivate:
		eErr = m_hDevHelper->SAMDeactivate();
		if(eErr) {
			SetErrPackage(m_errPkg, "SAMICCommand::SAMDeactivate", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMDeactivate);
			AlarmDEC(m_errPkg);
		}
		break;
	case SAMICCommand_SAM_WarmReset:
		eErr = m_hDevHelper->SAMWarmReset();
		if(eErr) {
			SetErrPackage(m_errPkg, "SAMICCommand::SAMWarmReset", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMWarmReset);
			AlarmDEC(m_errPkg);
		}
		break;
	case SAMICCommand_SAM_QueryStatus:
	{
		SAMStatus samStatus;
		eErr = m_hDevHelper->SAMQueryStatus(samStatus);
		Dbg("SAMWarmReset, isActive:%d, chosenOfSAM:%d", samStatus.isActive, samStatus.chosenOfSAM);
		if (eErr == Error_Succeed)
		{
			ctx->Ans.ret1.Init(2);
			ctx->Ans.ret1[0] = samStatus.isActive;
			ctx->Ans.ret1[1] = samStatus.chosenOfSAM;
		}
		else
		{
			SetErrPackage(m_errPkg, "SAMICCommand::SAMQueryStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMQueryStatus);
			AlarmDEC(m_errPkg);
		}
	}
		break;
	case SAMICCommand_SAM_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE *pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		eErr = m_hDevHelper->SAMCommand(sendBuf,recvBuf);
		Dbg("SAMCommand, req.param2:%s, recvBuf.dwSize:%d", ctx->Req.param2[0].GetData(), recvBuf.dwSize);
		if (eErr == Error_Succeed)
		{
			char *pRet = new char[MAX_IC_BUFFER_SIZE];
			ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
			Dbg("%d",recvBuf.dwSize);
			HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
			ctx->Ans.ret1.Init(1);
			ctx->Ans.ret2.Init(1);
			ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
			ctx->Ans.ret2[0] = pRet;
			delete[]pRet;
		}
		else
		{
			SetErrPackage(m_errPkg, "SAMICCommand::SAMCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SAMCommand);
			AlarmDEC(m_errPkg);
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_IC_Active:
	{
		eErr = m_hDevHelper->ContactIC();
		if (eErr == Error_Succeed)
		{
			CmdInfo atrBuf;
			eErr = m_hDevHelper->ActiveICCardATR(atrBuf);
			if (eErr == Error_Succeed)
			{
				BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
				if (pTmp == NULL)
				{
					Dbg("new MAX_IC_BUFFER_SIZE failed");
					eErr = Error_Unexpect;
					break;
				}
				ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(atrBuf.data, (char**)&pTmp, atrBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = atrBuf.dwSize * 2;
				ctx->Ans.ret2[0] = CSimpleStringA((const char*)pTmp);
				Dbg("AtrCtx: size=%d, content=%s, pTmp=%s", ctx->Ans.ret1[0], (LPCTSTR)ctx->Ans.ret2[0], (LPCTSTR)pTmp);
				delete[] pTmp;
				pTmp = NULL;

			}
			else
			{
				SetErrPackage(m_errPkg, "SAMICCommand::ActiveICCardATR", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ActiveICCardATR);
				AlarmDEC(m_errPkg);
			}

		}
		else
		{
			SetErrPackage(m_errPkg, "SAMICCommand::ContactIC", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ContactIC);
			AlarmDEC(m_errPkg);
		}
	}
		break;
	case SAMICCommand_IC_Deactivate:
		eErr = m_hDevHelper->DeactivateICCard();
		if (eErr != Error_Succeed) {
			eErr = m_hDevHelper->DeactivateICCard();
			if (eErr != Error_Stoped)
			{
				SetErrPackage(m_errPkg, "SAMICCommand::DeactivateICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard);
				AlarmDEC(m_errPkg);
			}
		}			
		break;
	case SAMICCommand_IC_WarmReset:
		eErr = m_hDevHelper->WarmReset();
		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "SAMICCommand::WarmReset", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_WarmReset);
			AlarmDEC(m_errPkg);
		}
		break;
	case SAMICCommand_IC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE *pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		eErr = m_hDevHelper->ICCommand(sendBuf, recvBuf);
		if(false)//oilyang@20201224 before deploy ,comment loging apdu content
		{
			char *pRet = new char[MAX_IC_BUFFER_SIZE];
			if (pRet != NULL)
			{
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(sendBuf.data, (char**)&pRet, size);
				Dbg("ICCommand return data, %s", (const char*)pRet);
				delete[] pRet;
			}
										
		}

		if (eErr == Error_Succeed)
		{
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				Dbg("ICCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else
		{
			SetErrPackage(m_errPkg, "SAMICCommand::ICCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ICCommand);
			AlarmDEC(m_errPkg);
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_RFIC_Active:
	{
		char chType = 0;
		eErr = m_hDevHelper->ActiveContactlessICCard('A', 'B', 'M', chType);
		Dbg("ActiveContactlessICCard, chType:%d", chType);
		ctx->Ans.ret1.Init(1);
		if (eErr == Error_Succeed)
		{
			ctx->Ans.ret1[0] = chType;
		}
		else
		{
			SetErrPackage(m_errPkg, "SAMICCommand::ActiveContactlessICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ActiveContactlessICCard);
			AlarmDEC(m_errPkg);
		}
	}
		break;
	case SAMICCommand_RFIC_Deactivate:
		eErr = m_hDevHelper->DeactContactlessICCard();
		if (eErr != Error_Succeed) {
			eErr = m_hDevHelper->DeactContactlessICCard();
			if (eErr != Error_Succeed) {
				SetErrPackage(m_errPkg, "SAMICCommand::DeactContactlessICCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard);
				AlarmDEC(m_errPkg);
			}
		}
		break;
	case SAMICCommand_RFIC_Command:
	{
		CmdInfo sendBuf, recvBuf;
		BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
		ZeroMemory(pTmp, MAX_IC_BUFFER_SIZE);
		int size = StrBuf2HexBuf(ctx->Req.param2[0], &pTmp);
		memcpy(sendBuf.data, pTmp, size);
		sendBuf.dwSize = size;
		eErr = m_hDevHelper->RFTypeABCommand(sendBuf, recvBuf);
		if (false)//oilyang@20201224 before deploy ,comment loging apdu content
		{
			char* pRet = new char[MAX_IC_BUFFER_SIZE];
			if (pRet != NULL)
			{
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				HexBuf2StrBuf(sendBuf.data, (char**)&pRet, size);
				Dbg("RFTypeABCommand, return data:%s", (const char*)pRet);
				delete[] pRet;
			}

		}

		if (eErr == Error_Succeed)
		{
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				Dbg("RFTypeABCommand, recvBuf.dwSize:%d", recvBuf.dwSize);
				HexBuf2StrBuf(recvBuf.data, (char**)&pRet, recvBuf.dwSize);
				ctx->Ans.ret1.Init(1);
				ctx->Ans.ret2.Init(1);
				ctx->Ans.ret1[0] = recvBuf.dwSize * 2;
				ctx->Ans.ret2[0] = pRet;
				delete[]pRet;
			}
		}
		else {
			SetErrPackage(m_errPkg, "SAMICCommand::RFTypeABCommand", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_RFTypeABCommand);
			AlarmDEC(m_errPkg);
		}
		delete[]pTmp;
	}
	break;
	default:
		break;
	}
	ctx->Answer(eErr);
	return 0;
}
int CalcDelayFactor(int failedCount)
{
	if ((failedCount % 7) == 0)
	{
		return 1;
	}
	else
		return 1 << (failedCount % 7);
}
void CCardIssuerFSM::PeriodConnect(BOOL anotherThread)
{
	//便携式蓝牙发卡器5s左右睡眠
	Dbg("<PeriodConnect>, Fire period connect, anotherThread:%d", anotherThread);
	Sleep(m_scanSlot * ONE_K * CalcDelayFactor(m_devOpenFailedCount));
	if (m_bBTConnected || m_bBTConncting || m_currentFSMState != 12) {
		Dbg("<PeriodConnect>, return previously: btconnected: %d, btconnecting: %d, fsm state: %d",
			m_bBTConnected, m_bBTConncting, m_currentFSMState);
		return;
	}
	Dbg("<PeriodConnect>, to connect(by PeriodConnect)");
	ConnectTask *task = new ConnectTask(this);
	if(anotherThread) {
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	} else {
		ConnectTask *task = new ConnectTask(this);
		task->Process();
		task->DecRef();
	}
}
int CCardIssuerFSM::QueryPrinterStatus(SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx)
{
	return 0;
}
int CCardIssuerFSM::Print(SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx)
{
	int dataSize = 0;
	Dbg("<Print>, print data bitmap of bmp:%d, face:%d, name:%s,%s;size:%d,%d",
		ctx->Req.reserved1[0], ctx->Req.reserved2[0].GetData(), ctx->Req.reserved1[1],
		ctx->Req.reserved2[1].GetData(), ctx->Req.data1.m_iLength, ctx->Req.data2.m_iLength);
	if (ctx->Req.reserved1[0] > 0xf)
	{
		Dbg("<Print>, param error.");
		ctx->Answer(Error_Param);
		return -1;
	}
	PBYTE pData = new BYTE[2048];
	if (pData == NULL)
	{
		Dbg("<Print>, resource failed.");
		ctx->Answer(Error_Unexpect);
		return -1;
	}
	CSimpleStringA csDepPath, csBackslash("\\"), csABmp,csBBmp;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
	ZeroMemory(pData, 2048);
	pData[dataSize++] = 0x37;
	pData[dataSize++] = 0x63;
	pData[dataSize++] = 0x30;
	//save print A bmp
	if ((ctx->Req.reserved1[0] & 0x1) == 0x1)
	{
		FILE *fp = NULL;
		csABmp = ctx->Req.reserved2[0];
		//csABmp = csDepPath + csBackslash + "PrintImage.bmp";
		Dbg("<Print>, a.bmp:%s", (const char*)csABmp);
		fp = fopen((const char*)csABmp, "wb+");
		if (fp) {
			fwrite(ctx->Req.data1.m_pData, 1, ctx->Req.data1.m_iLength, fp);
			fclose(fp);
		}
		else {
			Dbg("<Print>, save print A file failed.");
			ctx->Answer(Error_Unexpect);
			return -1;
		}
		memcpy(pData + dataSize, ctx->Req.reserved2[0], ctx->Req.reserved2[0].GetLength());
		dataSize += ctx->Req.reserved2[0].GetLength();
		//memcpy(pData + dataSize, "PrintImage.bmp", strlen("PrintImage.bmp"));
		//dataSize += strlen("PrintImage.bmp");
		pData[dataSize++] = 0x00;
	}
	//save print B bmp
	if ((ctx->Req.reserved1[0] & 0x2) == 0x2)
	{
		pData[2] = 0x31;
		csBBmp = ctx->Req.reserved2[1];
		//csBBmp = csDepPath + csBackslash + ctx->Req.reserved2[1];
		//csBBmp = csDepPath + csBackslash + "Overcoat.bmp";
		Dbg("<Print>, b.bmp:%s", (const char*)csBBmp);
		FILE *fp = fopen((const char*)csBBmp, "wb+");
		if (fp) {
			fwrite(ctx->Req.data2.m_pData, 1, ctx->Req.data2.m_iLength, fp);
			fclose(fp);
		}
		else {
			Dbg("<Print>, save print B file failed.");
			ctx->Answer(Error_Unexpect);
			return -1;
		}
		memcpy(pData + dataSize, ctx->Req.reserved2[1], ctx->Req.reserved2[1].GetLength());
		dataSize += ctx->Req.reserved2[1].GetLength();
		//memcpy(pData + dataSize, "Overcoat.bmp", strlen("Overcoat.bmp"));
		//dataSize += strlen("Overcoat.bmp");
		pData[dataSize++] = 0x00;
	}
	pData[dataSize++] = 0x00;
	pData[dataSize++] = 0x00;
	char *tmpShow = new char[1024];
	ZeroMemory(tmpShow, 1024);
	HexBuf2StrBuf(pData, &tmpShow, dataSize);
	Dbg("<Print>, print datasize(%d)(%s)",dataSize,tmpShow);
	delete[]tmpShow;
	ErrorCodeEnum eErr = Error_Unexpect;
	//BYTE *pData = new BYTE[ctx->Req.reserved1[0]];
	//if (pData != NULL)
	{
		eErr = m_hDevHelper->Print(pData, dataSize,ctx->Req.reserved1[1]);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "Print::Print", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_Print);
			ctx->Answer(eErr, AlarmDEC(m_errPkg, true));
		}
		ctx->Answer(Error_Succeed);
	}
	remove((const char*)csABmp);
	remove((const char*)csBBmp);
	return 0;
}
int CCardIssuerFSM::DetectBluetoothSCIOnLinux()
{
	return Error_NotImpl;
}
int CCardIssuerFSM::DetectBluetoothSCI()
{
#ifdef RVC_OS_WIN
	ClearSCIRecords();
	WSADATA m_data;
	SOCKET s;
	WSAPROTOCOL_INFO protocolInfo;
	int protocolInfoSize;
	WSAQUERYSET querySet, *pResults, querySet2;
	HANDLE hLookup, hLookup2;
	int result;
	static int i;
	BYTE buffer[1000];
	BYTE buffer1[2000];
	DWORD bufferLength, flags, addressSize, bufferLength1;
	CSADDR_INFO *pCSAddr;
	BTH_DEVICE_INFO *pDeviceInfo;
	char addressAsString[2000];
	BLOB *pBlob;
	GUID protocol;
	
	// Load the winsock2 library
	if (WSAStartup(MAKEWORD(2, 2), &m_data) == 0)
	{
		// Create a blutooth socket
		s = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
		if (s == INVALID_SOCKET)
		{
			Dbg("Failed to get bluetooth socket with error code %ld", WSAGetLastError());
			return 1;
		}
		else {
			Dbg("create socket() suc!");
		}
		protocolInfoSize = sizeof(protocolInfo);
		// Get the bluetooth device info using getsockopt()
		if (getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &protocolInfoSize) != 0)
		{
			Dbg("getsockopt(SO_PROTOCOL_INFO) failed with error code %ld", WSAGetLastError());
			return 1;
		}
		else {
			Dbg("getsockopt(SO_PROTOCOL_INFO) is OK!");
		}
		// Query set criteria
		memset(&querySet, 0, sizeof(querySet));
		querySet.dwSize = sizeof(querySet);
		querySet.dwNameSpace = NS_BTH;

		// Set the flags for query
		//LUP_RETURN_BLOB
		//flags = LUP_RETURN_NAME | LUP_CONTAINERS | LUP_RETURN_ADDR | LUP_NEAREST |
		//	LUP_RETURN_TYPE |   LUP_RES_SERVICE;
		flags = LUP_CONTAINERS| LUP_FLUSHCACHE;
		Dbg("Start a device in range query...");
		result = WSALookupServiceBegin(&querySet, flags, &hLookup);
		if(WSAGetLastError() == 10108 && m_bBTConncting) {
			WSASetLastError(10108);
			const int maxWaitTimes = 12;
			int currentWaitTimes = 0;
			do {
				Dbg("waiting bluetooth connect operation finish...");
				Sleep(800);
				currentWaitTimes++;
				if(currentWaitTimes >= maxWaitTimes) {
					Dbg("Timeout break");
					break;
				}
			} while (m_bBTConncting);
			memset(&querySet, 0, sizeof(querySet));
			querySet.dwSize = sizeof(querySet);
			querySet.dwNameSpace = NS_BTH;
			result = WSALookupServiceBegin(&querySet, flags, &hLookup);
		}
		Dbg("If OK");
		bool bFirst = false;//oilyang@20170802 暂时不用
		if (result == 0)
		{
			i = 0;
			//sockaddr *pRemoteAddr = new sockaddr();
			while (result == 0)
			{
				bufferLength = sizeof(buffer);
				pResults = (WSAQUERYSET *)&buffer;
				// Next query...
				flags = LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_NEAREST |
					LUP_RETURN_TYPE |   LUP_RES_SERVICE;
				result = WSALookupServiceNext(hLookup, flags, &bufferLength, pResults);
				if (result != 0)
				{
					Dbg("WSALookupServiceNext() failed with error code %ld", WSAGetLastError());
				}
				else
				{
					// Get the device info, name, address etc
					// if (IsValidSCIName(pResults->lpszServiceInstanceName, strlen(pResults->lpszServiceInstanceName)))
					// {
					// }
					pCSAddr = (CSADDR_INFO *)pResults->lpcsaBuffer;
					pDeviceInfo = (BTH_DEVICE_INFO *)pResults->lpBlob;
					memset(&querySet2, 0, sizeof(querySet2));
					querySet2.dwSize = sizeof(querySet2);
					protocol = L2CAP_PROTOCOL_UUID;
					querySet2.lpServiceClassId = &protocol;
					querySet2.dwNameSpace = NS_BTH;
					
					if(strlen(pResults->lpszServiceInstanceName) > 0) {
						Dbg("instance name: %s,protocol:%d,socket type:%d", pResults->lpszServiceInstanceName, pCSAddr->iProtocol, pCSAddr->iSocketType);
					}
					// Print the local bluetooth device address...
					//addressSize = sizeof(addressAsString);
					//if (WSAAddressToString(pCSAddr->LocalAddr.lpSockaddr, pCSAddr->LocalAddr.iSockaddrLength,
					//	&protocolInfo, (LPSTR)addressAsString, &addressSize) == 0)
					//{
					//	Dbg("The local address: %s", addressAsString);
					//}
					//else {
					//	Dbg("WSAAddressToString() for local address failed with error code %ld", WSAGetLastError());
					//}
					addressSize = sizeof(addressAsString);
					// Print the remote bluetooth device address...
					if (WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength,
						&protocolInfo, (LPSTR)addressAsString, &addressSize) == 0)
					{
						if (IsValidSCIName(pResults->lpszServiceInstanceName, strlen(pResults->lpszServiceInstanceName)))
						{
							Dbg("The remote device address: %s", addressAsString);
							//oiltest@20200113 去掉socket连接确认蓝牙卡机是否在附近
							//Dbg(" add %s\n", pResults->lpszServiceInstanceName);
							AddToSCIRecords(pResults->lpszServiceInstanceName, addressAsString, bFirst);
							bFirst = false;
#ifndef CancelSocketConfirm



							SOCKET LocalSocket = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
							//sockaddr sockaddr_value;
							//sockaddr *pRemoteAddr = &sockaddr_value;
							if (INVALID_SOCKET == LocalSocket) {
								Dbg("socket() call failed. WSAGetLastError = [%d]", WSAGetLastError());
							}
							else {
								// 设置为非阻塞的socket
								int iMode = 1;
								ioctlsocket(LocalSocket, FIONBIO, (u_long FAR*)&iMode);
								// 超时时间  
								struct timeval tm;
								tm.tv_sec = 7;
								tm.tv_usec = 0;
								int ret = -1;
								//
								// Connect the socket (pSocket) to a given remote socket represented by address (pServerAddr)
								//
								SOCKADDR_BTH xAddr;
								//CopyMemory(&xAddr,(PSOCKADDR_BTH)pCSAddr->RemoteAddr.lpSockaddr,sizeof(xAddr));
								//xAddr.btAddr = 0x0000881b99079464;
								//ZeroMemory(pRemoteAddr->sa_data, sizeof(pRemoteAddr->sa_data));
								//pRemoteAddr->sa_family = AF_BTH;
								//memcpy(pRemoteAddr->sa_data, addressAsString, strlen(addressAsString));

								int iAddrLen = sizeof(xAddr);
								WSAStringToAddress(addressAsString, AF_BTH, NULL, (LPSOCKADDR)&xAddr, &iAddrLen);
								xAddr.addressFamily = AF_BTH;
								xAddr.serviceClassId = RFCOMM_PROTOCOL_UUID;
								xAddr.port = 0;
								//if (SOCKET_ERROR == connect(LocalSocket, (const sockaddr*)pRemoteAddr, sizeof(pRemoteAddr)))
								bool isConnected = false;
								if (SOCKET_ERROR != connect(LocalSocket,(struct sockaddr *) &xAddr,sizeof(SOCKADDR_BTH)))
								{
									isConnected = true;
									Dbg("connected.");
									//Dbg("=CRITICAL= | connect() call failed. WSAGetLastError=[%d]\n", WSAGetLastError());
									//break;
								}
								else
								{
									fd_set set;
									FD_ZERO(&set);
									FD_SET(LocalSocket, &set);
									if (select(-1, NULL, &set, NULL, &tm) <= 0)
									{
										ret = -1; // 有错误(select错误或者超时)
										isConnected = false;
										Dbg("can't connect or timeout.");
									}
									else
									{
										int error = -1;
										int optLen = sizeof(int);
										getsockopt(LocalSocket, SOL_SOCKET, SO_ERROR, (char*)&error, &optLen);
										if (0 != error)
										{
											ret = -1; // 有错误
										}
										else
										{
											isConnected = true;
											Dbg("connected 2.");
										}
									}
								}
								if (isConnected)
								{
									//Dbg(" add %s\n", pResults->lpszServiceInstanceName);
									AddToSCIRecords(pResults->lpszServiceInstanceName, addressAsString, bFirst);
									bFirst = false;
								}
								Dbg("close socket.");
								closesocket(LocalSocket);
								// 设回为阻塞socket
								iMode = 0;
								ioctlsocket(LocalSocket, FIONBIO, (u_long FAR*)&iMode); //设置回阻塞模式  
							}
#endif // !CancelSocketConfirm
						}

					}
					else {
						Dbg("WSAAddressToString() for remote address failed with error code %ld", WSAGetLastError());
					}
				}
			}
			// Close handle to the device query
			if (WSALookupServiceEnd(hLookup) == 0) {
				Dbg("WSALookupServiceEnd(hLookup) is fine!", WSAGetLastError());
			}
			else {
				Dbg("WSALookupServiceEnd(hLookup) failed with error code %ld");
			}
		}
		else
		{
			Dbg("WSALookupServiceBegin() failed with error code %ld", WSAGetLastError());
		}// end WSALookupServiceBegin()
		// Cleanup the winsock library startup

		if (WSACleanup() == 0) {
			Dbg("WSACleanup() fine!");
		} else {
			Dbg("WSACleanup() failed with error code %ld", WSAGetLastError());
		}
	} // end WSAStartup()
	return 0;
#else 
return DetectBluetoothSCIOnLinux();
#endif //RVC_OS_WIN
}
int CCardIssuerFSM::QuerySCIList(
	SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx,
	const int fsmState)
{
	m_bDoingQueryListOrBindSCI = true;
	DetectBluetoothSCI();
	vector<SCIRecord> vTmp;
	//to get SCI list
	EnterCriticalSection(&g_sciRecord);
	vector<SCIRecord>::iterator it;
	for (it = m_vSCIRecords.begin(); it != m_vSCIRecords.end(); it++)
	{
		vTmp.push_back(*it);
	}
	LeaveCriticalSection(&g_sciRecord);

	//query info of each sci
	GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;
	ErrorCodeEnum errCode = Error_Unexpect;
	CSimpleStringA errMsg(true);
	pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
	if (pGuiConsoleClient != NULL) {
		errCode = pGuiConsoleClient->Connect();
		if (errCode != Error_Succeed) {
			Dbg("<QuerySCIList>, Connect to GUIConsole failed.");
		}
	}else {
		Dbg("<QuerySCIList>, pGuiConsoleClient is null?");
	}
	if (errCode == Error_Succeed)
	{
		if (pGuiConsoleClient)
		{
			for (it = vTmp.begin(); it != vTmp.end(); it++)
			{
				GUIConsoleService_QueryMaterialInfo_Req req;
				GUIConsoleService_QueryMaterialInfo_Ans ans;
				req.strDeviceNo = it->name;
				Dbg("<QuerySCIList>, inParam, SCI Name:%s", req.strDeviceNo.GetData());
				errCode = pGuiConsoleClient->QueryMaterialInfo(req, ans, 10000);
				if (errCode == Error_Succeed)
				{
					if (ans.count >= 0 && ans.count < 100)//oilyang@20180228 count有时候会异常大，不正常
					{
						int tmpCount = ans.count;
						if (ans.count == 0)
						{
							tmpCount = 1;
							CSimpleStringA blank("");
							unsigned int intZero = 0;
							ctx->Ans.sciNo.Append(&(req.strDeviceNo), 0, 1);
							ctx->Ans.arrMateriel.Append(&blank, 0, 1);
							ctx->Ans.CardGroove.Append(&blank, 0, 1);
							ctx->Ans.CardBoxNo.Append(&blank, 0, 1);
							ctx->Ans.PsbCode.Append(&blank, 0, 1);
							ctx->Ans.PsbName.Append(&blank, 0, 1);
							ctx->Ans.CardInit.Append(&intZero, 0, 1);
							ctx->Ans.CardRemains.Append(&intZero, 0, 1);
							ctx->Ans.CardIssued.Append(&intZero, 0, 1);
							ctx->Ans.CardMixed.Append(&intZero, 0, 1);
							ctx->Ans.CardPercent.Append(&intZero, 0, 1);
							ctx->Ans.Maintainer.Append(&blank, 0, 1);
							ctx->Ans.MaintainTime.Append(&blank, 0, 1);
							ctx->Ans.UpdateTime.Append(&blank, 0, 1);
						}
						else
						{
							ctx->Ans.sciNo.Append(ans.arrDeviceNo, 0, ans.count);
							ctx->Ans.arrMateriel.Append(ans.arrMateriel, 0, ans.count);
							ctx->Ans.CardGroove.Append(ans.CardGroove, 0, ans.count);
							ctx->Ans.CardBoxNo.Append(ans.CardBoxNo, 0, ans.count);
							ctx->Ans.PsbCode.Append(ans.PsbCode, 0, ans.count);
							ctx->Ans.PsbName.Append(ans.PsbName, 0, ans.count);
							ctx->Ans.CardInit.Append(ans.CardInit, 0, ans.count);
							ctx->Ans.CardRemains.Append(ans.CardRemains, 0, ans.count);
							ctx->Ans.CardIssued.Append(ans.CardIssued, 0, ans.count);
							ctx->Ans.CardMixed.Append(ans.CardMixed, 0, ans.count);
							ctx->Ans.CardPercent.Append(ans.CardPercent, 0, ans.count);
							ctx->Ans.Maintainer.Append(ans.Maintainer, 0, ans.count);
							ctx->Ans.MaintainTime.Append(ans.MaintainTime, 0, ans.count);
							ctx->Ans.UpdateTime.Append(ans.UpdateTime, 0, ans.count);
						}
						Dbg("<QuerySCIList>, add sci %s,record count:%d,count:%d",
							req.strDeviceNo.GetData(), ctx->Ans.sciNo.GetCount(), tmpCount);
					}
					else {
						errMsg = CSimpleStringA::Format("<QuerySCIList>, QueryMaterialInfo return data error, ans.count:%d", ans.count);
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_QueryMaterialInfo_Count_Error, errMsg.GetData());
					}

				}
				else {
					errMsg = CSimpleStringA::Format("<QuerySCIList>, QueryMaterialInfo failed:%d(0x%x)", errCode, errCode);
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_QueryMaterialInfo_Failed, errMsg.GetData());
				}
			}
			
			ctx->Answer(Error_Succeed);
		}
	}
	m_bDoingQueryListOrBindSCI = false;
	return fsmState;
}
int CCardIssuerFSM::BindSCI(
	SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx,
	const int fsmState)
{
	m_bDoingQueryListOrBindSCI = true;
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);
	errMsg = CSimpleStringA::Format("<BindSCI>, bindSCI type:%d, SCI Name:%s, previous fsm state:%d", ctx->Req.type, ctx->Req.sciNo.GetData(), fsmState);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_BindSCI, errMsg.GetData());

	int ret = 0;
	switch (ctx->Req.type)
	{//绑定类型：1：绑定（从后台同步数据） 2：绑定成功告知终端 3：解绑（终端数据同步到后台） 4：解绑成功
		case 1:
			if (!IsValidSCIName((const char*)ctx->Req.sciNo, ctx->Req.sciNo.GetLength()))
			{
				errMsg = CSimpleStringA::Format("Bind Failed, Invalid SCI Name, sciNo:%s(%d)", ctx->Req.sciNo.GetData(), ctx->Req.sciNo.GetLength());
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Bind_Invalid_SCI_Name, errMsg.GetData());
				ctx->Answer(Error_Param);
			}
			else
			{
				eErr = AfterBindSyncData(ctx->Req.sciNo.GetData(), true);
				if (eErr != Error_Succeed)
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Bind_SyncData_Failed, "Bind Failed, AfterBindSyncData error.");
				ctx->Answer(eErr);
			}
			ret = fsmState;
			break;
		case 2:
			if (!IsValidSCIName((const char*)ctx->Req.sciNo, ctx->Req.sciNo.GetLength()))
			{
				errMsg = CSimpleStringA::Format("Bind Failed, Invalid SCI Name, sciNo:%s(%d)", ctx->Req.sciNo.GetData(), ctx->Req.sciNo.GetLength());
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Bind_Invalid_SCI_Name, errMsg.GetData());
				ctx->Answer(Error_Param);
			}
			else
			{
				AfterBindUpdateSCINameToRunCfg((const char*)ctx->Req.sciNo, true);
				ret = 1;
				m_csDevSN = ctx->Req.sciNo; //绑定成功的时候才更新设备名称？
				CloseAndClearDevObj();
				m_bUnbindType3 = false;
				ctx->Answer(Error_Succeed);
			}
			break;
		case 3:
			if (!IsValidSCIName((const char*)ctx->Req.sciNo, ctx->Req.sciNo.GetLength()))
			{
				errMsg = CSimpleStringA::Format("Unbind Failed, Invalid SCI Name, sciNo:%s(%d)", ctx->Req.sciNo.GetData(), ctx->Req.sciNo.GetLength());
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Unbind_Invalid_SCI_Name, errMsg.GetData());
				ctx->Answer(Error_Param);
			}
			else
			{
				//解绑操作，同步运行时数据(而不是初始化数据)到后台数据库
				//在pad已经绑定多合一，而又没有连上的时候，如果收到解绑操作，去运行时取值再同步数据
				CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
				CSmartPointer<IConfigInfo> spConfig;
				eErr = spEntityFunction->OpenConfig(Config_Run, spConfig);
				if (eErr != Error_Succeed) {
					Dbg("<BindSCI>, open run cfg file failed!");
					ctx->Answer(eErr);
				}
				char sec[2];
				for (int i = 0; i < 3; ++i)
				{
					ZeroMemory(sec, 2);
					_itoa(i + 1, (char*)sec, 10);
					Dbg("<BindSCI>, the %sth CardBox, cardboxNo:%s, psbName:%s, CardInit:%d, CardRemain:%d, CardIssued:%d, Maintainer:%s",
						sec, m_CardBoxNoEx[i].GetData(), m_PsbNameEx[i].GetData(), m_CardInitEx[i], m_remainsEx[i], m_issuedEx[i], m_MaintainerEx[i]);
					spConfig->ReadConfigValue(sec, "CardBoxNo", m_CardBoxNoEx[i]);
					spConfig->ReadConfigValue(sec, "PsbCode", m_PsbCodeEx[i]);
					spConfig->ReadConfigValue(sec, "PsbName", m_PsbNameEx[i]);
					spConfig->ReadConfigValueInt(sec, "CardInit", m_CardInitEx[i]);
					spConfig->ReadConfigValueInt(sec, "CardRemains", m_remainsEx[i]);
					spConfig->ReadConfigValueInt(sec, "CardIssued", m_issuedEx[i]);
					spConfig->ReadConfigValueInt(sec, "CardMixed", m_mixedEx[i]);
					spConfig->ReadConfigValueInt(sec, "CardPercent", m_CardPercentEx[i]);
					spConfig->ReadConfigValue(sec, "Maintainer", m_MaintainerEx[i]);
					spConfig->ReadConfigValue(sec, "MaintainTime", m_csMaintainTimeEx[i]);
				}
				eErr = AfterBindSyncData((const char*)ctx->Req.sciNo, false);
				ctx->Answer(eErr);
				if (eErr == Error_Succeed)
				{
					//已经解除绑定，告知OpenDevice退出尝试连接
					m_bUnbindType3 = true;
				}
				else {
					errMsg = CSimpleStringA::Format("UnbindSCI failed, cause AfterBindSyncData failed, err:%d(0x%x)", eErr, eErr);
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Unbind_SyncData_Failed, errMsg.GetData());
				}
			}
			ret = fsmState;
			break;
		case 4:
			AfterBindUpdateSCINameToRunCfg((const char*)ctx->Req.sciNo, false);
			//if (ctx->Req.sciNo.GetLength() > 0)
			//{
			//	AfterBindUpdateSCINameToRunCfg((const char*)ctx->Req.sciNo, false);
			//}
			//else
			//{
			//	AfterBindUpdateSCINameToRunCfg("", false);
			//}
			ret = 0;
			// AfterBindUpdateSCINameToRunCfg 函数中已经做了清空 [10/10/2019 9:16 @Gifur]
			// m_csDevSN = ""; //告知解绑成功才清空设备名称，并调用适配器的关闭接口
			Dbg("after un bind,to close SCI.");
			CloseAndClearDevObj(false, true);
			//if (m_hDevHelper != NULL && !m_bBTConncting)
			//{
			//	eErr = m_hDevHelper->DevClose();
			//	Dbg("Close device returned: %d", eErr);
			//	//ReleaseDevComponent((DeviceBaseClass *&)m_hDevHelper);
			//	//m_hDevHelper = NULL;
			//}
			ctx->Answer(Error_Succeed);
			break;
		default:
			break;
	}
	m_bDoingQueryListOrBindSCI = false;
	return ret;
}
void CCardIssuerFSM::AddToSCIRecords(const char *name, const char * remoteMac, bool bFirst)
{
	EnterCriticalSection(&g_sciRecord);
	if (bFirst) {
		m_vSCIRecords.clear();
	}
	SCIRecord record;
	record.name = name;
	record.remoteMac = remoteMac;
	m_vSCIRecords.push_back(record);
	Dbg("<AddToSCIRecords>, the %dth sci,name is:%s", m_vSCIRecords.size(),name);
	LeaveCriticalSection(&g_sciRecord);
}

void CCardIssuerFSM::ClearSCIRecords()
{
	EnterCriticalSection(&g_sciRecord);
	m_vSCIRecords.clear();
	LeaveCriticalSection(&g_sciRecord);
	return;
}

ErrorCodeEnum CCardIssuerFSM::AfterBindSyncData(const char *name, bool bBind)
{
	LOG_FUNCTION();
	if (!bBind)
	{
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		bMaintain[0] = bMaintain[1] = true;
		int ret = SyncDataToDB(bMaintain,false);
		if (ret != 0)
		{
			Dbg("<AfterBindSyncData>, SyncDataToDB failed:%d", ret);
			return Error_Unexpect;
		}
	}
	else
	{
		GUIConsoleService_ClientBase *pGuiConsoleClient = NULL;
		ErrorCodeEnum errCode = Error_Unexpect;
		pGuiConsoleClient = new GUIConsoleService_ClientBase(dynamic_cast<CCardIssuerEntity*>(GetEntityBase()));
		if (pGuiConsoleClient != NULL)
			errCode = pGuiConsoleClient->Connect();
		else
		{
			Dbg("AfterBindSyncData pGuiConsoleClient is null?");
			return Error_Unexpect;
		}
		GUIConsoleService_QueryMaterialInfo_Req req;
		GUIConsoleService_QueryMaterialInfo_Ans ans;
		req.strDeviceNo = name;
		errCode = pGuiConsoleClient->QueryMaterialInfo(req, ans, 10000);
		if (errCode == Error_Succeed)
		{
			CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
			CSmartPointer<IConfigInfo> spConfig;
			ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
			if (eErrDev != Error_Succeed) {
				Dbg("(AfterBindSyncData)open cfg file failed!");
				return Error_Unexpect;
			}
			char sec[2];
			for (int i = 0; i < ans.count; ++i)
			{
				ZeroMemory(sec, 2);
				_itoa(i + 1, (char*)sec, 10);
				Dbg("<AfterBindSyncData>, the %sth CardBox, BoxNo:%s, Name:%s, CardInit:%d, CardRemain:%d, CardIssued:%d, Maintainer:%s",
					sec, ans.CardBoxNo[i].GetData(), ans.PsbName[i].GetData(), ans.CardInit[i], ans.CardRemains[i], ans.CardIssued[i], ans.Maintainer[i].GetData());
				spConfig->WriteConfigValue(sec, "CardBoxNo", ans.CardBoxNo[i]);
				spConfig->WriteConfigValue(sec, "PsbCode", ans.PsbCode[i]);
				spConfig->WriteConfigValue(sec, "PsbName", ans.PsbName[i]);
				spConfig->WriteConfigValueInt(sec, "CardInit", ans.CardInit[i]);
				spConfig->WriteConfigValueInt(sec, "CardRemains", ans.CardRemains[i]);
				spConfig->WriteConfigValueInt(sec, "CardIssued", ans.CardIssued[i]);
				spConfig->WriteConfigValueInt(sec, "CardMixed", ans.CardMixed[i]);
				spConfig->WriteConfigValueInt(sec, "CardPercent", ans.CardPercent[i]);
				spConfig->WriteConfigValue(sec, "Maintainer", ans.Maintainer[i]);
				spConfig->WriteConfigValue(sec, "MaintainTime", ans.MaintainTime[i]);
				if (i == 0)
				{
					spConfig->WriteConfigValueInt("RunInfo", "CardInit", ans.CardInit[i]);
					spConfig->WriteConfigValueInt("RunInfo", "CardRemains", ans.CardRemains[i]);
					spConfig->WriteConfigValueInt("RunInfo", "CardIssued", ans.CardIssued[i]);
					spConfig->WriteConfigValueInt("RunInfo", "CardMixed", ans.CardMixed[i]);
					spConfig->WriteConfigValueInt("RunInfo", "CardPercent", ans.CardPercent[i]);
				}
			}
		}
		else
		{
			Dbg("<AfterBindSyncData>, QueryMaterialInfo ret:%d(0x%x)", errCode, errCode);
			return errCode;
		}
	}
	return Error_Succeed;
}
ErrorCodeEnum CCardIssuerFSM::AfterBindUpdateSCINameToRunCfg(const char *name, bool bBind)
{
	LOG_FUNCTION();
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("(AfterBindUpdateSCINameToRunCfg)open cfg file failed!");
		return eErrDev;
	}
	if (bBind)
	{
		CSimpleStringA csName(name);
		spConfig->WriteConfigValue("SCI", "name", name);
		CSimpleStringA csVendor = csName.SubString(0, 2);
		Dbg("<AfterBindUpdateSCINameToRunCfg>, SCI Vendor: %s", csVendor.GetData());
		//怡化：YH；广电：YT；中航：ZH；南天：NT，中世顺：ZS；中钞科堡 CK，长城：CC，东方通信：DX
		if (csVendor.Compare("CK") == 0)
			spConfig->WriteConfigValue("SCI", "Vendor","keba");
		else if (csVendor.Compare("YT") == 0)
			spConfig->WriteConfigValue("SCI", "Vendor", "grg");
		else if (csVendor.Compare("NT") == 0)
			spConfig->WriteConfigValue("SCI", "Vendor", "nantian");
		else if (csVendor.Compare("ZS") == 0)
			spConfig->WriteConfigValue("SCI", "Vendor", "zss");
		else if (csVendor.Compare("CC") == 0)
			spConfig->WriteConfigValue("SCI", "Vendor", "GWI");
		else if (csVendor.Compare("DX") == 0) {
			spConfig->WriteConfigValue("SCI", "Vendor", "EastCom");
		}
		else {
			spConfig->WriteConfigValue("SCI", "Vendor", (const char*)csVendor);
		}
	} else {
		spConfig->WriteConfigValue("SCI", "Vendor", "");
		spConfig->WriteConfigValue("SCI", "name", "");
		m_csDevSN = "";
	}
	return Error_Succeed;
}
void CCardIssuerFSM::GetVendorDllName(CSimpleStringA &strDevAdaptorPath)
{
	if (m_csMachineType.Compare("RVC.Stand2S") == 0 || m_csMachineType.Compare("RVC.CardStore") == 0
		|| m_csMachineType.Compare("RVC.CardPrinter") == 0
		|| m_csMachineType.Compare("RVC.Desk1S") == 0 
		|| (m_csMachineType.Compare("RVC.Desk2S") == 0 && m_majorVerion == 2 && (m_minorVerion == 0 || m_minorVerion == 1)))
	{
		SpGetDevAdaptorPath(m_pEntity, GetEntityBase()->GetEntityName(), strDevAdaptorPath);
		return;
	}
	CSmartPointer<IConfigInfo> spConfigRoot,spConfigRun;
	ErrorCodeEnum eErr = Error_Unexpect;
	eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	if (eErr == Error_Succeed)
	{
		CSimpleStringA str("");
		strDevAdaptorPath = "CardIssuer";
		spConfigRun->ReadConfigValue("SCI", "Vendor", str);
		if (!str.IsNullOrEmpty())
		{
			strDevAdaptorPath += ".";
			strDevAdaptorPath += str;
		}
		HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, str);	
		//一代便携式发卡器
		const int SCIVersion = IsValidSCIName(m_csDevSN, m_csDevSN.GetLength());
		if(SCIVersion == 1) {
			// 南天更换新硬件驱动 [11/6/2019 16:47 @Gifur]
			if(m_csDevSN.IsStartWith("NTSCIB", true)) {
				strDevAdaptorPath += ".1.5";
				Dbg("nantian new version device.");
			} else {
				//oilyang@20171228 根据和邱总讨论结果，便携卡机固定1.4
				strDevAdaptorPath += ".1.4";
			}
		} else if(SCIVersion == 2){
			// 新发卡器定义版本 [10/21/2019 8:35 @Gifur]
			strDevAdaptorPath += ".1.20";
		} else {
			Dbg("find the cfg in the root.ini!!!");
			eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
			if (eErr == Error_Succeed) {
				//当运行时没有厂商名称时
				if(strDevAdaptorPath.Compare("CardIssuer", true) == 0) {
					str.Clear();
					spConfigRoot->ReadConfigValue("Device.CardIssuer", "Vendor", str);
					if (!str.IsNullOrEmpty())
					{
						strDevAdaptorPath += ".";
						strDevAdaptorPath += str;
					}
					HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, str);
				}
				str.Clear();
				spConfigRoot->ReadConfigValue("Device.CardIssuer", "Version", str);
				if (!str.IsNullOrEmpty())
				{
					strDevAdaptorPath += ".";
					strDevAdaptorPath += str;
				}
				str.Clear();
				spConfigRoot->ReadConfigValue("Device.CardIssuer", "Batch", str);
				if (!str.IsNullOrEmpty())
				{
					strDevAdaptorPath += ".";
					strDevAdaptorPath += str;
				}
			} else {
				Dbg("Error occurs when open root config: %d", eErr);
			}
		}
		CSimpleStringA strDepPath;
		GetEntityBase()->GetFunction()->GetPath("Dep", strDepPath);
#ifdef RVC_OS_WIN
		strDevAdaptorPath = CSimpleStringA::Format("%s\\%s.dll",
			strDepPath.GetData(),
			strDevAdaptorPath.GetData());
#else
		strDevAdaptorPath = CSimpleStringA::Format("%s/%s.so",
			strDepPath.GetData(),
			strDevAdaptorPath.GetData());
#endif
	}
	return;
}
void CCardIssuerFSM::GetSCINo(CSimpleStringA &sciNo)
{
	Dbg("GetSCINo, sciNo:%s", m_csDevSN.GetData());
	sciNo = m_csDevSN;
}
bool CCardIssuerFSM::AccountExchange(const char *origAcc, CSimpleStringA &acc, int dir)
{
	int len = strlen(origAcc);
	if (len < 8)
	{
		Dbg("<AccountExchange>, account size error:%d", len);
		return false;
	}
	CSimpleStringA csTmp(' ',len+1);
	csTmp[len] = '\0';
	
	if (dir)
	{
		int size, max;
		size = max = len / 4;
		if (len < 16)
			max = 4;
		for (int i = 0; i < max; i++)
		{
			csTmp[i * size] = *(origAcc + i);
			csTmp[i * size + 1] = *(origAcc + 4 + i);
			if (8 + i < len)
				csTmp[i * size + 2] = *(origAcc + 8 + i);
			if (12 + i < len)
				csTmp[i * size + 3] = *(origAcc + 12 + i);
		}
		if (len % 4 != 0)
		{
			for (int j = 4 * (len / 4); j < len; j++)
				csTmp[j] = *(origAcc + j);
		}
		acc = csTmp;
	}
	else
	{
		int size, max;
		size = max = len / 4;
		if (len < 16)
			max = 4;
		for (int i = 0; i < size; i++)
		{
			csTmp[i * 4] = *(origAcc + i);
			csTmp[i * 4 + 1] = *(origAcc + size + i);
			csTmp[i * 4 + 2] = *(origAcc + 2*size + i);
			csTmp[i * 4 + 3] = *(origAcc + 3*size + i);
		}
		if (len % 4 != 0)
		{
			for (int j = 4 * (len / 4); j < len; j++)
				csTmp[j] = *(origAcc + j);
		}
		acc = csTmp;
	}
	return true;
}
bool CCardIssuerFSM::WriteSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char *cardSerial, int slot, bool bClear)
{
	char buf[8];
	ZeroMemory(buf, 8);
	int sum = 0;
	cfgRun->ReadConfigValueInt("SlotInfo", "count", sum);
	if (bClear)
	{
		cfgRun->WriteConfigValue("SlotInfo", _itoa(slot, buf, 10), "0,0,0");
		return true;
	}

	CSimpleStringA csAcc("");
	if (AccountExchange(acc, csAcc))
	{
		csAcc = csAcc + ",1," + cardSerial;
		cfgRun->WriteConfigValue("SlotInfo", _itoa(slot, buf, 10), csAcc);
		sum++;
		cfgRun->WriteConfigValueInt("SlotInfo", "count", sum);
		return true;
	}
	return false;
}
bool CCardIssuerFSM::ReadSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &cardSerial, int slot, int &hasCard)
{
	char buf[8];
	ZeroMemory(buf, 8);
	CSimpleStringA csAcc("");
	cfgRun->ReadConfigValue("SlotInfo", _itoa(slot, buf, 10), csAcc);
	CAutoArray<CSimpleStringA> arr = csAcc.Split(',');
	if (arr.GetCount() < 3)
	{
		//Dbg("data error.size:%d",arr.GetCount());
		return false;
	}
	if (arr[1].Compare("1") == 0)
		hasCard = 1;
	else
		hasCard = 0;
	csAcc = arr[0];
	cardSerial = arr[2];
	//Dbg("account length: %d", strlen(csAcc));
	if (AccountExchange(csAcc, acc, 0))
	{
		return true;
	}
	return false;
}
bool CCardIssuerFSM::WriteCardInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char* serial, int slot, bool bClear, bool bHasCard)
{
	char buf[8];
	ZeroMemory(buf, 8);
	if (bClear || !bHasCard)
	{
		cfgRun->WriteConfigValue("OperateCardStore", _itoa(slot, buf, 10), "0,0,0");
		return true;
	}
	
	CSimpleStringA csAcc("");
	if (AccountExchange(acc, csAcc))
	{
		CSimpleStringA tmp("1,");				
		csAcc = tmp + csAcc + "," + serial;
		cfgRun->WriteConfigValue("OperateCardStore", _itoa(slot, buf, 10), (const char*)csAcc);
		return true;
	}
	return false;
}

bool CCardIssuerFSM::ReadCardInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &serial, int slot)
{
	char buf[8];
	ZeroMemory(buf, 8);
	CSimpleStringA csAcc("");
	cfgRun->ReadConfigValue("OperateCardStore", _itoa(slot, buf, 10), csAcc);
	CAutoArray<CSimpleStringA> arr = csAcc.Split(',');
	if (arr.GetCount() < 3)
	{
		//Dbg("data error.size:%d",arr.GetCount());
		return false;
	}
	csAcc = arr[1];
	serial = arr[2];
	if(strlen(csAcc) < 8 || serial.GetLength() <= 0)
	{
		return false;
	}
	if (AccountExchange(csAcc, acc, 0))
	{
		return true;
	}
	return false;
}
bool CCardIssuerFSM::SetSlotFlag(int slot, bool bReset,bool bClear)
{
	return true;
}
void CCardIssuerFSM::ClearAllLocalSlotInfo()
{
	LOG_FUNCTION();
	CSmartPointer<IConfigInfo> spConfigRun;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	if (eErr != Error_Succeed)
	{
		Dbg("<ClearAllLocalSlotInfo>, open runcfg failed.%d(0x%x)", eErr, eErr);
		return;
	}
	for (int i = 0; i < m_maxSlot; i++)
	{
		WriteSlotInfo(spConfigRun, "", "",i, true);
	}
}
int CCardIssuerFSM::PreOnlineOnStore(SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx)
{
	HeartBeatService_ClientBase *pHeartBeatClient = NULL;
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);
	pHeartBeatClient = new HeartBeatService_ClientBase(GetEntityBase());
	if (pHeartBeatClient != NULL) {
		eErr = pHeartBeatClient->Connect();
		if (eErr != Error_Succeed) {
			pHeartBeatClient->SafeDelete();
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Connect_Heatbeat_Failed, "connect heartbeat faile while preonline.");
		}
	}
	else
	{
		Dbg("pGuiConsoleClient is null?");
		ctx->Answer(Error_Unexpect);
		return 0;
	}
	Dbg("<PreOnlineOnStore>, connect to heartbeat suc.");
	m_crossStart = GetTickCountRVC();
	if (eErr == Error_Succeed)
	{
		if (pHeartBeatClient != NULL)
		{
			m_crossCtx = ctx;
			HeartBeatService_CardActive_Req req;
			HeartBeatService_CardActive_Ans ans;
			req.type = 0;
			req.account = ctx->Req.account;
			req.term = ctx->Req.termNo;
			req.data = ctx->Req.businessData;
			req.slot = ctx->Req.slot;

			errMsg = CSimpleStringA::Format("<PreOnlineOnStore>, send CardActive, termNo:%s, slot:%d", req.term, req.slot);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Send_CardActive, errMsg.GetData());

			eErr = pHeartBeatClient->CardActive(req, ans, 60000);

			errMsg = CSimpleStringA::Format("CardActive Result(termNo:%s, slot:%d):%d(0x%x)", req.term, req.slot, eErr, eErr);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Recv_CardActive, errMsg.GetData());

			pHeartBeatClient->GetFunction()->CloseSession();
			pHeartBeatClient = NULL;
		}
	}
	return 0;
}
void CCardIssuerFSM::NotifyPreOnline(unsigned long errCode, unsigned long findCard, unsigned long cardPos, CSimpleStringA data)
{
	UINT64 crossEnd = GetTickCountRVC();
	//in 110 second
	if (m_crossCtx != NULL)
	{
		if ((crossEnd - m_crossStart) < 110 * 1000)
		{
			m_crossCtx->Ans.cardPos = cardPos;
			m_crossCtx->Ans.findCard = findCard;
			m_crossCtx->Ans.result = data;
			CSimpleStringA outParam = CSimpleStringA::Format("NotifyPreOnline, cardPos:%d, findCard:%d, data:%s, errCode:%d", cardPos, findCard, data.GetData(), errCode);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_NotifyPreOnline_ParamInfo, outParam.GetData());
			m_crossCtx->Answer((ErrorCodeEnum)errCode);
		}
		m_crossCtx = NULL;
	}
}
int CCardIssuerFSM::IssueCardFromStore(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx,bool bSpec)
{
	LOG_FUNCTION();

	CSimpleStringA errMsg(true);
	errMsg = CSimpleStringA::Format("IssueCardFromStore with req.hopper=%d", ctx->Req.hopper);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_IssueCardFromStore, errMsg.GetData());

	ErrorCodeEnum eErr = Error_Unexpect;
	eErr = m_hDevHelper->MoveCardFromSlot(ctx->Req.reserved1[0]);
	Dbg("IssueCardFromStore, reserved1:%d, req.hopper:%d", ctx->Req.reserved1[0], ctx->Req.hopper);

	if (eErr == Error_Succeed)
	{
		//oiltmp 只为杭州中心门禁
		if (ctx->Req.hopper == 97)
		{
			ctx->Answer(Error_Succeed);
			return 0;
		}
		CardNo card;
		ctx->Ans.reserved1.Init(3);
		ctx->Ans.reserved2.Init(2);
		eErr = m_hDevHelper->ReadAccount(card);
		Dbg("IssueCardFromStore, dwSize:%d, t2dwSize:%d, t3dwSize:%d, card.account len:%d, reserved2[0] len:%d",
				card.dwSize, card.dwTrack2Size, card.dwTrack3Size, strlen(card.account), ctx->Req.reserved2[0].GetLength());

		if (eErr == Error_Succeed && ctx->Req.reserved2[0].GetLength() == card.dwSize && strncmp(card.account, ctx->Req.reserved2[0], card.dwSize) == 0)
		{
			m_currCardNo = card.account;
			if (card.dwSize > 6)
				Dbg("<IssueCardFromStore>, Account length:%d, %s****%s", m_currCardNo.GetLength(),
					m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
			ctx->Ans.reserved1[0] = 0;
			ctx->Ans.reserved1[1] = 0;
			if (bSpec)
			{
				ctx->Ans.reserved1[1] = 4;
				if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 32)
					ctx->Ans.reserved2[0] = card.account;
				else
					ctx->Ans.reserved2[0] = "";
				//oilyang@20171214 直接吐卡 @宋锐
				EjectTask *task = new EjectTask(this);
				task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				ctx->Answer(Error_Succeed);
				return 6;
			}
		}
		else
		{
			ctx->Ans.reserved1[0] = 3;
			if (bSpec)
			{
				if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 32)
					ctx->Ans.reserved2[0] = card.account;
				else
					ctx->Ans.reserved2[0] = "";

				if (ctx->Req.hopper == 98)
				{
					ctx->Ans.reserved1[1] = 4;
					//oilyang@20171214 直接吐卡 @宋锐
					EjectTask *task = new EjectTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					ctx->Answer(Error_Succeed);
					return 6;
				}
				if (ctx->Req.hopper == 100)
				{
					int ret = 2;
					ctx->Ans.reserved1[1] = 5;
					//zjw@20190506 直接吞卡 @宋锐
					//这里改为同步，因为清卡操作要循环调用，以防本次还未吞卡结束又调用下一次清卡，导致流程混乱
					Dbg("clear card in cardstore, normal capture card.");
					eErr = MachineMoveCardBackNotHold();
					if(eErr == Error_Succeed)
					{
						bool bCaptured = RegistCardWhileCaptureCard();
					}
					else
						ret = 1;
					m_CardCaptured++;
					if(!SetCardCaptured(m_CardCaptured))
						Dbg("<IssueCardFromStore>, set card captured failed.");
					m_pCardProcess->DataInit();
					if(Error_Succeed == eErr)
					{
						eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
						if(eErr != Error_Succeed) {
							SetErrPackage(m_errPkg, "IssueCardFromStore::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN)", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_SetCardInType);
							AlarmDEC(m_errPkg);
						}
						if(ctx != NULL)
							ctx->Answer(Error_Succeed);
					}
					else
					{
						LogError(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Capture_Failed, "IssueCardFromStore::MachineMoveCardBackNotHold, capture card failed.");
						if (ctx != NULL)
							ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_Failed);
					}
					return ret;
				}
			}
			else
			{
				eErr = m_hDevHelper->MoveCardToSlot(ctx->Req.reserved1[0]);
				Dbg("IssueCardFromStore, slot:%d", ctx->Req.reserved1[0]);

				if (eErr == Error_Succeed)
				{
					Dbg("<IssueCardFromStore>, accout not eqaul, card have been move back to slot.");
					ctx->Ans.reserved1[1] = 1;
					ctx->Answer(Error_Succeed);
					return 2;
				}
				else
				{
					SetErrPackage(m_errPkg, "IssueCardFromStore::MoveCardToSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot);
					AlarmDEC(m_errPkg);
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard,
						"accout not eqaul,card move back to slot failed, to capture card");
					RegistCardWhileCaptureCard();
					eErr = MachineMoveCardBackNotHold();
					if (eErr == Error_Succeed)
					{
						ctx->Ans.reserved1[1] = 2;
						ctx->Answer(Error_Succeed);
						return 2;
					}
					else
					{
						ctx->Ans.reserved1[1] = 3;
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Capture_Failed,
							"accout not eqaul,card move back to slot failed,capture card failed.");
					}
				}
			}
		}
		ctx->Answer(Error_Succeed);

	}
	else
	{
		SetErrPackage(m_errPkg, "IssueCardFromStore::MoveCardFromSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		return 2;
	}
	return 0;
}
int CCardIssuerFSM::AddCardToStoreStepFirst(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_addCardNo = "";
	m_addCardSerial = "";
	ErrorCodeEnum eErr = Error_Unexpect;
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_AddCardToStoreStepFirst, "AddCardToStoreStepFirst");
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER,99);
	Dbg("AddCardToStoreStepFirst, param:%d", CI_MOVECARD_FROM_HOPPER);

	ctx->Ans.reserved1.Init(4);
	ctx->Ans.reserved2.Init(2);
	
	if (eErr == Error_Succeed)
	{
		CardNo card;
		ctx->Ans.reserved2[0] = "";
		eErr = m_hDevHelper->ReadAccount(card);
		
		Dbg("AddCardToStoreStepFirst, dwSize:%d, t2dwSize:%d, t3dwSize:%d",
				card.dwSize, card.dwTrack2Size, card.dwTrack3Size);

		bool bDataOK = true;//oilyang@20171213 是否读卡失败，是否解析出卡序号，否则吞卡 @宋锐
		if (eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
		{
			//oilyang@20201217 if only ic 
			if (card.dwTrack3Size == 2)
			{
				Dbg("maybe only ic card.");
				ctx->Ans.reserved2[1] = m_addCardSerial = (const char*)card.track3;
			}
			else
			{
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char* tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				bool bT2OK = false, bT3OK = false;
				if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
				{
					Dbg("track2 has F in the end.");
					if (card.track2[card.dwTrack2Size - 1] == 'F')
					{
						card.track2[card.dwTrack2Size - 1] = '\0';
						card.dwTrack2Size--;
					}
					bT2OK = true;
				}
				if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150)
					bT3OK = true;
				DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
				if (SplitTrack2(tmpMag2, track2Data) == 0)
				{
					ctx->Ans.reserved2[1] = track2Data.t2CardSerial;
					m_addCardSerial = track2Data.t2CardSerial;
				}
			}
			ctx->Ans.reserved1[2] = 0;
			m_currCardNo = m_addCardNo = ctx->Ans.reserved2[0] = CSimpleStringA(card.account, card.dwSize);
			if (card.dwSize > 6)
				Dbg("<AddCardToStoreStepFirst>, Account length:%d, %s****%s",
					m_currCardNo.GetLength(), (ctx->Ans.reserved2[0].SubString(0, 6)).GetData(),
					(ctx->Ans.reserved2[0].SubString(ctx->Ans.reserved2[0].GetLength() - 4, 4)).GetData());

			Dbg("<AddCardToStoreStepFirst>, CardSerial:%s", m_addCardSerial.GetData());
			if (m_addCardSerial.GetLength() > 0)
			{
				ctx->Answer(Error_Succeed);
			}
			else
				bDataOK = false;
		}
		else {
			bDataOK = false;
			if (eErr != Error_Succeed) {
				SetErrPackage(m_errPkg, "AddCardToStoreStepFirst::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
				AlarmDEC(m_errPkg);
			}
		}
		if (!bDataOK)
		{
			CSimpleStringA errMsg = CSimpleStringA::Format("AddCardToStoreStepFirst failed,to capture card.%d,serial:%s", eErr, m_addCardSerial.GetData());
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, errMsg.GetData());
			ctx->Ans.reserved1[2] = 1;
			RegistCardWhileCaptureCard();
			eErr = MachineMoveCardBackNotHold();
			ctx->Answer(Error_Succeed);
			if (eErr == Error_Succeed)
				return 2;
		}
	}
	else
	{
		//oiltest need to add
		SetErrPackage(m_errPkg, "AddCardToStoreStepFirst::MoveCard", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCard);
		AlarmDEC(m_errPkg);
		ctx->Ans.reserved1[2] = 3;
		ctx->Answer(Error_Succeed);
		return 2;
	}

	return 0;
}
int CCardIssuerFSM::AddCardToStoreStepLast(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg("");
	int slot = FindFirstEmptySlot();
	errMsg = CSimpleStringA::Format("AddCardToStoreStepLast, slot:%d", slot);
	LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_AddCardToStoreStepLast, errMsg.GetData());

	if (slot < 0)
	{
		errMsg = CSimpleStringA::Format("AddCardToStoreStepLast::FindFirstEmptySlot failed or cannot find a empty slot(%d).", slot);
		LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_FindFirstEmptySlot_Failed, errMsg.GetData());
		ctx->Answer(AnswerErrCode(Error_Unexpect), CardIssuer_UserErrorCode_KakuFindEmptySlot_Failed);
		return 0;
	}
	ctx->Ans.reserved1.Init(4);
	ctx->Ans.reserved2.Init(2);
	eErr = m_hDevHelper->MoveCardToSlot(slot);
	Dbg("AddCardToStoreStepLast, slot:%d", slot);

	if (eErr == Error_Succeed)
	{
		m_currCardNo = "";
		ctx->Ans.reserved1[0] = slot;
		ctx->Ans.reserved1[2] = 0;
		ctx->Ans.reserved2[0] = "";
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr != Error_Succeed)
		{
			Dbg("<AddCardToStoreStepLast>, open runcfg to write slot info failed:%d(0x%x)", eErr, eErr);
		}
		else
			WriteSlotInfo(spConfigRun, (const char*)m_addCardNo,(const char*)m_addCardSerial, slot);
		ctx->Answer(Error_Succeed);
		return 2;
	}
	else
	{
		ctx->Ans.reserved1[2] = 2;
		RegistCardWhileCaptureCard();
		MachineMoveCardBackNotHold();
		errMsg = CSimpleStringA::Format("AddCardToStoreStepLast failed,to capture card. slot:%d", slot);
		LogError(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, errMsg.GetData());
		SetErrPackage(m_errPkg, "AddCardToStoreStepLast::MoveCardToSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		return 2;
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::FindFirstEmptySlot()
{
	LOG_FUNCTION();
	SlotStatus status;
	ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(status, 0,true);
	Dbg("FindFirstEmptySlot, status.dwSize:%d", status.dwSize);

	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "FindFirstEmptySlot::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
		AlarmDEC(m_errPkg);
		return -1;
	}
	for (int i = 0; i < status.dwSize; i++)
	{
		if (status.status[i] == 0)
		{
			Dbg("find an empty slot %d.", i);
			return i;
		}
	}
	Dbg("can't find a empty slot");
	return -1;
}
bool CCardIssuerFSM::IsValidSlotNum(const int slot)
{
	if (m_maxSlot == 0 || slot < 0 || slot >= m_maxSlot) {
		Dbg("<IsValidSlotNum>, invalid slot:%d", slot);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::IsSlotHasCard(const int slot)
{
	if (m_hDevHelper != NULL)
	{
		SlotStatus status;
		ErrorCodeEnum eErr = m_hDevHelper->QuerySlotsStatus(status, slot);
		Dbg("IsSlotHasCard, slot:%d, status:%d", slot, status.status[slot]);

		if (eErr == Error_Succeed && status.status[slot] == 1)
			return true;

		if (eErr != Error_Succeed) {
			SetErrPackage(m_errPkg, "IsSlotHasCard::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
			AlarmDEC(m_errPkg);
		}
	}
	return false;
}
void CCardIssuerFSM::AfterPreOnlineOnStore(ErrorCodeEnum err, const int slot)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);

	if (err == Error_Param)//oilyang@20171201 暂时不会进这里了，根据郭丹说明，所有跨机操作优先把卡移回卡槽
	{
		RegistCardWhileCaptureCard();
		eErr = MachineMoveCardBackNotHold();
		if (eErr == Error_Succeed)
			m_cardPos = 2;
		else
			m_cardPos = 3;
	}
	else
	{
		eErr = m_hDevHelper->MoveCardToSlot(slot);
		Dbg("AfterPreOnlineOnStore, slot:%d", slot);

		if (eErr == Error_Succeed)
		{
			m_cardPos = 1;
		}
		else
		{
			SetErrPackage(m_errPkg, "GetDevStatus::AfterPreOnlineOnStore::MoveCardToSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot);
			AlarmDEC(m_errPkg, true);

			errMsg = CSimpleStringA::Format("AfterPreOnlineOnStore::MoveCardToSlot failed, to capture card, slot:%d", slot);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, errMsg.GetData());

			RegistCardWhileCaptureCard();
			eErr = MachineMoveCardBackNotHold();
			if (eErr == Error_Succeed)
				m_cardPos = 2;
			else
				m_cardPos = 3;
		}
	}
		GetEntityBase()->GetFunction()->SetSysVar("CardStoreInUse", "N");
}

bool CCardIssuerFSM::OperateCardStore(CSmartPointer<IConfigInfo> &spConfigRun, int slot, int& status)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	DevErrorInfo devErrorInfo;
	CSimpleStringA errMsg(true);

	eErr = m_hDevHelper->MoveCardFromSlot(slot);
	Dbg("OperateCardStore, slot:%d", slot);

	if(eErr == Error_Succeed)
	{
		CardNo card;
		ZeroMemory(card.account, sizeof(card.account));
		eErr = m_hDevHelper->ReadAccount(card);
		Dbg("OperateCardStore, dwSize:%d, t2Size:%d, t3Size:%d",
				card.dwSize, card.dwTrack2Size, card.dwTrack3Size);


		bool bDataOK = true;
		//读卡成功并解析出卡序号，才算成功，卡序号也要返回
		if(eErr == Error_Succeed && card.dwSize > 0 && card.dwSize < 64)
		{
			Dbg("read account OK.");
			//oilyang@20201217 if only ic 
			if (card.dwTrack3Size == 2)
			{
				Dbg("maybe only ic card.");
				m_addCardSerial = (const char*)card.track3;
			}
			else
			{
				Track2Data track2Data;
				track2Data.status = 0;
				track2Data.t2Account = "";
				char* tmpMag2 = new char[256];
				ZeroMemory(tmpMag2, 256);
				bool bT2OK = false, bT3OK = false;
				if (card.dwTrack2Size > 0 && card.dwTrack2Size < 41)
				{
					//IC卡等效二磁道数据可能存在补F的情况(参考oilyang@20171129)
					if (card.track2[card.dwTrack2Size - 1] == 'F')
					{
						Dbg("track2 has F in the end");
						card.track2[card.dwTrack2Size - 1] = '\0';
						card.dwTrack2Size--;
					}
					bT2OK = true;
				}
				if (card.dwTrack3Size > 0 && card.dwTrack3Size < 150)
					bT3OK = true;
				DecodeTracksData(card.track2, card.dwTrack2Size, card.track3, card.dwTrack3Size, tmpMag2, bT2OK, bT3OK);
				if (SplitTrack2(tmpMag2, track2Data) == 0)
				{
					Dbg("set card serial %s", (const char*)track2Data.t2CardSerial);
					m_addCardSerial = track2Data.t2CardSerial;
				}
			}
			m_currCardNo = card.account;
			if (card.dwSize > 6)
				Dbg("<OperateCardStore>, Account lenth:%d, %s****%s",
					m_currCardNo.GetLength(), m_currCardNo.SubString(0, 6).GetData(), m_currCardNo.SubString(m_currCardNo.GetLength() - 4, 4).GetData());
			Dbg("card serial %s", m_addCardSerial.GetData());
			if (m_addCardSerial.GetLength() <= 0)
				bDataOK = false;
		}
		else
		{
			bDataOK = false;
		}
		if(!bDataOK)
		{
			SetErrPackage(m_errPkg, "OperateCardStore::ReadAccount", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_ReadAccount);
			AlarmDEC(m_errPkg, true);

			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, "OperateCardStore::ReadAccount failed, to capture card.");
			status = 2;
			RegistCardWhileCaptureCard();
			eErr = MachineMoveCardBackNotHold();
		}
		else
		{
			eErr = m_hDevHelper->MoveCardToSlot(slot);
			Dbg("OperateCardStore, slot:%d", slot);

			if(eErr == Error_Succeed)
			{
				if(WriteCardInfo(spConfigRun, m_currCardNo, m_addCardSerial, slot, false, true))
				{
					spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", slot);//记录已盘库到哪个槽
					status = 0;
					return true;
				}
				else
				{
					Dbg("operate slot(%d) success, but write card info to cardissuer.ini failed.");
				}
			}
			else
			{
				//移回卡槽不成功，登记并吞卡
				SetErrPackage(m_errPkg, "OperateCardStore::MoveCardToSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardToSlot);
				AlarmDEC(m_errPkg, true);
				errMsg = CSimpleStringA::Format("OperateCardStore::MoveCardToSlot, to capture card. slot:%d", slot);
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard, errMsg.GetData());
				status = 3;
				RegistCardWhileCaptureCard();
				MachineMoveCardBackNotHold();
			}
		}
	}
	else
	{
		SetErrPackage(m_errPkg, "OperateCardStore::MoveCardFromSlot", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_MoveCardFromSlot);
		AlarmDEC(m_errPkg, true);
		status = 1;
	}
	return false;
}

int CCardIssuerFSM::QueryCardInfoOnStore(SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	CSimpleStringA cardInfo("");

	if(!ctx->Req.reserved1)
	{
		//原有业务
		ctx->Ans.findCard = m_findCard;
		ctx->Ans.cardPos = m_cardPos;
		cardInfo = CSimpleStringA::Format("query findCard:%d,cardPos:%d", ctx->Ans.findCard, ctx->Ans.cardPos);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_QueryCardInfoOnStore_JustQueryInfo, cardInfo.GetData());
		Dbg("<QueryCardInfoOnStore>, query findCard:%d, cardPos:%d", ctx->Ans.findCard, ctx->Ans.cardPos);
		ctx->Answer(Error_Succeed);
		return 2;
	}
	else
	{
		//新增盘库操作@20190422 by zjw
		ErrorCodeEnum eErr = Error_Unexpect;
		DevErrorInfo devErrorInfo;
		bool bRet;
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if(eErr != Error_Succeed)
		{
			Dbg("<QueryCardInfoOnStore>, Open runcfg failed(%d).", eErr);
			ctx->Answer(Error_Unexpect);
			return 2;
		}

		//开始盘库
		CSimpleStringA errMsg = CSimpleStringA::Format("<QueryCardInfoOnStore>, req.reserved[0]:%d", ctx->Req.reserved1[0]);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_QueryCardInfoOnStore_Inparam, errMsg.GetData());
		if(ctx->Req.reserved1[0] == 1)
		{
			//检查是否有旧的盘库记录，若有，则返回给业务确定继续盘库or终止盘库；若无，则进行正常盘库
			if(CheckHasPanKuRecord(spConfigRun))
			{
				Dbg("Has operation cardstore record, please make sure continue or break!");
				ctx->Answer(Error_Param, CardIssuer_UserErrorCode_KakuHaveOldPanKuRecord);
				return 2;
			}
			
			//如果没有旧的盘库操作，则重新开始盘库（先清理本地记录）
			ClearLocalRecord(spConfigRun);
			SlotStatus slotstatus;
			eErr = m_hDevHelper->QuerySlotsStatus(slotstatus, 0, true);

			if(eErr != Error_Succeed)
			{
				SetErrPackage(m_errPkg, "QueryCardInfoOnStore::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
				ctx->Answer(AnswerErrCode(Error_Unexpect), AlarmDEC(m_errPkg, true));
				return 2;
			}
			spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 1);//设置盘库标志
			int i = 0;
			int status = 0;

			for (; i < m_maxSlot; ++i)
			{
				if (slotstatus.status[i] == 1)
				{
					bRet = OperateCardStore(spConfigRun, i, status);
					if (!bRet)
						break;
				}
				else
				{
					//该卡槽无卡
					WriteCardInfo(spConfigRun, "", "", i);
				}
			}
			//将卡信息返回给业务端
			ReturnCardInfo(i, status, spConfigRun, ctx);
		}
		else if(ctx->Req.reserved1[0] == 2)
		{
			//有旧的盘库记录，继续接着盘库
			SlotStatus slotstatus;
			eErr = m_hDevHelper->QuerySlotsStatus(slotstatus,0,true);
			int slotNum;
			spConfigRun->ReadConfigValueInt("OperateCardStore", "SlotNum", slotNum);
			if(slotNum >= 0)
			{
				int status = 0;
				int i = slotNum;

				for(; i < m_maxSlot; ++i)
				{
					if(slotstatus.status[i] == 1)
					{
						bRet = OperateCardStore(spConfigRun, i, status);
						if(!bRet)
							break;
					}
					else
					{
						//该卡槽无卡
						WriteCardInfo(spConfigRun, "", "", i);
					}
				}
				//将卡信息返回给业务端
				ReturnCardInfo(i, status, spConfigRun, ctx);
			}
			else
			{
				Dbg("No operate cardstore record, please make sure!");
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_KakuHaveNoPanKuRecord);
			}
		}
		else if(ctx->Req.reserved1[0] == 3)
		{
			//有旧的盘库记录，终止盘库(清空本地记录)
			ClearLocalRecord(spConfigRun);
			ctx->Answer(Error_Succeed);
		}
		else if(ctx->Req.reserved1[0] = 4)
		{
			//查询是否有盘库记录
			if(CheckHasPanKuRecord(spConfigRun))
			{
				Dbg("Has operation cardstore record!");
				ctx->Ans.findCard = 1;
				ctx->Answer(Error_Succeed);
			}
			else
			{
				Dbg("Has no operation cardstore record!");
				ClearLocalRecord(spConfigRun);
				ctx->Ans.findCard = 0;
				ctx->Answer(Error_Succeed);
			}
		}
	}
	return 2;
}

bool CCardIssuerFSM::CheckHasPanKuRecord(CSmartPointer<IConfigInfo>&spConfigRun)
{
	int operFlag, slotNum;
	spConfigRun->ReadConfigValueInt("OperateCardStore", "OperationFlag", operFlag);
	spConfigRun->ReadConfigValueInt("OperateCardStore", "SlotNum", slotNum);
	Dbg("<CheckHasPanKuRecord>, operFlag:%d, slotNum:%d", operFlag, slotNum);
	if(operFlag == 1 && slotNum >= 0)
	{
		return true;
	}
	return false;
}

void CCardIssuerFSM::ClearLocalRecord(CSmartPointer<IConfigInfo>&spConfigRun)
{
	spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 0);
	spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", -1);
	for (int i = 0; i < m_maxSlot; ++i)
	{
		WriteCardInfo(spConfigRun, "", "", i, true);
	}
}

void CCardIssuerFSM::ReturnCardInfo(int slotNum, int status, CSmartPointer<IConfigInfo>&spConfigRun, SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	bool bRet;
	Dbg("<ReturnCardInfo>, slotNum:%d, status:%d", slotNum, status);

	if(slotNum == m_maxSlot && status == 0)
	{
		ctx->Ans.reserved1.Init(1);
		ctx->Ans.reserved3.Init(m_maxSlot);
		ctx->Ans.reserved4.Init(m_maxSlot);
		for (int i = 0; i < m_maxSlot; ++i)
		{
			CSimpleStringA csAcc("");
			CSimpleStringA serial("");
			bRet = ReadCardInfo(spConfigRun, csAcc, serial, i);
			if(bRet)
			{
				ctx->Ans.reserved3[i] = csAcc;
				ctx->Ans.reserved4[i] = serial;
			}
			else
			{
				ctx->Ans.reserved3[i] = "0";
				ctx->Ans.reserved4[i] = "0";
			}
		}
		ctx->Ans.reserved1[0] = m_maxSlot;

		//返回完成，清空本地记录
		spConfigRun->WriteConfigValueInt("OperateCardStore", "OperationFlag", 0);
		spConfigRun->WriteConfigValueInt("OperateCardStore", "SlotNum", -1);
		for (int i = 0; i < m_maxSlot; ++i)
		{
			WriteCardInfo(spConfigRun, "", "", i, true);
		}
		ctx->Answer(Error_Succeed);
	}
	else
	{
		Dbg("operate cardstore failed in slot(%d).", slotNum);
		ctx->Ans.reserved1.Init(2);
		ctx->Ans.reserved1[0] = slotNum;
		ctx->Ans.reserved1[1] = status;
		ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_KakuPanKu_Failed);
	}
	return;
}

void CCardIssuerFSM::GetAddCardInfo(SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req, CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;

	if(!ctx->Req.reserved1)
	{
		//原有业务
		Dbg("<GetAddCardInfo>, req.reserved1 is null, just get AddCAradInfo, req.isSync:%d", ctx->Req.isSync);
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr != Error_Succeed)
		{
			Dbg("<GetAddCardInfo>, open runcfg failed:%d(0x%x)", eErr, eErr);
			ctx->Answer(Error_Unexpect);
			return;
		}

		ctx->Ans.count = 0;
		CSimpleStringA csAcc(""), csCardSerial("");
		int hasCard = 0;
		bool bRet = false;
		
		if (ctx->Req.isSync == 1)//clear local record
		{
			for (int i = 0; i < m_maxSlot; i++)
			{
				bRet = ReadSlotInfo(spConfigRun, csAcc, csCardSerial, i, hasCard);
				if (bRet)
					WriteSlotInfo(spConfigRun, "", "", i, true);
			}
			spConfigRun->WriteConfigValueInt("SlotInfo", "count",0);
			ctx->Answer(Error_Succeed);
			return;
		}
		int sum = 0;
		spConfigRun->ReadConfigValueInt("SlotInfo", "count", sum);
		Dbg("<GetAddCardInfo>, add card num:%d", sum);

		if (sum > 0)
		{
			for (int i = 0; i < m_maxSlot; i++)
			{
				bRet = ReadSlotInfo(spConfigRun, csAcc, csCardSerial, i, hasCard);
				if (bRet)
				{
					ctx->Ans.account.Append(&csAcc, 0, 1);
					ctx->Ans.cardSerial.Append(&csCardSerial, 0, 1);
					ctx->Ans.slot.Append(&i, 0, 1);
				}
			}
			ctx->Ans.count = ctx->Ans.account.GetCount();
			if (ctx->Ans.count != sum)
				Dbg("<GetAddCardInfo>, actual added card num is:%d, not equals to the runinfo:%d.", ctx->Ans.count, sum);
		}
	}
	else if(ctx->Req.reserved1[0] == 1)
	{
		ctx->Ans.reserved1.Init(1);
		//获取卡库总容量
		Dbg("<GetAddCardInfo>, CardStore account is:%d", m_maxSlot);
		if(m_maxSlot > 0)
		{
			ctx->Ans.reserved1[0] = m_maxSlot;
		}
		else
		{
			Dbg("CardStore account is less zero.");
		}

		//卡库数量盘点
		DevErrorInfo devErrInfo;
		int numOfHasCard = 0;
		vector<int> slotNoOfHasCard;
		SlotStatus slotstatus;

		eErr = m_hDevHelper->QuerySlotsStatus(slotstatus,0,true);
		if (eErr == Error_Succeed)
		{
			for(int i = 0; i < m_maxSlot; ++i)
			{
				if(slotstatus.status[i] == 1)
				{
					slotNoOfHasCard.push_back(i);
					numOfHasCard++;
				}
			}
			Dbg("num of card in cardstore: %d.", numOfHasCard);
			ctx->Ans.reserved2.Init(numOfHasCard + 1);
			ctx->Ans.reserved2[0] = numOfHasCard;
			for(int j = 0; j < numOfHasCard; ++j)
			{
				ctx->Ans.reserved2[j+1] = slotNoOfHasCard[j];
			}
		}
		else
		{
			SetErrPackage(m_errPkg, "GetAddCardInfo::QuerySlotsStatus", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_QuerySlotsStatus);
			AlarmDEC(m_errPkg, true);
		}
	}

	ctx->Answer(Error_Succeed);
	return;
}
void CCardIssuerFSM::DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size, char *&magData, bool bT2OK, bool bT3OK)
{
	Dbg("<DecodeTracksData>, bT2OK:%d, bT3OK:%d, t2.size:%d(%d), t3.size:%d(%d)",
		bT2OK, bT3OK, dwT2size, strlen(track2), dwT3size, strlen(track3));

	if (!bT2OK)
	{
		Dbg("<DecodeTracksData>, track2 isn't ok.");
		return;
	}
	if (dwT2size <= 0 || strlen(track2) < 15)//运通卡号为15位
	{
		Dbg("<DecodeTracksData>, track2 size maybe wrong.");
		return;
	}
	
	char tmpMag2_3[512] = { 0 };// , tmpMag2[256] = { 0 };
	memcpy(tmpMag2_3, track2, dwT2size);
	char cardType[8];
	ZeroMemory(cardType, 8);
	if (bT3OK && strlen(track3) > 1)
	{
		memcpy(tmpMag2_3 + dwT2size, "A", 1);
		memcpy(tmpMag2_3 + dwT2size + 1, track3, dwT3size);
		cmdDecodeEx(tmpMag2_3, cardType, magData);
	}
	Dbg("<DecodeTracksData>，cardType:%s", cardType);

	if (!bT3OK || strlen(cardType) < 4)
	{
		Dbg("<DecodeTracksData>, track3 data isn't ok or track3 size maybe wrong");
		cmdDecodeMag2(tmpMag2_3, magData);
	}
}
int CCardIssuerFSM::SplitDevModelInfo()
{
	LOG_FUNCTION();
	if (strlen(m_devCat.szModel) < 3)
	{
		Dbg("<SplitDevModelInfo>, Wrong szModel:%s", m_devCat.szModel);
		return -1;
	}
	m_csCM = "";
	CSimpleStringA csTmpModel(m_devCat.szModel);
	CAutoArray<CSimpleStringA> arrParam;
	arrParam.Init(16);
	arrParam = csTmpModel.Split('#');
	for (int i = 0; i < arrParam.GetCount(); ++i)
	{
		if (_strnicmp(arrParam[i], "CM", 2) == 0)
		{
			m_csCM = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);
		}
	}
	return 0;
}

void CCardIssuerFSM::CloseAndClearDevObj(bool bCheckConnecting, bool bCloseOnly)
{
	LOG_FUNCTION();
	ErrorCodeEnum ec = Error_Unexpect;
	Dbg("<CloseAndClearDevObj>, bCheckConnecting:%d, bCloseOnly:%d, m_bBTConncting:%d, m_bBTConnected:%d, m_bOpened:%d",
		bCheckConnecting, bCloseOnly, m_bBTConncting, m_bBTConnected, m_bOpened);
	if(m_bBTConncting) {
		if(m_hDevHelper != NULL) {
			ec = m_hDevHelper->DevClose();
			if (ec != Error_Succeed) {
				SetErrPackage(m_errPkg, "CloseAndClearDevObj::DevClose", m_csDevSN, ec, MEC_DEVAPI_CARDISSUER_DevClose);
				AlarmDEC(m_errPkg);
			}
		}
		if(bCheckConnecting) {
			const int maxWaitTimes = 20;
			int currentWaitTimes = 0;
			do {
				Sleep(500);
				currentWaitTimes++;
				if(currentWaitTimes >= maxWaitTimes) {
					Dbg("Timeout break");
					break;
				}
			} while (m_bBTConncting);
		}
	}
	if(m_bBTConnected || m_bOpened) {
		if(m_hDevHelper != NULL) {
			ec = m_hDevHelper->DevClose();
		} else {
			SetErrPackage(m_errPkg, "CloseAndClearDevObj::DevClose", m_csDevSN, ec, MEC_DEVAPI_CARDISSUER_DevClose);
			AlarmDEC(m_errPkg);
		}
		m_bBTConnected = false;
		m_bOpened = false;
	}
	if (m_hDevHelper != NULL && !bCloseOnly)
	{
		m_hDevHelper.TearDown();
	}
}

int CCardIssuerFSM::PrintCardIm(SpReqAnsContext<CardIssuerService_PrintCardImmediately_Req, CardIssuerService_PrintCardImmediately_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	KakuPrintInfo kakuInfo;
	memset(kakuInfo.formPath, 0, sizeof(kakuInfo.formPath));
	memset(kakuInfo.fields, 0, sizeof(kakuInfo.fields));
	//oiltest where is the file locate?
	CSimpleStringA csDepPath, csBackslash("\\"), filePath;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
	filePath = csDepPath + csBackslash + m_devCat.szVendor + "-" + ctx->Req.formFile;
	strncpy(kakuInfo.formPath,(const char*)filePath, filePath.GetLength());
	strncpy(kakuInfo.fields, (const char*)ctx->Req.printData, ctx->Req.printData.GetLength());
	ErrorCodeEnum eErr = Error_Unexpect;
	eErr = m_hDevHelper->PrintCardFaceRightNow(kakuInfo);
	Dbg("PrintCardFaceRightNow, PrintCardIm, formPath:%s", kakuInfo.formPath);

	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "PrintCardIm::PrintCardFaceRightNow", m_csDevSN, eErr, MEC_DEVAPI_CARDISSUER_PrintCardFaceRightNow);
		AlarmDEC(m_errPkg, true);
		ret = 1;
	}
	ctx->Ans.ret = ret;
	ctx->Answer(Error_Succeed);
	return 0;
}
void CCardIssuerFSM::oiltest()
{
	if (m_hDevHelper != NULL)
	{
		ErrorCodeEnum eErr = Error_Unexpect;
		int sum = 0;
		eErr = m_hDevHelper->GetSlotSum(sum);
		if (eErr == Error_Succeed)
			Dbg("max slot:%d",sum);
		SlotStatus slotstatus;
		eErr = m_hDevHelper->QuerySlotsStatus(slotstatus,0,true);
		if (eErr == Error_Succeed)
		{
			
			for (int i = 0; i < 10; ++i)
			{
				Dbg("slot %d,status %d",i,slotstatus.status[i]);
				if (slotstatus.status[i] == 1)
				{
					eErr = m_hDevHelper->MoveCardFromSlot(i);
					if (eErr == Error_Succeed)
					{
						CardNo card;
						ZeroMemory(card.account, sizeof(card.account));
						eErr = m_hDevHelper->ReadAccount(card);
						if (eErr == Error_Succeed)
						{
							Dbg("slot %d,account:%s", i, card.account);
						}
						else
							Dbg("read slot %d failed.%d", i, eErr);
						if (i % 3 == 0)
						{
							Dbg("move card in slot %d to front gate.", i);
							eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
						}
						else if (i % 3 == 1)
						{
							//oiltest@20171114 for dx
							Dbg("capture card in slot %d 22.", i);
							eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
							//eErr = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
						}
						if (i % 3 == 2)
						{
							Dbg("move card in slot %d back to slot.", i);
							eErr = m_hDevHelper->MoveCardToSlot(i);
						}
						Sleep(5000);
					}
					else
						Dbg("move card from slot failed.%d",eErr);
				}
			}
		}
	}
}

void CCardIssuerFSM::oiltestSCI(bool bSCI)
{
	LOG_FUNCTION();
	if (bSCI && !m_bChannelOK)
	{
		Dbg("SCI压力测试，安全通道建立不成功，终止测试");
		return;
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("(set issue)open cfg file failed!");
		return;
	}

	//三步循环：发卡，读卡，吐卡/吞卡

	//第一步：发卡
	ErrorCodeEnum errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	if (errCode != Error_Succeed)
	{
		//LogErrInfo("before issue,close shutter");
		return;
	}
	int hopperRemains = 0, hopperSN = 1;
	int captureCount = 0;//SCI测试，吞卡计数，吞够3张不再吞（看各厂商吞卡箱容量？）
	while (true)
	{
		spConfig->ReadConfigValueInt("SCITest", "Hopper1Remains", hopperRemains);
		if (hopperRemains == 0)
		{
			spConfig->ReadConfigValueInt("SCITest", "Hopper2Remains", hopperRemains);
			if (hopperRemains == 0)
			{
				Dbg("卡箱1，卡箱2都没有卡片了");
				Dbg("hopper 1 & 2 no more card.");
				return;
			}
			else
			{
				hopperSN = 2;
			}
		}
		Dbg("move card to holder");
		//move card to holder
		errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, hopperSN);

		Dbg("move card result %d.", errCode);
		if (errCode != Error_Succeed)
		{
			//LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MoveCardFromHopper_Failed, "从卡槽发卡失败");
			DevErrorInfo errMove;
			m_hDevHelper->GetLastErr(errMove);
			Dbg("Move card from hopper to position failed(%d),(%s).", errCode, errMove.szErrMsg);
			Dbg("从卡槽发卡失败");
			return;
		}
		Dbg("issue suc.");
		if (hopperSN == 1)
			spConfig->WriteConfigValueInt("SCITest", "Hopper1Remains", hopperRemains - 1);
		else
			spConfig->WriteConfigValueInt("SCITest", "Hopper2Remains", hopperRemains - 1);
		//第二步：读卡

		ErrorCodeEnum eErr;
		int activeCardType;
		bool bIC(false), bICSuc(false), bReadCardInfo(false);
		{
			bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
			if (bIC)
			{
				m_hDevHelper->DeactivateICCard();
				m_hDevHelper->ReleaseIC();
			}
		}
		DWORD dwStart = GetTickCountRVC();
		MagTracks magTracks;
		int readTries = 0;


		magTracks.eRange = CI_TRACK_RANGE_2_3;
		eErr = m_hDevHelper->MagRead(magTracks);
		Dbg("MAGread(%d)...", eErr);
		Dbg("t2,t3:%d,%d", magTracks.track[1].eStatus, magTracks.track[2].eStatus);
		if (magTracks.track[1].dwSize > sizeof(magTracks.track[1].data) || magTracks.track[2].dwSize > sizeof(magTracks.track[2].data))
		{
			Dbg("Wrong dwSize %d,%d", magTracks.track[1].dwSize, magTracks.track[2].dwSize);
		}
		if (bIC)
		{
			//read card no 20140625
			int activeCardType;
			m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
			//oilyang@20201014 add emv support
			int retGetICData = -1;
			retGetICData = m_pCardProcess->GetICDataFromCard(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList);
			ICData track2(false, 0x57, 0x00);
			string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
			if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
			{
				Dbg("no track2 data (ic only)");
			}
			else
			{
				int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
				char *pICTrack2 = new char[128];
				ZeroMemory(pICTrack2, 128);
				HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
				pICTrack2[37] = '\0';
				{
					char *ddd = new char[128];
					memset(ddd, 0, 128);
					memcpy(ddd, pICTrack2, pos - 1);

					t2ICTrack2 = pICTrack2;
					t2ICAccount = (char*)ddd;
					Dbg("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str());
					delete[]ddd;
				}
				delete[]pICTrack2;
			}
			m_hDevHelper->DeactivateICCard();
			m_hDevHelper->ReleaseIC();
			bReadCardInfo = true;
			if (magTracks.track[1].eStatus == CI_DATA_INVALID)
			{
				Dbg("may be ic only...");
			}
		}


		if (Error_Succeed == eErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
			bool bT3OK = false;
			if (magTracks.track[2].eStatus == CI_DATA_OK)
			{
				bT3OK = true;
			}
			Track2Data track2Data;
			track2Data.status = 0;
			track2Data.t2Account = "";
			char *tmpMag2 = new char[256];
			ZeroMemory(tmpMag2, 256);
			DecodeTracksData((const char*)magTracks.track[1].data, magTracks.track[1].dwSize, (const char*)magTracks.track[2].data, magTracks.track[2].dwSize, tmpMag2, true, bT3OK);

			int pos = 0;
			for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e)
					break;
			}
			Dbg("pos:%d,%d", pos, magTracks.track[1].dwSize);

			char *ddd = new char[40];
			memset(ddd, 0, 40);
			memcpy(ddd, magTracks.track[1].data, pos);

			if (SplitTrack2(tmpMag2, track2Data) == 0)
			{
				Dbg("done.");
				bReadCardInfo = true;
			}

			delete[]ddd;
			if (tmpMag2 != NULL)
			{
				delete[]tmpMag2;
				tmpMag2 = NULL;
			}
		}

		//第三步：吐卡/吞卡

		srand((int)time(NULL));
		int tmpNum = rand() % 7;
		if (captureCount < 5 && tmpNum == 5)//吞卡箱容量优先，超过了就不再吞了，随意选择一个数，假定能实现1/7的概率吞卡
		{
			ErrorCodeEnum eErr;
			eErr = MachineMoveCardBackNotHold();
			Dbg("asked to capture %d", eErr);
			if (eErr != Error_Succeed)
			{
				Dbg("capture card failed.");
				DevErrorInfo devErrInfo;
				m_hDevHelper->GetLastErr(devErrInfo);
				Dbg("capture err %s", devErrInfo.szErrMsg);
			}
			captureCount++;
			Dbg("capture card suc,the %d", captureCount);
			m_pCardProcess->DataInit();
			if (Error_Succeed == eErr) {
				eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
			}
		}
		else
		{
			EjectCard(NULL);
			//等待取卡
			DWORD dwStart, dwEnd;
			dwStart = GetTickCountRVC();
			do {
				if (GetDevStatus()) {
					dwEnd = GetTickCountRVC();
					if (m_devStatus.eMedia == CI_MEDIA_ENTERING) {
						Sleep(WAIT_INTERVAL);
						//waitTries++;
					}
					else {
						Dbg("Card have been fetched.");
						break;
					}
				}
				else
				{
					Dbg("GetDevStatus faied.");
					break;
				}
			} while ((dwEnd - dwStart) < 60 * 1000);
		}
	}
}