myvtm/Module/mod_CardIssuerStand/CardIssuerStandFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CardIssuerStandFSM.h"
#include "EventCode.h"
#include "RVCEventCode.h"
#include "RVCComm.h"
//oilyang@20200522 go on using
// deprecated!! [4/17/2020 16:15 @Gifur]
#include "CardIssuerStand_UserErrorCode.h"	//后续替代EventCode.h，暂时混合使用，时间太紧
#include "CardIssuerStand_msg_g.h"
#include "ModuleMix.h"

#include "publicFunExport.h"
#pragma comment(lib, "libpublicFun.lib")
#include <algorithm>
#include <map>
#ifdef RVC_OS_WIN
#define _ATL_NO_AUTOMATIC_NAMESPACE
#include <atltime.h>
#endif //RVC_OS_WIN

#include "CardIssuerClass.h"
#include "mod_cardissuerStand.h"
#include "stdafx.h"
#include <regex>

//oiltest@20200915 temp for GetTickCount
#ifdef RVC_OS_WIN
#define _ATL_NO_AUTOMATIC_NAMESPACE
#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 = 1;
const int ACCEPT_TRY_INTERVAL = 500;
const int ACCEPT_TRY_NUM = 110;

class CCardIssuerEntity;
void CCardIssuerFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 0;
	SetDevState(DEVICE_STATUS_NOT_READY);
	FSMEvent* e;
	e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
}

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

unsigned int CCardIssuerFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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_QUIT:
		break;
	case USER_EVT_TEST:
		break;
	default:
		break;
	}
	return 0;
}
//Initializing
void CCardIssuerFSM::s1_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 1;
}
void CCardIssuerFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s1_on_event(FSMEvent* event)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s1 evt (%d,%d)", event->iEvt, event->param1));

	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;
	SetDevState(DEVICE_STATUS_NORMAL);
	
	m_resetTimes = 0;
	m_testResult = Error_Succeed;
	m_bIssuingExit = false;
}

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

unsigned int CCardIssuerFSM::s2_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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:
	case EVT_MAINPAGE_DISPLAY:
	{
		m_captureReason = "4001";
		m_bExit = true;
		pEvt->SetHandled();
		if (!m_bDoExit) {
			SetDoExitFlag(true);
			DoExitWhenIdleTask* task = new DoExitWhenIdleTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		}
	}
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		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];
				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] = "";
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetMaterial CardBoxNo (%d):%s, PsbCode:%s, PsbName:%s, CardInit:%d, remains:%d, issued:%d, mixed:%d,",i,
				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;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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);
										 
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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();

				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetMaterial, need to SyncDataToDB.");
			if (pSMEE->ctx->Req.SetCaptured == 1)
				SyncDataToDB(bMaintain);
			else
				SyncDataToDB(bMaintain, false);
		}
	}
		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_JS_INSERT:
	{
		InsertJSEvent* ise = dynamic_cast<InsertJSEvent*>(pEvt);
		m_bCancelInsert = false;
		m_bExit = false;
		InsertJSTask* task = new InsertJSTask(this);
		task->ctx = ise->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_ISSUE_FROM_BOX:
	{
		IssueFromBoxJSTask* task = new IssueFromBoxJSTask(this);
		IssueFromBoxJSEvent* ife = dynamic_cast<IssueFromBoxJSEvent*>(pEvt);;
		task->ctx = ife->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		break;
	case USER_EVT_JS_CAPTURE:
	{
		CaptureJSEvent* cje = dynamic_cast<CaptureJSEvent*>(pEvt);
		CaptureJSTask* task = new CaptureJSTask(this);
		task->ctx = cje->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
	}
		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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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;
		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;
	case USER_EVT_JS_INSERT_FINISHED:
		{
			ret = pEvt->param1;
			if (ret == 1) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("插卡时查询设备状态故障");
				setQuickSelfCheck();
			}
			else if (ret == 4) {
				//吐卡
				EjectJSEvent* eje = dynamic_cast<EjectJSEvent*>(pEvt);
				EjectJSTask* task = new EjectJSTask(this);
				task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			}
			pEvt->SetHandled();
		}
		break;
	case USER_EVT_JS_INSERT_CANCEL:
		{
			m_bCancelInsert = true;
			pEvt->SetHandled();
			ret = 0;
		}
		break;
	case EVT_MAINPAGE_DISPLAY:
		{
			m_captureReason = "4001";
			m_bExit = true;
			pEvt->SetHandled();
			ret = 0;
		}
		break;
	default:
		break;
	}
	return ret;
}
//Hold
void CCardIssuerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 4;
}
void CCardIssuerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s4_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s4 evt (%d,%d)", pEvt->iEvt, pEvt->param1));

	switch(pEvt->iEvt){
		case USER_EVT_JS_READ:
			{
				ReadJSEvent* rje = dynamic_cast<ReadJSEvent*>(pEvt);
				ReadJSTask* task = new ReadJSTask(this);
				task->ctx = rje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_POSTONLINE:
			{
				PostOnlineJSEvent* poe = dynamic_cast<PostOnlineJSEvent*>(pEvt);
				PostOnlineJSTask* task = new PostOnlineJSTask(this);
				task->ctx = poe->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_EJECT:
			{
				EjectJSEvent* eje = dynamic_cast<EjectJSEvent*>(pEvt);
				EjectJSTask* task = new EjectJSTask(this);
				task->ctx = eje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_CAPTURE:
			{
				CaptureJSEvent* cje = dynamic_cast<CaptureJSEvent*>(pEvt);
				CaptureJSTask* task = new CaptureJSTask(this);
				task->ctx = cje->ctx;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				return 0;
			}
		case USER_EVT_JS_EXIT_MIAN_PAGE:
			{
				if (m_issueStatus) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S4 receive exception exit to main page, begin capture card");
					m_captureReason = "4001";
					CaptureJSTask* task = new CaptureJSTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 1;
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S4 receive exception exit to main page,begin eject card");
					EjectJSTask* task = new EjectJSTask(this);
					task->ctx = NULL;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
					pEvt->SetHandled();
					return 0;
				}
			}
		case USER_EVT_READ:
			{
				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)
				{
					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_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] = "";
				}
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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);
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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();

					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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_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_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;
		default:
			break;
	}
	return 0;
}
//Reading
void CCardIssuerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 5;
}
void CCardIssuerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s5_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s5 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_READ_FINISHED:
		{
			pEvt->SetHandled();
			CardReadFinishedEvent *pCRNFE = dynamic_cast<CardReadFinishedEvent *>(pEvt);
			if (pCRNFE->param1 == 0)
			{
				pCRNFE->ctx->Answer(Error_Succeed);
				ret = 0;
			}else if (pCRNFE->param1 == 2)
			{
				pCRNFE->ctx->Answer(Error_DevMedia);
				ret = 2;
			}
			else
			{
				//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Read finished,获取设备状态GetDevStatus失败");
				SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), 10, "QLR040220303", "Read finished,获取设备状态GetDevStatus失败");
				pCRNFE->ctx->Answer(Error_Unexpect, GetAlarmDEC());

				ret = 1;
			}
		}
		break;
	case USER_EVT_EXIT:
		{
			pEvt->SetHandled();
			m_captureReason = "4001";
		}
		break;
	case USER_EVT_QUIT:
		{
			pEvt->SetHandled();
			ret = 0;
		}
	default:
		break;
	}
	return ret;
}
//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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s6 evt (%d,%d)", pEvt->iEvt, pEvt->param1));

	if (pEvt->iEvt == USER_EVT_EJECTFINISHED){
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}else if (pEvt->iEvt == USER_EVT_QUIT) {
		pEvt->SetHandled();
		return 0;
	}
	else if (pEvt->iEvt == USER_EVT_JS_EJECT_FINISHED) {
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
			m_currCardNo = "";
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户取走卡片");
			return 0;
		}
		else if (pEvt->param1 == 1) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("取卡时设备故障");
			setQuickSelfCheck();
			return 1;
		}
	}
	return 0;
}
//Waiting fetch
void CCardIssuerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 7;
	WaitFetchingTask* task = new WaitFetchingTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
}
void CCardIssuerFSM::s7_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s7_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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, "CardIssuerStand op.");
			m_currCardNo = "";
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户取走卡片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);
			return 1;
		}
		else {
			FetchCard evt;
			evt.status = 2;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户未取卡超时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_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] = "";
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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);
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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();

				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s8 evt (%d,%d)", pEvt->iEvt, pEvt->param1));
	if (pEvt->iEvt == USER_EVT_CAPTUREFINISHED){
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
			return 0;
		else
			return 1;
	}
	else if (pEvt->iEvt == USER_EVT_JS_CAPTURE_FINISHED) {
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			return 0;
		}
		else {
			setQuickSelfCheck();
			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;
	SetDevState(DEVICE_STATUS_FAULT);
	if (m_quickSelfcheck) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand in fault state, need to quickSelfcheck.");
		m_testResult = Error_InvalidState;
		QuickSelfcheckTask* task = new QuickSelfcheckTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand in fault state, need to reset.");
		FSMEvent* e = new FSMEvent(USER_EVT_RESET);
		PostEventFIFO(e);
	}

}
void CCardIssuerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardIssuerFSM::s9_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s9 evt (%d,%d)", pEvt->iEvt, pEvt->param1));
	switch(pEvt->iEvt)
	{
	case USER_EVT_RESET:
		{
			pEvt->SetHandled();
			m_resetTimes++;
			if((m_csMachineType.Compare("RVC.Stand2S", true) == 0 || m_csMachineType.Compare("RVC.Stand1SPlus", true) == 0)
			   && m_resetTimes > MAX_RESET_TIMES_PERIOD)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
	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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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();
		break;
	case USER_EVT_PREONLINE:
	{
		pEvt->SetHandled();
		if (pEvt->iEvt == USER_EVT_PREONLINE)
		{
			PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA230Q")("卡库正在被其他机器跨机使用中");
			poe->ctx->Answer(Error_Duplication);
		}
	}
		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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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;
}

//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)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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;
}

void CCardIssuerFSM::s15_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 15;
	m_bReturnMainPage = false;
}

void CCardIssuerFSM::s15_on_exit()
{
	if (m_bReturnMainPage) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S15 exit, send exit main page event");
		this->PostEventFIFO(new FSMEvent(USER_EVT_JS_EXIT_MIAN_PAGE));
	}
	LOG_FUNCTION();
}

unsigned int CCardIssuerFSM::s15_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s15 evt (%d,%d)", pEvt->iEvt, pEvt->param1);
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_POSTONLINE_FINISHED:
	{
		pEvt->SetHandled();
		ret = 0;
	}
	break;
	case USER_EVT_JS_READ_FINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			ret = 0;
		}
		else if (pEvt->param1 == 1) {
			ret = 1;
		}
	}
	break;
	case EVT_MAINPAGE_DISPLAY:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S15 receive exit to main page");
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bReturnMainPage = true;
		ret = 0;
	}
	break;
	default:
		break;
	}
	return ret;
}

void CCardIssuerFSM::s16_on_entry()
{
	LOG_FUNCTION();
	m_currentFSMState = 16;
	m_bReturnMainPage = false;
}

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

unsigned int CCardIssuerFSM::s16_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("s16 evt (%d,%d)", pEvt->iEvt, pEvt->param1));
	int ret = 0;
	switch (pEvt->iEvt)
	{
	case USER_EVT_JS_ISSUE_FROM_BOX_FINISHED:
	{
		pEvt->SetHandled();
		ret = pEvt->param1;
		if (ret == 2) {
			setQuickSelfCheck();
		}
		else if (ret == 1) {
			if (m_bReturnMainPage) {
				
				CaptureJSEvent* cje = dynamic_cast<CaptureJSEvent*>(pEvt);
				CaptureJSTask* task = new CaptureJSTask(this);
				task->ctx = NULL;
				GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				pEvt->SetHandled();
				ret = 3;
			}
		}
	}
	break;
	case EVT_MAINPAGE_DISPLAY:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("S16 receive exit to main page");
		pEvt->SetHandled();
		m_captureReason = "4001";
		m_bReturnMainPage = true;
	}
	break;
	default:
		break;
	}
	return ret;
}

ErrorCodeEnum CCardIssuerFSM::OnInit()
{
	LOG_FUNCTION();
	AddStateHooker(this);
	m_pCardProcess = new CCardProcess();
	if (m_pCardProcess == NULL)//almost no use...
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CY")("create card process failed.");
		return Error_Resource;
	}
	CSystemStaticInfo sysInfo;
	//oilyang 20160331
	//so many function always return Error_Succeed,so is useless to process it.
	m_csMachineType = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_terminalNo = sysInfo.strTerminalID;
	m_majorVerion = sysInfo.MachineVersion.GetMajor();
	m_minorVerion = sysInfo.MachineVersion.GetMinor();

	m_devStatus.eMedia = CI_MEDIA_NOTPRESENT;
	m_bHasHopper[0] = false;
	m_bHasHopper[1] = false;
	m_bHasHopper[2] = false;
	return Error_Succeed;
}
ErrorCodeEnum CCardIssuerFSM::OnExit()
{
	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(bool bPrint)
{
	int getDevInfoCount = 0;
	static unsigned int lightStatus = 0;
	ErrorCodeEnum errCode;
	long l_beginTime, l_endTime;
	do{
		l_beginTime = GetTickCountRVC();
		errCode = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();
		
		//if (bPrint)
		//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus::GetDevStatus eMedia: %d,errCode:%d", m_devStatus.eMedia, errCode);
		if (Error_Succeed == errCode) 
		{
			if (bPrint) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("GetDevStatus::GetDevStatus eMedia: %d", m_devStatus.eMedia);
			}
			if (_strnicmp("RVC.CardPrinter", m_csMachineType, strlen("RVC.CardPrinter")) == 0)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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
		{
			if (bPrint) {
				SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			}			
			//DevErrorInfo devErrInfo;
			//m_hDevHelper->GetLastErr(devErrInfo);
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevStatus errMsg:%s", devErrInfo.szErrMsg);
			getDevInfoCount++;
			Sleep(300);
		}
	} while (getDevInfoCount < GET_DEV_STATUS_COUNT);
	return false;
}
int CCardIssuerFSM::Reset()
{
	LOG_FUNCTION();
	if (m_hDevHelper == nullptr)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Maybe the m_hDevHelper have been released,switch to s0 to restart.");
		return 2;
	}
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum ec = m_hDevHelper->Reset();
	l_endTime = GetTickCountRVC();
	if (ec == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Reset").setCostTime(l_endTime - l_beginTime)("Reset::Reset");
		if(GetDevStatus())
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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_Reset, "issue flag is 1, to capture card.");
					m_CardCaptured++;
					if (!SetCardCaptured(m_CardCaptured))
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("set card captured failed.");
				}
				else
				{
					//oiltmp to add 20131212
					eMoveErr = MachineMoveCardFrontGate();
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_EjectCard_ByTerminal, "issue flag is 0, to eject card.");
				}
				if (eMoveErr == Error_Succeed)
				{
					return 0;
				}
			}
			else if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT) {
				return 0;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("media position %d",m_devStatus.eMedia);
				return 1;
			}
		}
		else
		{
			return 1;
		}
	}
	else {
		SetErrorAndLog(ec, MEC_DEVAPI_CARDISSUER_Reset, "DevAdapter::Reset", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		return 1;
	}
	return 0;
}


bool CCardIssuerFSM::LoadCMBPrint(CSimpleStringA csBinPath)
{
	if (cmdDecodeEx == NULL) {
		CSimpleStringA csCMBPrint("");
#ifdef RVC_OS_LINUX
		csCMBPrint = "libCMBPrint.so";
		csCMBPrint = csBinPath + "/" + csCMBPrint;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("cmbpath %s", (const char*)csCMBPrint);
		void* hr = NULL;
		hr = dlopen(csCMBPrint, RTLD_LAZY);
		if (hr == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Load CMBPrint failed(%s).", dlerror());
			return false;
		}
		//pfunc_unpack = (PF_unpack)dlsym(hLib, "_Z6unpackPcS_i");
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)dlsym(hr, "CMBdecodeMag2")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)dlsym(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#else
		csCMBPrint = "CMBPrint.dll";
		csCMBPrint = csBinPath + SPLIT_SLASH_STR + csCMBPrint;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("cmbpath %s", (const char*)csCMBPrint);
		HMODULE hr = LoadLibraryA(csCMBPrint);
		if (hr == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Load CMBPrint failed(%d).", hr);
			return false;
		}
		if ((cmdDecodeMag2 = (lpCMBdecodeMag2)GetProcAddress(hr, "CMBdecodeMag2")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag2 address failed.");
			return false;
		}
		if ((cmdDecodeEx = (lpCMBdecodeEx)GetProcAddress(hr, "CMBdecodeEx")) == NULL)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23CX")("Get Mag23Ex address failed.");
			cmdDecodeMag2 = NULL;
			return false;
		}
#endif
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Load %s suc.", (const char*)csCMBPrint);
	}

	return true;
}
ErrorCodeEnum CCardIssuerFSM::OpenDevice(BYTE btOpenType, const char* pDevSN)
{
	LOG_FUNCTION();
	m_devOpenFailedCount++;
	ErrorCodeEnum eErrDev;
	CSimpleString errMsg(true);

	int initTries = 0;
	CSimpleStringA dllName;
	GetVendorDllName(dllName);

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

	CSimpleStringA csBinPath, csBackslash("\\");
	ErrorCodeEnum eErrPath = spEntityFunction->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("GetPath(bin) failed (%d) in OpenDevice.", eErrPath));
		return Error_Param;
	}
	//  [9/29/2019 14:13 @Gifur]
	CloseAndClearDevObj(false);
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();

	eErrDev = LoadUpAdapterLibrary(dllName);
	if (!IS_SUCCEED(eErrDev))
	{
		errMsg = CSimpleStringA::Format("Load vendor adapter failed.%d", GetLastError());
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_LoadLibraryA_Failed, errMsg.GetData());
		GetEntityBase()->GetFunction()->ShowFatalError("加载厂商适配器失败！请检查root.ini配置是否正确。");
		return Error_DevLoadFileFailed;
	}
	
	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;
	}
	long l_beginTime,l_endTime;
	do {
		l_beginTime = GetTickCountRVC();
		eErrDev = m_hDevHelper->DevOpenEx(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, pDevSN, m_connectType);
		l_endTime = GetTickCountRVC();
		
		if (eErrDev == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpenEx").setCostTime(l_endTime - l_beginTime)("OpenDevice::DevOpenEx succ, port:%d, baudRate:%d, openType:%d, connectType:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(),btOpenType, m_connectType);
			SetDevInitFlag(true);
			m_devOpenFailedCount = 0;
			ZeroMemory(m_devCat.szModel, sizeof(m_devCat.szModel));
			ZeroMemory(m_devCat.szType, sizeof(m_devCat.szType));
			ZeroMemory(m_devCat.szVendor, sizeof(m_devCat.szVendor));
			l_beginTime = GetTickCountRVC();
			eErrDev = m_hDevHelper->GetDevCategory(m_devCat);
			l_endTime = GetTickCountRVC();
			
			if (eErrDev == Error_Succeed)
			{
				int ret = SplitDevModelInfo();
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(l_endTime - l_beginTime)("OpenDevice::GetDevCategory SplitDevModelInfo=%d",ret);
				m_adapterInfo.FulfillCategoryInfo(m_devCat);
			}
			else
			{
				SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
				return Error_Unexpect;
			}

			if (!LoadCMBPrint(csBinPath))
			{
				errMsg = CSimpleStringA::Format("CardIssuerStand启动失败:Load CMBPrint failed.");
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_LoadLibraryA_CMBPrint_Failed, errMsg.GetData());
				return Error_DevLoadFileFailed;
			}
			initTries = 0;
			break;
		}
		else {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OpenDevice::DevOpenEx err, port:%d, baudRate:%d, openType:%d, connectType:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, m_connectType);
			errMsg = CSimpleStringA::Format("OpenDevice::DevOpenEx err, port:%d, baudRate:%d, openType:%d, connectType:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), btOpenType, m_connectType);
			SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_DevOpenEx, "DevAdapter::DevOpenEx", __FUNCTION__, false, l_endTime - l_beginTime, "", errMsg.GetData());
			
			//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStand启动失败:DevOpenEx failed.重试:%d", initTries);
			Sleep(200);
			initTries++;
		}
	} while (initTries < INIT_TRY_NUM);

	if (initTries != 0)
	{
		errMsg = CSimpleStringA::Format("CardIssuerStand启动失败，have tried %d times!!!", initTries);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_DevOpen_Failed, errMsg.GetData());
		return Error_DevCommFailed;
	}
	else
	{
		eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
		if (eErrDev != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("CardIssuerStand启动失败: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;
		}
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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);
			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]);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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 如果没有配置，使用原来的配置
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("use new hopper cfg record"));
		}
		//oilyang 回写卡机配置
		spConfig->WriteConfigValueInt("all", "IsIssue", isIssue);
		spConfig->WriteConfigValueInt("all", "HopperNum", m_hopperNum);
		spConfig->WriteConfigValueInt("1", "CardPercent", m_CardPercentEx[0]);
		spEntityFunction->OpenConfig(Config_CenterSetting, spConfigCS);

		int tmpCardnoMismatch = 0, tmpICRetryTimes = 1, tmpStopUseRF = 0;
		int tmpSelfcheckSleepTime = 0;

		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "EacQueryFlag", m_eacQueryFlag);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "UseCardnoMismatch", tmpCardnoMismatch);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "ICRetryTimes", tmpICRetryTimes);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "StopUseRF", tmpStopUseRF);
		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "RFVendorList", m_rfVendorList);
		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SwallowCardUrl", m_csSwallowCardUrl);
		spConfigCS->ReadConfigValue(GetEntityBase()->GetEntityName(), "SyncMaterialUrl", m_csSyncMaterialUrl);
		spConfigCS->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "SelfcheckSleepTime", tmpSelfcheckSleepTime);
		spConfigCS->ReadConfigValue("Common", "EacQueryHost", m_EacQueryHost);

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EacQueryFlag:%d,EacQueryHost:%s,UseCardnoMismatch:%d,ICRetryTimes:%d,SelfcheckSleepTime:%d,StopUseRF:%d"
			, m_eacQueryFlag, m_EacQueryHost.GetData(), tmpCardnoMismatch, tmpICRetryTimes, tmpSelfcheckSleepTime, tmpStopUseRF);

		if (tmpCardnoMismatch == 1)
			m_bUseCardnoMismatch = true;
		if (tmpICRetryTimes > 0 && tmpICRetryTimes < 4)
			m_ICRetryTimes = tmpICRetryTimes;
		if (tmpStopUseRF == 1)
			m_bStopUseRF = true;
		m_issueStatusFromFile = m_issueStatus = isIssue;
		if (m_issueStatusFromFile == 0)
			m_bCardFromHopper = false;
		if (tmpSelfcheckSleepTime == 0) {
			m_SelfcheckSleepTime = 10000;//默认10s
		}

		ret = UnAcceptCard();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
			}
			//oilyang@20191219 获取吞卡箱容量，目前有便携卡机，大机
			//超过5，认为是脏数据，用默认值3
			CardIssuerStatus cis;
			l_beginTime = GetTickCountRVC();
			eErrDev = m_hDevHelper->GetDevStatus(cis);
			l_endTime = GetTickCountRVC();

			if (eErrDev != Error_Succeed) {
				SetErrorAndLog(eErrDev, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("OpenDevice::GetDevStatus 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, "(sensor)retain bin is full!回收箱满了，请及时清理！");
				}
			}
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Open_Success, "读卡器打开成功");
			return Error_Succeed;
		}
		else
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Open_Failed, "启动后检查卡机状态失败");
			return Error_Unexpect;
		}
	}
}

int CCardIssuerFSM::Initial()
{
	m_bOpening = true;
	ErrorCodeEnum errCode = OpenDevice(DEV_OPEN_TYPE_COM,"");
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OpenDevice in Initial return failed with errCode:%d(0x%x)", errCode, errCode);
		CloseAndClearDevObj(false);
		SetDevInitFlag(false);
	}
	m_bOpening = false;
	return errCode;
}

int CCardIssuerFSM::UnAcceptCard()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	if (GetDevStatus())
	{
		switch (m_devStatus.eMedia)
		{
		case 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);
			}

			if (m_currCardNo.GetLength() > 1)
				m_captureReason = "4014";
			else
				m_captureReason = "0000";
			//oilyang@20230313 根据卡片异常处理沟通会议（业务、深圳开发），实体启动发现有卡，一律吞卡
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z01").setResultCode("RTA23A1")("读卡器打开时，卡机有卡片，吞卡");
			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_CaptureCard_EntityOnStart, errMsg.GetData());
			return CaptureCard(NULL);
		}
		case CI_MEDIA_JAMMED:
		case CI_MEDIA_ENTERING:
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CardPosUnexpectedOnDevOpen, CSimpleStringA::Format("Unexpected CardStatusEnum:%d", m_devStatus.eMedia));
			break;
		case CI_MEDIA_NOTPRESENT:
			return 0;
		default:
			break;
		}
	}
	else
	{
		//DevErrorInfo devErrorInfo;
		//m_hDevHelper->GetLastErr(devErrorInfo);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("UnAcceptCard, GetDevStatus failed ");
	}
	return 1;
}
int CCardIssuerFSM::IssueCard(SpReqAnsContext<CardIssuerStandService_Issue_Req, CardIssuerStandService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerStandService_IssueEx_Req, CardIssuerStandService_IssueEx_Ans>::Pointer ctxEx)
{
	LOG_FUNCTION();

	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	if (ctxEx != NULL)
	{
		//Req.hopper
		//89:从加卡箱移卡读卡
		//88:卡片加到卡槽
		//87:吞卡
		//99:移卡读卡
		//98:手工取卡
		//100:清空卡库、卡库盘库吞到吞卡箱
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("IssueCard, issue type:%d", ctxEx->Req.hopper));
		ctxEx->Ans.reserved1.Init(2);
		
		//oiltmp 卡库独有吗？
		if (ctxEx->Req.hopper == 87)//签发失败，吞卡
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_SignFailed, "sign failed, to capture card.");
			ToRegistCaptureCardInfo();
			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;
		}

		if (!m_bHasHopper[ctxEx->Req.hopper - 1])
		{
			switch (ctxEx->Req.hopper)
			{
			case 1:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper1);
				break;
			case 2:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				ctxEx->Answer(Error_DevMedia, CardIssuer_UserErrorCode_NotHas_Hopper2);
				break;
			case 3:
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱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;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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]))
			SetDevState(DEVICE_STATUS_MAINTAINCE);

		errMsg = CSimpleStringA::Format("the current card hopper %d may be wrong.mixedEx:%d",
			m_currentHopper, m_mixedEx[m_currentHopper-1]);
		DWORD dwTmpErrCode = CardIssuer_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (m_currentHopper == 2)
		{
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper2_Mixed_Too_Much;
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230S")("卡箱2连续吞卡超限，请及时执行清机");
		}
		else if (m_currentHopper == 3)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230T")("卡箱3连续吞卡超限，请及时执行清机");
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper3_Mixed_Too_Much;
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230R")("卡箱1连续吞卡超限，请及时执行清机");

		LogWarn(Severity_Middle, Error_Unexpect, dwTmpErrCode, errMsg.GetData());
		if (ctx != NULL)
			ctx->Answer(Error_DevMedia, dwTmpErrCode);
		else
			ctxEx->Answer(Error_DevMedia, dwTmpErrCode);
		return 2;
	}
	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	memset(&cis, 0, sizeof(CardIssuerStatus));
	bool bEmpty = false;

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();
	

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("IssueCard::GetDevStatus");
		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]);
		//LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_No_More_Card_Issue, warnInfo.GetData());
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(warnInfo.GetData());

		DWORD dwUsrErrCode = 0;
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP)
		{
			if (m_currentHopper == 1)//oiltmp MACRO?
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱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)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230G")("卡箱3未检测到卡片，请检测卡箱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)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230H")("卡箱1本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230J")("卡箱2本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220320").setResultCode("RTA230K")("卡箱3本地计数无卡，请执行清机计划");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardRemains_Hopper3;
			}
		}
		if (ctx != NULL)
			ctx->Answer(Error_DevNotAvailable, dwUsrErrCode);
		else
			ctxEx->Answer(Error_DevNotAvailable, dwUsrErrCode);

		return 2;
	}
	//forbid front enter
	
	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("IssueCard::SetCardInType");
	}

	FSMSetIssueFlag(1);
	//move card to holder

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, m_currentHopper);
	l_endTime = GetTickCountRVC();

	
	m_bCardFromHopper = true;
	if (errCode != Error_Succeed)
	{
		
		CSimpleStringA ErrMsg = CSimpleStringA::Format("IssueCard::MoveCard err , m_currentHopper:%d", m_currentHopper);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(ErrMsg.GetData());
		FSMSetIssueFlag(2);
		
		if (ctx != NULL) {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("从卡箱移动卡片到读卡器失败，请重试或检查是否有塞卡");
			SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", ErrMsg.GetData());
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}
		else {
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("从卡箱移动卡片到读卡器失败，请重试或检查是否有塞卡");
			SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", ErrMsg.GetData());
			ctxEx->Answer(Error_Unexpect, GetAlarmDEC());
		}
		return 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320")("IssueCard::MoveCard succ, m_currentHopper:%d", m_currentHopper);
	}
	//LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper suc.");
	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_Middle, Error_Unexpect, CardIssuer_UserErrorCode_FEW_CARD_REMAINS, "Few card remains.");
	}
	m_bSettingMaterial = true;//oilyang 借用于延迟同步，紧接着设置remains时更新到后台数据库
	if (!SetCardIssued(m_issuedEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, Set card issued failed.");
	m_bSettingMaterial = false;
	if (!SetCardRemains(m_remainsEx[m_currentHopper - 1], m_currentHopper))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, Set card remains failed.");
	m_bUseRFTillNext = false;
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220320")("IssueCard success.");
	Sleep(1000);
	ctxEx->Ans.reserved1[0] = ctxEx->Ans.reserved1[1] = 0;
	//oilyang@20170929 根据讨论结果，去掉调用

	if (m_bIssuingExit)
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_IssueExit, "Issuing exit, to capture card.");
		CaptureCard(NULL);
	}
	if (ctx != NULL)
		ctx->Answer(Error_Succeed);
	else
		ctxEx->Answer(Error_Succeed);
	return 0;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::CaptureCard(SpReqAnsContext<CardIssuerStandService_Capture_Req,CardIssuerStandService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (ctx != NULL)
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_FromBusiness, "CaptureCard called from Business.");
	ErrorCodeEnum eErr;
	long l_beginTime, l_endTime;
	int ret = 0;

	eErr = MachineMoveCardBackNotHold();
	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220304")();
		bool bCaptured = ToRegistCaptureCardInfo();
		m_currCardNo = m_addCardNo = "";
	}
	else
		ret = 1;
	m_CardCaptured++;
	if (!SetCardCaptured(m_CardCaptured))
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CaptureCard>, set card captured failed");
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();


		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("CaptureCard::SetCardInType");
		}
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
	}
	else {
		if (ctx != NULL){
			if (IsInBusiness()) {
				LogError(Severity_Middle, Error_Unexpect, 0x20300034, "CaptureCard failed");
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040220304").setResultCode("RTA2307")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
			}
			else {
				LogWarn(Severity_Middle, Error_Unexpect, 0x20300034, "CaptureCard failed");
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setLogCode("QLR040220304").setResultCode("RTA2307")("吞卡失败，请检查吞卡箱是否已满或联系厂商检查是否有吞卡");
			}
			ctx->Answer(Error_Unexpect, 0x20300034);
		}
	}
	if (ret == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setLogCode("QLR040220304")("Captured succ");
	}
	return ret;
}

/** 0:succeed,1:failed [Gifur@2022516]*/
int CCardIssuerFSM::EjectCard(SpReqAnsContext<CardIssuerStandService_Eject_Req,CardIssuerStandService_Eject_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Sleep(300);//oilyang@20230106 for keba said "maybe we need stay for machine to prepare..."
	int ret = 0;
	ErrorCodeEnum eErr;
	eErr = MachineMoveCardFrontGate(ctx != NULL && IsInBusiness());
	m_pCardProcess->DataInit();
	if (Error_Succeed == eErr){
		if (ctx != NULL)
			ctx->Answer(Error_Succeed);
		ret = 0;
	}
	else {
		if (ctx != NULL){
			ctx->Answer(Error_Exception, 0x20300035);
		}
		ret = 1;
	}
	if (ret == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setLogCode("QLR040220305")("EjectCard succ");
	}
	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");
	long l_beginTime, l_endTime;
	do {
		l_beginTime = GetTickCountRVC();
		if (GetDevStatus(false)){
			dwEnd = GetTickCountRVC();
			if (m_devStatus.eMedia == CI_MEDIA_ENTERING){
				Sleep(WAIT_INTERVAL);
			}
			else{
				
				l_beginTime = GetTickCountRVC();
				ErrorCodeEnum eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
				l_endTime = GetTickCountRVC();

				if (eErr != Error_Succeed) {			
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("WaitFetchingCard::SetCardInType");
				}
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
				return 0;
			}
		}else
		{
			l_endTime = GetTickCountRVC();
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader(fetch) warning off");
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220305", "取卡时设备故障");
			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;
	long l_beginTime, l_endTime;
	m_bWaitingAccept = true;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("InternalAcceptCard, m_bExit:%d, m_bCancelAccept:%d, m_bWaitAccepteMore:%d, m_bCancelByRFIC:%d",
		m_bExit, m_bCancelAccept, m_bWaitAccepteMore, m_bCancelByRFIC));
	bool bHasSetCardInType = false;
	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(false))
		{
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
				acceptTries = 0;
				goto Err;
			}
			if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				acceptTries++;
				Sleep(ACCEPT_TRY_INTERVAL);
				//oilyang@20230609 after sleep,to check if have been canceled in sleeping time
				if (m_bCancelAccept)
				{
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("have been canceled in sleeping time");
					err = 3;
					goto Err;
				}
				//hr = m_pIDCard->IDC_Accept(IDC_ALL_CARD,&lpCardData);
				if (!m_bCancelAccept && !bHasSetCardInType) {
					l_beginTime = GetTickCountRVC();
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
					l_endTime = GetTickCountRVC();
					//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_ALL");

				}
				if (Error_Succeed != eErr) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_ALL err");
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_ALL err");

				}
				else {
					bHasSetCardInType = true;
				}
			}
		}
		else
		{
			err = 1;
			goto Err;
		}
		dwEnd = GetTickCountRVC();
	} while ((dwEnd - dwStart) < 58 * 1000);
	err = 2;
Err:
	m_bExit = false;
	m_bWaitingAccept = false;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();	


	if (Error_Succeed != eErr)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN");
	}
	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;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<InternalAcceptCard>, Cancel InterAccept, eject card.");
				eErr = MachineMoveCardFrontGate(IsInBusiness());

				if (Error_Succeed == eErr) {
					l_beginTime = GetTickCountRVC();
					eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
					l_endTime = GetTickCountRVC();	

					if (eErr != Error_Succeed) {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
						SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalAcceptCard::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");

					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalAcceptCard::SetCardInType CI_MEDIA_PRESENT CI_CARD_IN_TYPE_FORBIDDEN");
					}
				}
				else
				{
					//吐卡失败，前面已有告警，这里不再告警
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalAcceptCard::MachineMoveCardFrontGate failed(0x%x)", eErr);
					err = 2;
				}
			}
		}
		else
			err = 2;
	}
	return err;
}
int CCardIssuerFSM::AcceptCard(SpReqAnsContext<CardIssuerStandService_Insert_Req, CardIssuerStandService_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();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("AcceptCard::InternalAcceptCard, result:%d", rc));
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF,"CardReader warning off");
	if (rc == 0) {
		FSMSetIssueFlag(0);
		m_bCardFromHopper = false;
		if (ctx != NULL)
		{
			//LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_InsertCardSucceed, "AcceptCard, insert succeed");
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("AcceptCard, insert succeed");
			m_bUseRFTillNext = false;
			ctx->Answer(Error_Succeed);
		}
	}
	else if(rc == 2)
	{
		if (ctx != NULL) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert timeout");
			ctx->Answer(Error_TimeOut);
		}
	}
	else if(rc == 3 || rc == 4)
	{
		if (ctx != NULL)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AcceptCard, insert cancel");
			ctx->Answer(Error_Cancel);
		}
	}else 
	{
		if (ctx != NULL){
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, IsInBusiness(), 10, "QLR040220303", "");
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}
	}
	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);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len:%d", dataLen);

	if (pTrack2.GetLength() == 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E2")("<SplitTrack2>, pTrack2.len=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:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len=38 Not implemented ");
		break;
	default:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SplitTrack2>, pTrack2.len=%d Not implemented ", dataLen);
		return -1;
	}
	decodeData.status = 0;
	return 0;
}

int CCardIssuerFSM::ReadCard(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
{
	bool bCtOK = false;
	memset(m_magTracks.track[0].data, 0, sizeof(m_magTracks.track[0].data));
	memset(m_magTracks.track[1].data, 0, sizeof(m_magTracks.track[1].data));
	memset(m_magTracks.track[2].data, 0, sizeof(m_magTracks.track[2].data));
	int ret = ReadCard_Contact(ctx, bCtOK);
	if (ret == 2 || bCtOK)
		return ret;
	if (IfUseRf())
	{
		m_bUseRFTillNext = true;
		return ReadCard_RF(ctx);
	}
	else
		return ret;
}
int CCardIssuerFSM::ReadCard_Contact(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx, bool& bICOK)
{
	bICOK = false;
	m_currCardNo = "";

	ctx->Ans.ICType = 0;
	ErrorCodeEnum eErr, eMagReadErr;
	int activeCardType;
	bool bIC(false), bICSuc(false), bReadCardInfo(false);
	long l_beginTime, l_endTime;
	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());
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());
	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 {
		l_beginTime = GetTickCountRVC();
		eMagReadErr = m_hDevHelper->MagRead(magTracks);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed == eMagReadErr) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::MagRead t2Status:%d, t3Status:%d, t2Len:%d, t3Len:%d",
				magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[1].dwSize, magTracks.track[2].dwSize);
		}
		else {
			SetErrorAndLog(eMagReadErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::MagRead err");

		}

		//oilyang@20230204 copy mag data for RF
		m_magTracks.eRange = magTracks.eRange;
		for (int i = 0; i < 3; ++i)
		{
			m_magTracks.track[i].eStatus = magTracks.track[i].eStatus;
			m_magTracks.track[i].eSource = magTracks.track[i].eSource;
			m_magTracks.track[i].dwSize = magTracks.track[i].dwSize;
			memcpy(m_magTracks.track[i].data, magTracks.track[i].data, sizeof(magTracks.track[i].data));
		}

		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 == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand 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)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e || magTracks.track[1].data[i] == 0x44)// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleString::Format("<ReadCard::MagRead>, split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split track is err, pos:%d", pos);
				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;
				bReadCardInfo = true;
				if (m_issueStatus)
				{
					//设置为mixed从读卡失败恢复为成功时才触发同步计数和写运行时
					if (m_mixedEx[m_currentHopper - 1]!= 0) {
						m_mixedEx[m_currentHopper - 1] = 0;
						SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					}
					else {
						SetDevState(DEVICE_STATUS_NORMAL);
					}
				}
			}
			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;
			}

			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 , len:%d", (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4), ctx->Ans.t2Account.GetLength());
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

			break;
		}
	} while (readTries < READ_TRY_NUM);

	m_currCardNo = ctx->Ans.t2Account;
	//oilyang@20230331
	//1、发卡且读磁成功，不再继续检测IC，一律ICType=1，以便读取IC
	//2、其他情况（发卡未读到磁条或前端插卡），先查询户口系统进行卡片介质判定：
	//	2a：户口系统返回非纯磁条介质类型，ICType以户口为准（ICType影响后续IC读取，即：都会读IC）
	//	2b：其他情况（户口系统访问错（未走户口系统查或访问微服务失败或未返回介质类型或返回纯磁条卡），一律探测是否芯片卡

	if (m_issueStatus && (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK))//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		ctx->Ans.ICType = 1;
		bICOK = true;
	}
	else
	{
		int cardTypeFromHost = 0;
		bool bMismatch = false;
		if (m_eacQueryFlag == 1)
			cardTypeFromHost = JudgeCardType(m_currCardNo, bMismatch);
		if (cardTypeFromHost > 0 && cardTypeFromHost != 2)//户口系统返回非纯磁条介质类型
		{
			ctx->Ans.ICType = cardTypeFromHost;
			if (m_bUseCardnoMismatch && bMismatch)
			{
				bICOK = true;
				return 2;
			}
		}
		else//未访问户口系统或户口系统访问失败或户口未告知介质类型（包括插反卡）
		{
			int icRetryTimes = 0;
			while (1)
			{//for poor mag only card,we always retry...
				l_beginTime = GetTickCountRVC();
				bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
				l_endTime = GetTickCountRVC();
				if (!bIC)
					icRetryTimes++;
				else
					break;
				Sleep(500);
				if (icRetryTimes >= m_ICRetryTimes)
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<ReadCard::DetectIfICCard>, bIC:%d", bIC);
			if (!bIC) {
				ErrorCodeEnum eErrCode = Error_Unexpect;
				CSimpleStringA ApiName = "";
				CSimpleStringA alarmMsg = "";
				CSimpleStringA csErrMsgWithReturnCode = "";
				GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setResultCode("RTA23CT")(csErrMsgWithReturnCode.GetData());
				LogWarn(Severity_Middle, Error_Unexpect, 0x2030000a, alarmMsg.GetData());
			}
			if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
			{
				if (bIC)
					ctx->Ans.ICType = 1;
				else
				{
					ctx->Ans.ICType = 2;
				}
			}
			else
			{
				if (bIC)
				{
					bReadCardInfo = true;
					ctx->Ans.ICType = 3;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MaybeIC_Only, "<ReadCard>, maybe ic only.");
				}
				else
				{
					//既没有读到磁条，又不是IC，很大概率是插反了
					if (m_issueStatus) {
						LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<ReadCard>, 既没读到磁条，又没检测到IC，可能插反了，m_issueStatus=1");
					}
					else {
						LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<ReadCard>, 既没读到磁条，又没检测到IC，可能插反了，m_issueStatus=0");
					}
					if (m_issueStatus)
					{
						m_mixedEx[m_currentHopper - 1]++;
						SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					}
				}
			}
			if (bIC)
			{
				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->DeactivateICCard();
				l_endTime = GetTickCountRVC();
				
				if (eErr != Error_Succeed) {
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::DeactivateICCard err");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::DeactivateICCard");
				}

				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->ReleaseIC();
				l_endTime = GetTickCountRVC();

				if (eErr != Error_Succeed) {
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_Contact::ReleaseIC err");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("ReadCard_Contact::ReleaseIC");
				}
			}
		}
	}
	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ctx->Ans.ICType);
	//LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardType, cardType.GetData());

	DWORD dwEnd = GetTickCountRVC();
	DWORD dwCollapse = dwEnd - dwStart;

	if (!bReadCardInfo)
	{
		bICOK = false;
		ctx->Ans.status = 1;
		if (GetDevStatus())
			return 0;
		else
			return 1;
	}
	bICOK = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc. cardType:%d. m_issueStatus:%d", ctx->Ans.ICType, m_issueStatus);
	return 0;
}
int CCardIssuerFSM::ReadCard_RF(SpReqAnsContext<CardIssuerStandService_Read_Req, CardIssuerStandService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr, eMagReadErr;

	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	l_endTime = GetTickCountRVC();

	if (eErr != Error_Succeed)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_RF::MoveCard err");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::MoveCard");
	}

	ctx->Ans.ICType = 0;
	
	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());
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());
	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 {
		//oiltmp tricks...copy mag data
		//need to remove ,just for simple or lazy...

		eMagReadErr = Error_Succeed;
		magTracks.eRange = m_magTracks.eRange;
		for (int i = 0; i < 3; ++i)
		{
			magTracks.track[i].eStatus = m_magTracks.track[i].eStatus;
			magTracks.track[i].eSource = m_magTracks.track[i].eSource;
			magTracks.track[i].dwSize = m_magTracks.track[i].dwSize;
			memcpy(magTracks.track[i].data, m_magTracks.track[i].data, sizeof(m_magTracks.track[i].data));
		}


		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 == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand 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)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e || magTracks.track[1].data[i] == 0x44)// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleString::Format("<ReadCard::MagRead>, split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadCard::MagRead>, split track is err, pos:%d", pos);
				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;
				bReadCardInfo = true;
				if (m_issueStatus)
				{
					//设置为mixed从读卡失败恢复为0时才触发同步计数和写运行时
					if (m_mixedEx[m_currentHopper - 1] != 0) {
						m_mixedEx[m_currentHopper - 1] = 0;
						SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					}
					else {
						SetDevState(DEVICE_STATUS_NORMAL);
					}
				}
			}
			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;
			}

			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 , len:%d", (LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(ctx->Ans.t2Account.GetLength() - 4, 4), ctx->Ans.t2Account.GetLength());
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

			break;
		}
	} while (readTries < READ_TRY_NUM);
	m_currCardNo = ctx->Ans.t2Account;
	if (m_issueStatus && (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK))//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		ctx->Ans.ICType = 1;
	}
	else
	{
		int cardTypeFromHost = 0;
		bool bMismatch = false;
		if (m_eacQueryFlag == 1)
			cardTypeFromHost = JudgeCardType(m_currCardNo, bMismatch);
		if (cardTypeFromHost > 0)//户口系统有返回卡片类型
		{
			ctx->Ans.ICType = cardTypeFromHost;
			if (m_bUseCardnoMismatch && bMismatch)
				return 2;
		}
		else//未访问户口系统或户口系统访问失败（包括插反卡）
		{
			int icRetryTimes = 0;
			while (1)
			{//for poor mag only card,we always retry...
				l_beginTime = GetTickCountRVC();
				bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_RF, m_hDevHelper, activeCardType);
				l_endTime = GetTickCountRVC();
				if (!bIC)
					icRetryTimes++;
				else
					break;
				Sleep(500);
				if (icRetryTimes >= m_ICRetryTimes)
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<ReadCard::DetectIfICCard>, bIC:%d", bIC);
			if (!bIC) {
				ErrorCodeEnum eErrCode = Error_Unexpect;
				CSimpleStringA ApiName = "";
				CSimpleStringA alarmMsg = "";
				CSimpleStringA csErrMsgWithReturnCode = "";
				GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setResultCode("RTA23C6")(csErrMsgWithReturnCode.GetData());
				LogWarn(Severity_Middle, Error_Unexpect, 0x20300017, alarmMsg.GetData());
			}
			if (!(bIC && activeCardType == 'A'))
				bIC = false;
			if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
			{
				if (bIC)
					ctx->Ans.ICType = 1;
				else
				{
					ctx->Ans.ICType = 2;
				}
			}
			else
			{
				if (bIC)
				{
					bReadCardInfo = true;
					ctx->Ans.ICType = 3;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MaybeIC_Only, "<ReadCard>, maybe ic only.");
				}
				else
				{

				}
			}
			if (bIC)
			{
				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->DeactContactlessICCard();
				l_endTime = GetTickCountRVC();
				
				if (eErr != Error_Succeed) {
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadCard_RF::DeactContactlessICCard err");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::DeactContactlessICCard");
				}
			}
		}
	}
	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ctx->Ans.ICType);
	//LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardType, cardType.GetData());

	DWORD dwEnd = GetTickCountRVC();
	DWORD dwCollapse = dwEnd - dwStart;

	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
		if (GetDevStatus())
			return 0;
		else
			return 1;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220303")("ReadCard suc. cardType:%d. m_issueStatus:%d", ctx->Ans.ICType, m_issueStatus);
	return 0;
}
int CCardIssuerFSM::PreOnline(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PreOnline_RF(ctx);

	bool bCtOK = false;
	int ret = PreOnline_Contact(ctx, bCtOK);
	if (!bCtOK && IfUseRf())
		return PreOnline_RF(ctx);
	else
		return ret;
}
int CCardIssuerFSM::PreOnline_Contact(SpReqAnsContext<CardIssuerStandService_PreOnline_Req,CardIssuerStandService_PreOnline_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	//oilyang@20220611 only return 0；if unexpected,process and return 0
	bool bCrossPreOnline = false;
	long l_beginTime, l_endTime;

	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData,ctx->Req.businessData.GetLength());
	
	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)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline>, the front BusinessData han't provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, the aid from bussiness is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		CSimpleStringA xCardName("");
		if (m_issueStatus && m_currentHopper - 1 >= 0)
			xCardName = m_PsbNameEx[m_currentHopper - 1];
		if (retDetectAndRead == -1)
		{
			ErrorCodeEnum eErrCode = Error_Unexpect;
			CSimpleStringA ApiName = "";
			CSimpleStringA alarmMsg = "";
			CSimpleStringA csErrMsgWithReturnCode = "";
			GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("检测卡片类型时上电失败");
			if (!IfUseRf())
			{
				if (IsInBusiness())
				{
					if (m_issueStatus)
					{
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
						LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed, alarmMsg.GetData());
						ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed);
					}
					else
					{
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
						LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed, alarmMsg.GetData());
						ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed);
					}
				}
				else
				{
					if (m_issueStatus)
					{
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed, alarmMsg.GetData());
						ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed);
					}
					else
					{
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed, alarmMsg.GetData());
						ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed);
					}
				}
				
			}
			else //非终态，还有非接兜底
			{
				if (m_issueStatus)
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
				else
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
			}
		}
		else if (retDetectAndRead == -2){
			if (!IfUseRf())
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "");
				}
				ctx->Answer(Error_Unexpect, GetAlarmDEC());
			}
			else //非终态，还有非接兜底
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220320", "");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220303", "");
				}
			}
		}else if (retDetectAndRead == -3){
			if (!IfUseRf())
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "");
				}
				ctx->Answer(Error_Unexpect, GetAlarmDEC());
				
			}
			else //非终态，还有非接兜底
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220320", "");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220303", "");
				}
			}
		}
		bICOK = false;
		return 0;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER,m_hDevHelper,taaResult,true,m_bCDA,bt9f27);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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;

	if (ctx->Ans.result.GetLength() == 0)
	{
		if (!IfUseRf())
			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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, can't find expire date");
		if (!IfUseRf())
			ctx->Answer(Error_Succeed);
		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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value,&pICCardSerial,ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC,track2,false,0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline>, [ic]no track2 data");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();
		if (eErr != Error_Succeed){
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("PreOnline::ReleaseIC");
		}
	}
	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';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<PreOnline>, ic.track2, split 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;
			if (m_issueStatus)
			{
				//设置为mixed从读卡失败恢复为0时才触发同步计数和写运行时
				if (m_mixedEx[m_currentHopper - 1] != 0) {
					m_mixedEx[m_currentHopper - 1] = 0;
					bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline>, set %d card mixed %d,%d", m_currentHopper, bSetMix, m_mixedEx[m_currentHopper - 1]);
				}
				else {
					SetDevState(DEVICE_STATUS_NORMAL);
				}
			}
		}
		if (_strnicmp(track2Data.t2Account,ddd,strlen(ddd)))
		{
			t2ICCVC = "";
			t2ICTrack2 = pICTrack2;
			t2ICAccount = (char*)ddd;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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) {
		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();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<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;
	}
	bICOK = true;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PreOnline_RF(SpReqAnsContext<CardIssuerStandService_PreOnline_Req, CardIssuerStandService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("(PreOnline) use cardissuerStand rf");
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	l_endTime = GetTickCountRVC();
	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("PreOnline_RF::MoveCard, (CI_MOVECARD_RF_POSITION)");
	}
	else {
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	bool bCrossPreOnline = false;

	CSimpleStringA csMagT2Track(""), csMagT3Track(""), csMagAccout(""), csMagRegion(""), csMagCardSerial(""), csMagCVC(""), csMagExpireDate("");
	int slot = 0;
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());

	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)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, the front BusinessData han't provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline_RF>, the aid from bussiness is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);
	if (retDetectAndRead < 0)
	{
		CSimpleStringA xCardName("");
		if (m_issueStatus && m_currentHopper - 1 >= 0)
			xCardName = m_PsbNameEx[m_currentHopper - 1];
		if (retDetectAndRead == -1) {
			ErrorCodeEnum eErrCode = Error_Unexpect;
			CSimpleStringA ApiName = "";
			CSimpleStringA alarmMsg = "";
			CSimpleStringA csErrMsgWithReturnCode = "";
			GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("检测卡片类型时上电失败（非接）");

			if (m_issueStatus)
			{
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA2327")(csErrMsgWithReturnCode.GetData());
					LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed, alarmMsg.GetData());
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA2327")(csErrMsgWithReturnCode.GetData());
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed, alarmMsg.GetData());
				}
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed);
			}
			else
			{
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA2326")(csErrMsgWithReturnCode.GetData());
					LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed, alarmMsg.GetData());
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA2326")(csErrMsgWithReturnCode.GetData());
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed, alarmMsg.GetData());
				}
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed);
			}
		}
		else if (retDetectAndRead == -2) {

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
			if (m_issueStatus) {
				SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "");
			}
			else {
				SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "");
			}
			ctx->Answer(Error_Unexpect, GetAlarmDEC());

		}
		else if (retDetectAndRead == -3) {

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
			if (m_issueStatus) {
				SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "");
			}
			else {
				SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "");
			}
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
		}
		return 0;
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_RF, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	if (retTAA != 0 || taaResult.GetLength() == 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnline_RF>, 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;

	if (ctx->Ans.result.GetLength() == 0)
	{
		ctx->Answer(Error_Succeed);
		return 0;
	}

	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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, can't find expire date");
		ctx->Answer(Error_Succeed);
		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);
	
	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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnline_RF>, [ic]no track2 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';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<PreOnline_RF>, ic.track2, split 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;
			//oilyang@20230116 if we read by RF,we can't reset card mixed
			//if (m_issueStatus)
			//{
			//	m_mixedEx[m_currentHopper - 1] = 0;
			//	bool bSetMix = SetCardMixed(m_mixedEx[m_currentHopper - 1], m_currentHopper);
			//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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) {
		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();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnline_RF>, 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;
	}
	LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_ReadByRF, CSimpleStringA::Format("PreOnline_RF ok.iIssue:%d ", m_issueStatus));
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext)
		return PostOnline_RF(ctx);

	bool bCtOK = false;
	int ret = PostOnline_Contact(ctx, bCtOK);
	if (!bCtOK && IfUseRf())
		return PostOnline_RF(ctx);
	else
		return ret;
}
int CCardIssuerFSM::PostOnline_Contact(SpReqAnsContext<CardIssuerStandService_PostOnline_Req,CardIssuerStandService_PostOnline_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220307")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::PostOnline_RF(SpReqAnsContext<CardIssuerStandService_PostOnline_Req, CardIssuerStandService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_RF, 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;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnline>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220307")();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardIssuerFSM::WriteCard(SpReqAnsContext<CardIssuerStandService_WriteTrack_Req, CardIssuerStandService_WriteTrack_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	int ret = 0;
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<WriteCard>, write card param is null.");
		ctx->Answer(Error_Param);
		return ret;
	}
	else
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_MAG_POSITION);
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("从卡箱移动卡片到磁条写卡位置失败");
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_MAG_POSITION, "DevAdapter::MoveCard", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220315", "");
			ctx->Answer(Error_Unexpect, GetAlarmDEC());
			return ret;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("WriteCard::MoveCard");
		}
	}
	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);
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MagWrite(magTrack, AUTO_CO);
	l_endTime = GetTickCountRVC();
	
	if (eErr != Error_Succeed)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MagWrite, "DevAdapter::MagWrite", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		ret = 1;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagWrite").setCostTime(l_endTime - l_beginTime)("WriteCard::MagWrite");
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220315")("MagWrite ok");
	ctx->Ans.result = ret;
	ctx->Answer(Error_Succeed);
	return ret;
}
void CCardIssuerFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}

bool CCardIssuerFSM::FSMSetIssueFlag(int value)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("FSMSetIssueFlag, value:%d,from file:%d", value, m_issueStatusFromFile);
	if (value == 0 && m_issueStatusFromFile >1)
	{
		//oilyang@20171220 如果曾经卡片卡住，但启动时没有发现卡片，则更新本次发卡方向但不写文件，以防后续卡片被移动到卡槽
		if (!m_hasCardWhileDevOpen)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("card jamed havn't been process.");
			m_issueStatus = 0;
		}
		else
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("(FSMSetIssueFlag) open cfg file failed!");
		return false;
	}
	eErrDev = spConfig->WriteConfigValueInt("all", "IsIssue", value);
	if (eErrDev == Error_Succeed) {
		return true;
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("(FSMSetIssueFlag) write IsIssue err:%d, value:%d", eErrDev, value);
		return false;
	}
}
bool CCardIssuerFSM::SetCardCaptured(const int num,bool bClear)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardCaptured>, num:%d, bClear:%d, m_maxRetainCount:%d, m_bSettingMaterial:%d",
		num, bClear, m_maxRetainCount, m_bSettingMaterial);
	if (num < 0)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardCaptured>, open cfg file failed!");
		return false;
	}
	m_CardCaptured = num;
	if (num >= m_maxRetainCount)
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_RETAIN_BIN_IS_FULL, "<SetCardCaptured>, 回收箱满了，请及时清理!");

	eErrDev = spConfig->WriteConfigValueInt("all", "CardCaptured", num);
	if (eErrDev == Error_Succeed)
	{
		if (bClear && !m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain);
		}
		return true;
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardCaptured>, write CardCaptured err:%d, num:%d, bClear:%d", eErrDev, num, bClear);
		return false;
	}
}
bool CCardIssuerFSM::SetCardIssued(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<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 (hopper == 1)
		{
			int xNum = 0;
			spConfig->ReadConfigValueInt("all", "HopperNum", xNum);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SetCardIssued>, xNum:%d", xNum);
			if (xNum == 0)
				spConfig->WriteConfigValueInt("all", "HopperNum", 1);
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
		return true;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardIssued>, write CardIssued err:%d, num :%d, hopper: %d", eErrDev, num, hopper);
		return false;
	}
}
bool CCardIssuerFSM::SetCardRemains(const int num, const int hopper,bool bInit)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<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)
		{

			eErrDev = spConfig->WriteConfigValueInt(section, "CardInit", num);
		}

		if (eErrDev != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardRemains>, write CardInit err:%d", eErrDev);
			return false;
		}
		//oilyang@20170428 汪磊东要求单卡箱也要同步数据
		if (!m_bSettingMaterial)
		{
			bool bMaintain[12];
			memset(bMaintain, 0, 12);
			SyncDataToDB(bMaintain,false);
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardRemains>, write CardRemains err:%d, num:%d, hopper:%d, bInit:%d", eErrDev, num, hopper, bInit);
		return false;
	}
	return true;
}
bool CCardIssuerFSM::SetCardMixed(const int num, const int hopper)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("<SetCardMixed>, open cfg file failed!");
		return false;
	}
	if (hopper < 1 || hopper > HOPPER_NUM)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("wrong hopper num:%d .", hopper));
		return false;
	}
	if (num == 0)
		SetDevState(DEVICE_STATUS_NORMAL);
	else
	{
		CSimpleStringA errMsg = CSimpleStringA::Format("the current card hopper %d may be wrong.mixedEx:%d",
			hopper, m_mixedEx[hopper - 1]);
		DWORD dwTmpErrCode = CardIssuer_UserErrorCode_Hopper1_Mixed_Too_Much;
		if (hopper == 2)
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper2_Mixed_Too_Much;
		else if (hopper == 3)
			dwTmpErrCode = CardIssuer_UserErrorCode_Hopper3_Mixed_Too_Much;

		LogWarn(Severity_Middle, Error_Unexpect, dwTmpErrCode, errMsg.GetData());
	}
	char buf[8];
	memset(buf, 0, 8);
	_itoa(hopper, (char*)buf, 10);
	CSimpleStringA section(buf);
	eErrDev = spConfig->WriteConfigValueInt(section, "CardMixed", num);

	if (eErrDev != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_WRITE_FAILED)("<SetCardMixed>, write CardMixed err:%d", eErrDev);
		return false;
	}
	//oilyang@20170428 汪磊东要求单卡箱也要同步数据
	if (!m_bSettingMaterial)
	{
		bool bMaintain[12];
		memset(bMaintain, 0, 12);
		SyncDataToDB(bMaintain,false);
	}
	return true;

}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardBackNotHold()
{
	LOG_FUNCTION();
	long l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eMoveNotHold = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
	long l_endTime = GetTickCountRVC();

	//2016-11-10 14:30:54 joseph
	if (eMoveNotHold != Error_Succeed)
	{
		SetErrorAndLog(eMoveNotHold, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "MachineMoveCardBackNotHold::MoveCard err");
		return eMoveNotHold;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("MachineMoveCardBackNotHold::MoveCard");
	}
	return eMoveNotHold;
}
ErrorCodeEnum CCardIssuerFSM::MachineMoveCardFrontGate(bool bInBussiness)
{
	LOG_FUNCTION();
	long l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eMoveFrontGate = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
	long l_endTime = GetTickCountRVC();
	

	if (eMoveFrontGate != Error_Succeed){
		if (m_bCardFromHopper)
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("发卡，卡片吐出失败，请联系厂商检查卡嘴是否没对齐或是否有塞卡");
			SetErrorAndLog(eMoveFrontGate, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, bInBussiness, l_endTime - l_beginTime, "QLR040220305", "后端发卡，卡片吐出失败");

		}
		else
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("前端进卡，卡片吐出失败，请确认卡片是否平整");
			SetErrorAndLog(eMoveFrontGate, CardIssuer_UserErrorCode_MoveCardToGate_Failed, "DevAdapter::MoveCard", __FUNCTION__, bInBussiness, l_endTime - l_beginTime, "QLR040220305", "前端进卡，卡片吐出失败");
		
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220305")("MachineMoveCardFrontGate::MoveCard");
	}
	
	return eMoveFrontGate;
}
int CCardIssuerFSM::QueryCardInfo()
{
	int ret;
	if (m_hDevHelper == nullptr)
		ret = 1;
	else{
		if(GetDevStatus())
			ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 2 : 0;
		else
			ret = 1;
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("QueryCardInfo, ret:%d", ret);
	return ret;
}

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::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) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(RTAERR_CONFIG_OPEN_FAILED)("(UpdateLocalRunCfg)open cfg file failed!");
		return false;
	}

	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]);

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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();

	SyncMaterialCountInfo info = {};
	info.dwCardBoxNum = m_hopperNum;
	info.strDeviceNo = m_terminalNo;

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SyncDataToDB>, to init sync info, CardBox Num:%d, DeviceNo:%s", info.dwCardBoxNum, info.strDeviceNo.GetData());
	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];

		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<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;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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]);
	}
	
	//修改为起线程同步物料计数
	//判断物料url地址是否存在

	if (m_csSyncMaterialUrl.IsNullOrEmpty())
	{
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, "<SyncDataToDB>, SyncMaterialUrl is empty");
		return -1;
	}
	SyncMaterialCountTask* task = new SyncMaterialCountTask(this, info);
	ErrorCodeEnum err = GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	if (err != Error_Succeed) {
		CSimpleStringA errMsg = CSimpleStringA::Format("<SyncDataToDB>, create SyncMaterialCountTask thread fail. %d", (int)err);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, errMsg.GetData());
		return -2;
	}
	return 0;
}
void CCardIssuerFSM::SetHopperNum(int hopperNum)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("SetHopperNum, hopperNum:%d", hopperNum));
	m_hopperNum = hopperNum;
}

void CCardIssuerFSM::DoExitWhenIdle()
{
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("DoExitWhenIdle::GetDevStatus");
		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_IdleExit, errMsg.GetData());

			eErr = MachineMoveCardBackNotHold();
			if (eErr == Error_Succeed)
			{
				bool bCaptured = ToRegistCaptureCardInfo();
				m_CardCaptured++;
				bool bSetCapture = SetCardCaptured(m_CardCaptured);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("DoExitWhenIdle, to capture card. result:%d, m_CardCaptured:%d, bSetCapture:%d",
						bCaptured, m_CardCaptured, bSetCapture));
			}
		}
	}
}

bool CCardIssuerFSM::JustReadCardNo()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;
	m_currCardNo = "";
	bool bHasAccount = false;
	int activeCardType;
	l_beginTime = GetTickCountRVC();
	bool bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
	l_endTime = GetTickCountRVC();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("DetectIfICCard， bIC:%d, activeCardType:%d", bIC, activeCardType));

	if (bIC)
	{
		//oilyang@20201014 add emv support
		int bGetICData = m_pCardProcess->GetICDataFromCard(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList);
		if(bGetICData != 0)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<JustReadCardNo::GetICDataFromCard> faile(%d)", bGetICData));
		}
		ICData track2(false, 0x57, 0x00);
		string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
		if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<JustReadCardNo>, FindHexCharPosition， pos：%d, track2.lenth:%d， m_currCardNo.Len:%d",
											pos, track2.lenth, m_currCardNo.GetLength()));

			delete[]ddd;
			delete[]pICTrack2;
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();
		
		if (eErr != Error_Succeed){
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::DeactivateICCard");
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();
		

		if (eErr != Error_Succeed){
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::ReleaseIC");
		}
	}
	else {
		ErrorCodeEnum eErrCode = Error_Unexpect;
		CSimpleStringA ApiName = "";
		CSimpleStringA alarmMsg = "";
		CSimpleStringA csErrMsgWithReturnCode = "";
		GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setResultCode("RTA23CT")(csErrMsgWithReturnCode.GetData());
		LogWarn(Severity_Middle, Error_Unexpect, 0x2030000a, alarmMsg.GetData());
	}
	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));

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MagRead(magTracks);
		l_endTime = GetTickCountRVC();


		if (eErr == Error_Succeed)
		{
			//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::MagRead");

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("JustReadCardNo::MagRead 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 (magTracks.track[1].eStatus == CI_DATA_OK)
			{
				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 || 
						magTracks.track[1].data[i] == 0x44) //fixpoint (=或>)？ 运通卡考虑 = 和 D 
						break;
				}
				char buf[128];
				ZeroMemory(buf, 128);
				strncpy(buf, (char*)magTracks.track[1].data, pos);
				m_currCardNo = buf;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<JustReadCardNo::MagRead>, split pos:%d, m_currCardNo.Len:%d", pos, m_currCardNo.GetLength()));
				if (m_currCardNo.GetLength() > 1)
					bHasAccount = true;
			}
		}
		else {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
	}
	if (m_currCardNo.GetLength() > 8)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("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());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(errMsg.GetData());
	}
	return true;
}
bool CCardIssuerFSM::RegistCardWhileCaptureCard(CSimpleStringA cardno)
{
	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);

	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);
	CRegistSwallowCardReq qRegistCardReq;
	CRegistSwallowCardRet qRegistCardRet;
	qRegistCardReq.m_timeOut = 15;//15 second

	qRegistCardReq.m_url = m_csSwallowCardUrl.GetData();
	qRegistCardReq.cardNo = cardno;
	if (IsValidCardNo(cardno.GetData(), cardno.GetLength()))
	{
		if (cardno.GetLength() > 0)
			qRegistCardReq.reasonCode = m_captureReason;
		else
			qRegistCardReq.reasonCode = "0000";
	}
	else
		qRegistCardReq.reasonCode = "0001";

	qRegistCardReq.swallowDate = csDate;
	qRegistCardReq.swallowTime = csTime;
	qRegistCardReq.deviceSciNo = "";
	qRegistCardReq.terminalNo = m_terminalNo;
	qRegistCardReq.terminalType = m_csMachineType;
	//qRegistCardReq.m_url = "http://55.13.170.50:8080/defa-gateway/dee1/EacQuery/queryByEac";
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<RegistCardWhileCaptureCard>, 吞卡登记开始, SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s****%s, m_captureReason:%s",
	//	csDate.GetData(), csTime.GetData(), cardno.GetLength(), cardno.SubString(0, 6).GetData(),
	//	cardno.SubString(cardno.GetLength() - 4, 4).GetData(), m_captureReason.GetData());
	long beg = GetTickCountRVC();
	PROCESS_LINK_CONTEXT("LR0402203RegisterCard")
	bool ret = client->Post(qRegistCardReq, qRegistCardRet, &nextLink);
	long end = GetTickCountRVC();
	if (ret)
	{
		bool bParse = qRegistCardRet.Parse(qRegistCardRet.m_resultData.c_str());
		if (bParse)
		{
			if (qRegistCardRet.returnInfo.returnCode.compare("SUC0000") != 0) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2341")("登记吞卡信息到后台失败:%s,%s"
					, qRegistCardRet.returnInfo.returnCode.c_str(), qRegistCardRet.returnInfo.errorMsg.c_str());
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220304")("吞卡登记成功: SwallowDate:%s, SwallowTime:%s, cardNoLen:%d, m_currCardNo:%s****%s, m_captureReason:%s",
					csDate.GetData(), csTime.GetData(), cardno.GetLength(), cardno.SubString(0, 6).GetData(),
					cardno.SubString(cardno.GetLength() - 4, 4).GetData(), m_captureReason.GetData());
			}
		}
		else
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2341")("解析返回报文qRegistCardRet失败");
	}
	else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA2340")("访问吞卡登记失败");
	}
	client->Destory();
	return true;
}

bool CCardIssuerFSM::SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo syncInfo) {

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, 同步物料计数开始, DeviceNo = %s, CardBoxNum = %d", syncInfo.strDeviceNo.GetData(), syncInfo.dwCardBoxNum);

	if (syncInfo.strDeviceNo == NULL || strlen(syncInfo.strDeviceNo) == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, param [DeviceNo] invalid");
		return false;
	}

	if (syncInfo.dwCardBoxNum <= 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, param [CardBoxNum] invalid");
		return false;
	}

	if (m_csSyncMaterialUrl.GetLength() == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("<SyncMaterialCount>, m_csSyncMaterialUrl is null");
		return false;
	}

	CSystemStaticInfo info;
	m_pEntity->GetFunction()->GetSystemStaticInfo(info);

	SyncMaterialCountHTTPReq qTempReq;
	SyncMaterialCountHTTPRet qTempRet;

	qTempReq.m_url = m_csSyncMaterialUrl.GetData();
	qTempReq.m_headers.emplace(std::make_pair("Content-Type", "application/json"));
	SyncMaterialCountReq1& req1 = qTempReq.reqInfo;
#ifdef RVC_OS_WIN
	strncpy_s(req1.TerminalNo, sizeof(req1.TerminalNo), info.strTerminalID, _TRUNCATE);
	strncpy_s(req1.DeviceNo, sizeof(req1.DeviceNo), syncInfo.strDeviceNo, _TRUNCATE);
	strncpy_s(req1.Material, sizeof(req1.Material), "DebitCard", _TRUNCATE);
#else
	strncpy(req1.TerminalNo, info.strTerminalID, sizeof(req1.TerminalNo));
	strncpy(req1.DeviceNo, syncInfo.strDeviceNo, sizeof(req1.DeviceNo));
	strncpy(req1.Material, "DebitCard", sizeof(req1.Material));	
#endif //RVC_OS_WIN
	req1.CardBoxNum = syncInfo.dwCardBoxNum;
	for (int i = 0; i <= syncInfo.dwCardBoxNum; i++)
	{
		SyncMaterialCountReq2 pReq2;
		memset(&pReq2, 0, sizeof(SyncMaterialCountReq2));
		pReq2.bMaintain = syncInfo.arrMaintainFlag[i];
		if (syncInfo.arrMaintainFlag[i])
		{
#ifdef RVC_OS_WIN		
			strncpy_s(pReq2.Maintainer, sizeof(pReq2.Maintainer), syncInfo.arrMaintainer[i], _TRUNCATE);
#else
			strncpy(pReq2.Maintainer, syncInfo.arrMaintainer[i], sizeof(pReq2.Maintainer));
#endif //RVC_OS_WIN
			pReq2.MaintainTime = syncInfo.arrMaintainTime[i];
		}
#ifdef RVC_OS_WIN
		strncpy_s(pReq2.CardBoxNo, sizeof(pReq2.CardBoxNo), syncInfo.arrCardBoxNo[i], _TRUNCATE);
		strncpy_s(pReq2.PsbCode, sizeof(pReq2.PsbCode), syncInfo.arrPsbCode[i], _TRUNCATE);
		strncpy_s(pReq2.PsbName, sizeof(pReq2.PsbName), syncInfo.arrPsbName[i], _TRUNCATE);
#else
		strncpy(pReq2.CardBoxNo, syncInfo.arrCardBoxNo[i], sizeof(pReq2.CardBoxNo));
		strncpy(pReq2.PsbCode, syncInfo.arrPsbCode[i], sizeof(pReq2.PsbCode));
		strncpy(pReq2.PsbName, syncInfo.arrPsbName[i], sizeof(pReq2.PsbName));
#endif //RVC_OS_WIN
		pReq2.CardInit = syncInfo.arrCardInit[i];
		pReq2.CardRemains = syncInfo.arrCardRemains[i];
		pReq2.CardIssued = syncInfo.arrCardIssued[i];
		pReq2.CardMixed = syncInfo.arrCardMixed[i];
		pReq2.CardPercent = syncInfo.arrCardPercent[i];
		qTempReq.reqData.push_back(pReq2);
	}
	PROCESS_LINK_CONTEXT("LR0402203SyncMaterialCount")
	if (!client->Post(qTempReq, qTempRet, &nextLink)) {
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, http req fail,url=%s, err=%s", qTempReq.m_url.c_str(), qTempRet.m_errMsg.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2330")("同步物料计数通讯失败");
		return false;//通讯失败
	}

	Json::Reader reader;
	Json::Value rootRet;
	if (!reader.parse(qTempRet.m_retStr, rootRet, false))
	{
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, parse resp is fail, url=%s", qTempReq.m_url.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2331")("同步物料计数解析返回报文失败");
		return false;//解析失败
	}

	if (rootRet["success"].isBool()) {
		bool isSucc = rootRet["success"].asBool();
		if (isSucc){
			//成功
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("同步物料计数成功");
			return true;
		}
		else {
			//失败
			LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, is error, url=%s", qTempReq.m_url.c_str()).GetData());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2332")("同步物料计数失败");
			return false;
		}
	}
	else {
		//参数不符合
		LogWarn(Severity_Middle, Error_Exception, CardIssuer_UserErrorCode_SyncMaterialCount_Failed, CSimpleStringA::Format("<SyncMaterialCount>, resp param is error, url=%s", qTempReq.m_url.c_str()).GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402203Z02").setResultCode("RTA2333")("同步物料计数返回参数不对");
		return false;
	}
}

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'
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<IsValidCardNo>, CardNo is Invalid with illegal charactor:%c", pCardNo[i]);
			return false;
		}
	}
	return true;
}
int CCardIssuerFSM::SAMICCommand(SpReqAnsContext<CardIssuerStandService_SAMICCommand_Req, CardIssuerStandService_SAMICCommand_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<SAMICCommand, inParam<cmdType:%d>", ctx->Req.cmdType);

	switch (ctx->Req.cmdType)
	{
	case SAMICCommand_SAM_Select:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMICCommand::SAMSelect, req.param1:%d ", ctx->Req.param1[0]);
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMSelect(ctx->Req.param1[0]);
		l_endTime = GetTickCountRVC();

		if (eErr) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMSelect, "DevAdapter::SAMSelect", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMSelect").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMSelect succ");
		}
	}
		break;
	case SAMICCommand_SAM_Active:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMICCommand::SAMActive, req.param1:%d ", ctx->Req.param1[0]);
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMActive(ctx->Req.param1[0]);
		l_endTime = GetTickCountRVC();	

		if (eErr) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMActive, "DevAdapter::SAMActive", __FUNCTION__, false, l_endTime - l_beginTime, "","");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMActive").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMActive succ");
		}
	}
		break;
	case SAMICCommand_SAM_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMDeactivate();
		l_endTime = GetTickCountRVC();	

		if (eErr) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMDeactivate, "DevAdapter::SAMDeactivate", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMDeactivate").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMDeactivate");
		}
	}
		break;
	case SAMICCommand_SAM_WarmReset:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMWarmReset();
		l_endTime = GetTickCountRVC();

		if (eErr) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMWarmReset, "DevAdapter::SAMWarmReset", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMWarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMWarmReset");
		}
	}
		break;
	case SAMICCommand_SAM_QueryStatus:
	{
		SAMStatus samStatus;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMQueryStatus(samStatus);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMQueryStatus").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMQueryStatus");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMWarmReset isActive:%d, chosenOfSAM:%d", samStatus.isActive, samStatus.chosenOfSAM);
			ctx->Ans.ret1.Init(2);
			ctx->Ans.ret1[0] = samStatus.isActive;
			ctx->Ans.ret1[1] = samStatus.chosenOfSAM;
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMQueryStatus, "DevAdapter::SAMQueryStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
	}
		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;

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SAMCommand(sendBuf,recvBuf);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SAMCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::SAMCommand");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SAMCommand req.param2:%s, recvBuf.dwSize:%d", ctx->Req.param2[0].GetData(), recvBuf.dwSize);
			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
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SAMCommand, "DevAdapter::SAMCommand", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_IC_Active:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ContactIC();
		l_endTime = GetTickCountRVC();
		

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ContactIC").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ContactIC");
			CmdInfo atrBuf;
			l_beginTime =GetTickCountRVC();
			eErr = m_hDevHelper->ActiveICCardATR(atrBuf);
			l_endTime =GetTickCountRVC();
			
			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveICCardATR").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ActiveICCardATR");
				BYTE* pTmp = new BYTE[MAX_IC_BUFFER_SIZE];
				if (pTmp == NULL)
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AtrCtx: size=%d, content=%s, pTmp=%s", ctx->Ans.ret1[0], (LPCTSTR)ctx->Ans.ret2[0], (LPCTSTR)pTmp);
				delete[] pTmp;
				pTmp = NULL;

			}
			else
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ActiveICCardATR, "DevAdapter::ActiveICCardATR", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			}

		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ContactIC, "DevAdapter::ContactIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
	}
		break;
	case SAMICCommand_IC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactivateICCard();
			l_endTime = GetTickCountRVC();
			
			if (eErr != Error_Stoped)
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactivateICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactivateICCard");
		}
	}
		break;
	case SAMICCommand_IC_WarmReset:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->WarmReset();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_WarmReset, "DevAdapter::WarmReset", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WarmReset").setCostTime(l_endTime - l_beginTime)("SAMICCommand::WarmReset");
		}
	}
		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;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ICCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();

		if(false)//oiltest@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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ICCommand return data, %s", (const char*)pRet);
				delete[] pRet;
			}
										
		}

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ICCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ICCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("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
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		delete[]pTmp;
	}
		break;
	case SAMICCommand_RFIC_Active:
	{
		char chType = 0;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ActiveContactlessICCard('A', 'B', 'M', chType);
		l_endTime = GetTickCountRVC();
		
		ctx->Ans.ret1.Init(1);
		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ActiveContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::ActiveContactlessICCard, chType:%d", chType);
			ctx->Ans.ret1[0] = chType;
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ActiveContactlessICCard, "DevAdapter::ActiveContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
	}
		break;
	case SAMICCommand_RFIC_Deactivate:
	{
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->DeactContactlessICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {

			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->DeactContactlessICCard();
			l_endTime = GetTickCountRVC();

			if (eErr != Error_Succeed) {
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactContactlessICCard");
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("SAMICCommand::DeactContactlessICCard");
		}
	}
		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;
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->RFTypeABCommand(sendBuf, recvBuf);
		l_endTime = GetTickCountRVC();
		if (false)//oiltest@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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RFTypeABCommand, return data:%s", (const char*)pRet);
				delete[] pRet;
			}

		}

		if (eErr == Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::RFTypeABCommand").setCostTime(l_endTime - l_beginTime)("SAMICCommand::RFTypeABCommand");
			if (recvBuf.dwSize > 0 && recvBuf.dwSize < 1024)
			{
				char* pRet = new char[MAX_IC_BUFFER_SIZE];
				ZeroMemory(pRet, MAX_IC_BUFFER_SIZE);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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{
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		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::GetVendorDllName(CSimpleStringA& strDevAdaptorPath)
{
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->LoadVendorLibName();
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	strDevAdaptorPath = m_adapterInfo.adapterFilePath;
	return;
}
bool CCardIssuerFSM::AccountExchange(const char *origAcc, CSimpleStringA &acc, int dir)
{
	int len = strlen(origAcc);
	if (len < 8)
	{
		if (len > 4)//排除掉一些空格或者换行之类的干扰日志
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<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::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;
}

void CCardIssuerFSM::DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size, char *&magData, bool bT2OK, bool bT3OK)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<DecodeTracksData>, bT2OK:%d, bT3OK:%d, t2.size:%d(%d), t3.size:%d(%d)",
		bT2OK, bT3OK, dwT2size, strlen(track2), dwT3size, strlen(track3));

	if (!bT2OK)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<DecodeTracksData>, track2 data isn't ok.");
		return;
	}
	if (dwT2size <= 0 || strlen(track2) < 15)//fixpoint AE card is 15
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<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);
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<DecodeTracksData>，cardType:%s", cardType);

	if (!bT3OK || strlen(cardType) < 4)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E3")("<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)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<SplitDevModelInfo>, Wrong szModel:%s", m_devCat.szModel);
		return -1;
	}
	m_csRF = "";
	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], "RF", 2) == 0)
		{
			if (arrParam[i].GetLength()>3) {
				m_csRF = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);//获取非接支持的字段值
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("szModel: RF[%s] , m_csRF=%s", arrParam[i].GetData(), m_csRF.GetData());
			
		}
	}
	return 0;
}

void CCardIssuerFSM::CloseAndClearDevObj(bool bCheckConnecting, bool bCloseOnly)
{
	LOG_FUNCTION();
	ErrorCodeEnum ec = Error_Unexpect;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CloseAndClearDevObj>, bCloseOnly:%d, m_bOpened:%d",
		bCloseOnly, m_bOpened);
	if (m_hDevHelper != nullptr && !bCloseOnly)
	{
		m_hDevHelper.TearDown();
		SetDevInitFlag(false);
		//硬件适配器关闭，则设置打开失败
	}
}

int CCardIssuerFSM::JudgeCardType(CSimpleStringA cardno, bool& bMismatch)
{
	if (cardno.GetLength() < 8)
		return 0;
	int cardType = 0;
	IHttpFunc* client;
	client = create_http(HttpsLogCallBack);
	CQueryCardTypeReq qCardTypeReq;
	CQueryCardTypeRet qCardTypeRet;
	//qCardTypeReq.m_printDbg = true;//oiltest
	qCardTypeReq.m_timeOut = 3;//3 second

	qCardTypeReq.m_url = m_EacQueryHost.GetData();
	//qCardTypeReq.m_url = "http://55.13.170.50:8080/defa-gateway/dee1/EacQuery/queryByEac";
	qCardTypeReq.HEAD.xHdrLen = 203;
	qCardTypeReq.HEAD.xIsuCnl = "X86";
	qCardTypeReq.HEAD.xRtnCod = "SUC0000";
	qCardTypeReq.BODY.x1.xCltNbr = "";
	qCardTypeReq.BODY.x1.xEacNbr = cardno.GetData();
	qCardTypeReq.BODY.x1.xIacNbr = "";
	long beg = GetTickCountRVC();
	PROCESS_LINK_CONTEXT("LR0402203CardType")
	bool ret = client->Post(qCardTypeReq, qCardTypeRet, &nextLink);
	long end = GetTickCountRVC();
	if (ret)
	{
		bool bParse = qCardTypeRet.Parse(qCardTypeRet.m_resultData.c_str());
		if (bParse)
		{
			if (qCardTypeRet.BODY.z1.zPsbMdm.compare("C") == 0)
				cardType = 2;
			else if (qCardTypeRet.BODY.z1.zPsbMdm.compare("I") == 0)
				cardType = 3;
			else if (qCardTypeRet.BODY.z1.zPsbMdm.compare("M") == 0)
				cardType = 1;
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("Query card type from host is:%s,zPsbSeq:%s"
				, qCardTypeRet.BODY.z1.zPsbMdm.c_str(), qCardTypeRet.BODY.z1.zPsbSeq.c_str()));
			int eacLen = qCardTypeRet.BODY.z1.zEacNbr.length();
			if (eacLen > 7 && cardno.Compare(qCardTypeRet.BODY.z1.zEacNbr.c_str()) != 0)
			{
				bMismatch = true;
				LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Account_EAC_Mismatch,
					CSimpleStringA::Format("cardno:%s****%s EAC:%s****%s", cardno.SubString(0,6).GetData(), cardno.SubString(cardno.GetLength()-4, 4).GetData()
						, qCardTypeRet.BODY.z1.zEacNbr.substr(0, 6).c_str(), qCardTypeRet.BODY.z1.zEacNbr.substr(eacLen - 4, 4).c_str()));
			}
		}
		else
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("Query card type return false:%s",qCardTypeRet.HEAD.xRtnCod.c_str()));//也没必要知道什么错 oilyang@20220829 在功能可用之前，还是有必要的
	}
	else {
	}
	client->Destory();
	//oiltest for stupid http component!!!
	//if (cardno.IsStartWith("622580") || cardno.IsStartWith("622588") || cardno.IsStartWith("622609")
	//	|| cardno.IsStartWith("410062"))
	//	return 3;
	return cardType;
}


void CCardIssuerFSM::HttpsLogCallBack(const char* logtxt) {
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s", logtxt);
}
void CCardIssuerFSM::QueryCIStatus(SpReqAnsContext<CardIssuerStandService_QueryCIStatus_Req, CardIssuerStandService_QueryCIStatus_Ans>::Pointer ctx)
{
	if (m_hDevHelper == nullptr)
		ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	long l_beginTime, l_endTime;
	memset(&cis, 0, sizeof(CardIssuerStatus));

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("QueryCIStatus::GetDevStatus");
		ctx->Ans.retainBin = cis.eRetainBin;
		ctx->Ans.hopperNo.Init(m_hopperNum);
		ctx->Ans.hopperStatus.Init(m_hopperNum);
		for (int i = 0; i < m_hopperNum; ++i)
		{
			ctx->Ans.hopperNo[i] = i;
			ctx->Ans.hopperStatus[i] = (int)cis.eIssuerBin[i];
		}
		ctx->Answer(Error_Succeed);
	}
	return;
}
bool CCardIssuerFSM::ToRegistCaptureCardInfo()
{
	//oilyang@20230214 no need to regist swallowed card info to system(according to meeting result,运营&财富平台)

	//to check if url config
	if (m_csSwallowCardUrl.IsNullOrEmpty())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220304").setResultCode("RTA230Z")("m_csSwallowCardUrl is empty. %s", m_csSwallowCardUrl.GetData());
		return false;
	}
	RegistCaptureCardInfoTask* task = new RegistCaptureCardInfoTask(this, m_currCardNo);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	return true;
}
bool CCardIssuerFSM::IfUseRf()
{
	if (m_bStopUseRF)
		return false;

	//加入szmodel非接字段属性判断
	if (m_csRF.Compare("Y") == 0) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("szModel,RF=%s", m_csRF.GetData());
		return true;
	}	
	CAutoArray<CSimpleStringA> arr = m_rfVendorList.Split('|');
	
	for (int i = 0; i < arr.GetCount(); ++i)
	{
		if (m_adapterInfo.adapterFilePath.IndexOf(arr[i].GetData()) > 0) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s,%s", arr[i].GetData(), m_adapterInfo.adapterFilePath.GetData());
			return true;
		}
	}

	return false;
}

int CCardIssuerFSM::EjectJS(SpReqAnsContext<CardIssuerStandService_EjectJS_Req, CardIssuerStandService_EjectJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("吐卡开始");
	long l_beginTime, l_endTime;
	Sleep(300);//oilyang@20230106 for keba said "maybe we need stay for machine to prepare..."
	int ret = 0;
	ErrorCodeEnum eErr;
	m_pCardProcess->DataInit();
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_FRONT_GATE);
	l_endTime = GetTickCountRVC();
	DWORD dwTmpUserErrCode = 0;
	if (eErr != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
		if (m_bCardFromHopper) {
			if (IsInBusiness() && ctx != NULL) {
				dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
			}
			else {
				dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FRONT_GATE, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
			}
		}
		else {
			if (IsInBusiness() && ctx != NULL) {
				dwTmpUserErrCode = SetErrorAndLog(eErr, CardIssuer_UserErrorCode_MoveCardToGate_Failed, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
			}
			else {
				dwTmpUserErrCode = SetErrorAndLog(eErr, CardIssuer_UserErrorCode_MoveCardToGate_Failed, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE) err");
			}
		}
		if (ctx != NULL) {
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
		return 1;//S9
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220342")("EjectJS::MoveCard(CI_MOVECARD_FRONT_GATE)");
		//等待取卡
		DWORD dwStart, dwEnd;
		dwStart = GetTickCountRVC();
		ErrorCodeEnum errState = Error_Succeed;
		long l_beginTime, l_endTime;
		DWORD dwTmpUserErrCode = 0;
		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_ON, "CardReader(fetch) warning on");
		do {

			l_beginTime = GetTickCountRVC();
			errState = m_hDevHelper->GetDevStatus(m_devStatus);
			l_endTime = GetTickCountRVC();

			if (Error_Succeed == errState) {
				dwEnd = GetTickCountRVC();
				if (m_devStatus.eMedia == CI_MEDIA_ENTERING) {
					Sleep(WAIT_INTERVAL);
				}
				else {
					
					l_beginTime = GetTickCountRVC();
					ErrorCodeEnum eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
					l_endTime = GetTickCountRVC();


					if (eErr != Error_Succeed) {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN) err");
						SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN) err");
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("EjectJS::SetCardInType");
					}

					LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
					if (ctx != NULL) {
						ctx->Answer(Error_Succeed);
					}
					return 0;//成功取走
				}
			}
			else
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
				
				if (IsInBusiness() && ctx != NULL) {
					dwTmpUserErrCode = SetErrorAndLog(errState, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040220342", "");
				}
				else {
					dwTmpUserErrCode = SetErrorAndLog(errState, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "");
				}
				
				if (ctx != NULL)
				{
					ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
				}
				return 1;//S9
			}
		} while ((dwEnd - dwStart) < 55 * 1000);//预留5秒给吞卡操作
		LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader(fetch) warning off");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("客户未取卡超时");

		//超时未取卡进行吞卡操作
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
		l_endTime = GetTickCountRVC();

		if (eErr == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)");
			m_CardCaptured++;
			m_captureReason = "4998";//超时未取卡引起吞卡
			ToRegistCaptureCardInfo();//登记吞卡记录
			m_currCardNo = m_addCardNo = "";

			l_beginTime = GetTickCountRVC();
			ErrorCodeEnum eErrSet = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
			l_endTime = GetTickCountRVC();

			if (eErrSet != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::SetCardInType err");
				SetErrorAndLog(eErrSet, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::SetCardInType err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("EjectJS::SetCardInType");
			}
			//超时吞卡成功
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Succ, "forget fetch card ,capture succ");
			if (ctx != NULL) {
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Succ);
			}
			return 0;//超时吞卡成功
		}
		else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
			
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220342", "EjectJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
			
			//超时吞卡失败
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Fail, "forget fetch card ,capture fail");
			if (ctx != NULL) {
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Forget_Fetch_Card_Capture_Fail);
			}
			return 1;//S9 超时吞卡失败
		}

	}
}

int CCardIssuerFSM::CaptureJS(SpReqAnsContext<CardIssuerStandService_CaptureJS_Req, CardIssuerStandService_CaptureJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("吞卡开始");
	long l_beginTime, l_endTime;
	int ret = 0;
	if (ctx != NULL) {
		if (!ctx->Req.captureCode.IsNullOrEmpty()) {
			m_captureReason = ctx->Req.captureCode;
		}
		else {
			m_captureReason = "9999";//默认值，未分类的业务吞卡
		}
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CaptureCard_FromBusiness, CSimpleStringA::Format("CaptureCard called from Business. captureReason=%s", ctx->Req.captureCode.GetData()));
	}
	m_pCardProcess->DataInit();

	//判断是否无卡
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed) {

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("CaptureJS::GetDevStatus succ,m_devStatus.eMedia=%d", (int)m_devStatus.eMedia);
		if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT) {
			//读卡器无卡
			l_beginTime = GetTickCountRVC();
			ErrorCodeEnum eErrSet = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
			l_endTime = GetTickCountRVC();

			if (eErrSet != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CaptureJS::SetCardInType err");
				SetErrorAndLog(eErrSet, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220343", "CaptureJS::SetCardInType err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("CaptureJS::SetCardInType");
			}
			CSimpleStringA maskCardno = MaskCardno(m_currCardNo.GetData());
			m_currCardNo = m_addCardNo = "";
			if (ctx != NULL) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode("QLR040220343").setResultCode("RTA23CS")("CaptureJS::GetDevStatus succ, No card found in cardReader, m_currCardNo=%s", maskCardno.GetData());
				LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Capture_NoCard_Failed, "Capture card, No card found in cardReader");
				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Capture_NoCard_Failed);//读卡器无卡
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode("QLR040220343").setResultCode("RTA23CS")("CaptureJS::GetDevStatus succ, No card found in cardReader");
			}
			return 0;//回到无卡状态
		}
	}
	else {
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220343", "");
	}

	DWORD dwTmpUserErrCode = 0;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->MoveCard(CI_MOVECARD_BACK_NOT_HOLD);
	l_endTime = GetTickCountRVC();

	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD)");
		m_CardCaptured++;
		ToRegistCaptureCardInfo();//登记吞卡记录
		m_currCardNo = m_addCardNo = "";

		l_beginTime = GetTickCountRVC();
		ErrorCodeEnum eErrSet = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();

		if (eErrSet != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CaptureJS::SetCardInType err");
			SetErrorAndLog(eErrSet, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220343", "CaptureJS::SetCardInType err");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("CaptureJS::SetCardInType");
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
		if (ctx != NULL && IsInBusiness()) {
			dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, true, l_endTime - l_beginTime, "QLR040220343", "CaptureJS::MoveCard(CI_MOVECARD_BACK_NOT_HOLD) err");
		}
		else {
			dwTmpUserErrCode = SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_BACK_NOT_HOLD, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220343", "");
		}
		ret = 1;
	}
	//业务返回
	if (ctx != NULL) {
		if (Error_Succeed == eErr) {
			ctx->Answer(Error_Succeed);
		}
		else {
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
	}
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CapturedJS, ret:%d", ret);
	return ret;
}

void CCardIssuerFSM::QueryHasCardJS(SpReqAnsContext<CardIssuerStandService_QueryHasCardJS_Req, CardIssuerStandService_QueryHasCardJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int ret = 0;
	if (m_hDevHelper == nullptr) {
		ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_DevOpen_Failed);
	}
	else {
		ErrorCodeEnum errCode;
		long l_beginTime, l_endTime;
		l_beginTime = GetTickCountRVC();
		errCode = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();

		if (Error_Succeed == errCode)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("QueryHasCardJS::GetDevStatus, m_devStatus.eMedia:%d", m_devStatus.eMedia);
			//ret = (m_devStatus.eMedia == CI_MEDIA_PRESENT) ? 1 : 0;
			ret = (int)m_devStatus.eMedia;
			ctx->Ans.position = ret;
			ctx->Answer(Error_Succeed);
		}
		else
		{
			DWORD dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}

	}
}

int CCardIssuerFSM::IssueFromBoxJS(SpReqAnsContext<CardIssuerStandService_IssueFromBoxJS_Req, CardIssuerStandService_IssueFromBoxJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("卡箱发卡");
	CSimpleStringA errMsg(true);
	long l_beginTime, l_endTime;

	//Req.hopper
	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IssueCard, issue hopper:%d", ctx->Req.hopper);
	ctx->Ans.reserved1.Init(2);

	//param Req.hopper is wrong
	if (ctx->Req.hopper < 1 || ctx->Req.hopper > 6) {
		errMsg = CSimpleStringA::Format("Issuer Card, the hopperNo(%d) is wrong!!!", ctx->Req.hopper);
		LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_Invalid_Hopper, errMsg.GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA23CW")(errMsg.GetData());
		ctx->Answer(Error_Param, CardIssuer_UserErrorCode_Invalid_Hopper);
		return 1;
	}
	m_currentHopper = ctx->Req.hopper;//设置发送的卡箱号
	m_pCardProcess->DataInit();

	ErrorCodeEnum errCode;
	CardIssuerStatus cis;
	memset(&cis, 0, sizeof(CardIssuerStatus));
	bool bEmpty = false;

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->GetDevStatus(cis);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed) {
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("IssueFromBoxJS::GetDevStatus");
		if (cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_EMPTY || cis.eIssuerBin[m_currentHopper - 1] == CI_ISSUEHOPPER_NOTSUPP) {
			bEmpty = true;
		}
	}

	if (bEmpty)
	{
		//卡箱无卡时返回错误信息
		CSimpleStringA warnInfo = CSimpleStringA::Format("IssuerCard, hopper%d no more cards to issue. Vendor return:NoCard(%d), CardCount(%d)",
			cis.eIssuerBin[m_currentHopper - 1], cis.dwIssuerCount[m_currentHopper - 1]);
		LogWarn(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)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230B")("未检测到卡箱1，请检测卡箱1是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230C")("未检测到卡箱2，请检测卡箱2是否放好");
				dwUsrErrCode = CardIssuer_UserErrorCode_NotHas_Hopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230D")("未检测到卡箱3，请检测卡箱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)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230E")("卡箱1未检测到卡片，请检测卡箱1中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper1;
			}
			else if (m_currentHopper == 2)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230F")("卡箱2未检测到卡片，请检测卡箱2中卡片是否放好或卡片余量过低");
				dwUsrErrCode = CardIssuer_UserErrorCode_NoCardInHopper2;
			}
			else if (m_currentHopper == 3)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220345").setResultCode("RTA230G")("卡箱3未检测到卡片，请检测卡箱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;
		}
		ctx->Answer(Error_DevNotAvailable, dwUsrErrCode);
		return 1;
	}

	//forbid front enter

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
	l_endTime = GetTickCountRVC();

	if (errCode != Error_Succeed)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("IssueFromBoxJS::SetCardInType");
	}

	FSMSetIssueFlag(1);
	//move card to holder

	l_beginTime = GetTickCountRVC();
	errCode = m_hDevHelper->MoveCard(CI_MOVECARD_FROM_HOPPER, m_currentHopper);
	l_endTime = GetTickCountRVC();

	m_bCardFromHopper = true;//用于区分吐卡报错不同
	if (errCode != Error_Succeed)
	{
		CSimpleStringA errMsg = CSimpleStringA::Format("IssueFromBoxJS::MoveCard err, m_currentHopper:%d", m_currentHopper);
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());
		FSMSetIssueFlag(2);
		DWORD dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_CI_MOVECARD_FROM_HOPPER, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220345", errMsg.GetData());
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		return 2;//S9 
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220345")("IssueCard::MoveCard succ, m_currentHopper:%d", m_currentHopper);
	}
	//LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_MoveCard_FromHopper, "MoveCard from hopper succ.");

	m_bUseRFTillNext = false;
	Sleep(1000);
	ctx->Ans.reserved1[0] = ctx->Ans.reserved1[1] = 0;

	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::PostOnlineJS(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx)
{
	if (m_bUseRFTillNext) {
		return PostOnlineJS_RF(ctx);
	}
	bool bCtOK = false;
	int ret = PostOnlineJS_Contact(ctx, bCtOK);
	if (!bCtOK && IfUseRf()) {
		return PostOnlineJS_RF(ctx);
	}
	else {
		return ret;
	}
}

int CCardIssuerFSM::PostOnlineJS_Contact(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx, bool& bICOK)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PostOnlineJS_Contact) 联机后IC接触处理");
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnlineJS_Contact>, postOnLine data[%s]", ctx->Req.data.GetData());
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data.GetData(), 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;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220341")("<PostOnlineJS_Contact>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::PostOnlineJS_RF(SpReqAnsContext<CardIssuerStandService_PostOnlineJS_Req, CardIssuerStandService_PostOnlineJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PostOnlineJS_RF) 联机后IC非接处理");
	m_pCardProcess->DataInit();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PostOnlineJS_RF>, postOnLine data[%s]", ctx->Req.data.GetData());
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data.GetData(), strlen(ctx->Req.data));
	int issBnkAuth = m_pCardProcess->IssueBankAuth(CARD_MACHINE_ISSUER_RF, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(CARD_MACHINE_ISSUER_RF, 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;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220341")("<PostOnlineJS_RF>, issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData());
	ctx->Answer(Error_Succeed);
	return 0;
}

int CCardIssuerFSM::ReadMag(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx, bool& bReadCardInfo, bool& bReadMag, CSimpleStringA& t2Account)
{
	m_currCardNo = "";
	ctx->Ans.magStatus = 0; //读磁硬件状态默认值

	ErrorCodeEnum eErr, eMagReadErr;
	int activeCardType;
	bool bIC(false);
	long l_beginTime, l_endTime;
	CSimpleString errMsg("");
	errMsg = CSimpleString::Format("ReadCard, inParam: m_issueStatus:%d, m_currentHopper:%d", m_issueStatus, m_currentHopper);
	//LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_ReadCard_Process, errMsg.GetData());
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(errMsg.GetData());

	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));
	magTracks.eRange = CI_TRACK_RANGE_2_3;

	int readTries = 0;
	do {
		l_beginTime = GetTickCountRVC();
		eMagReadErr = m_hDevHelper->MagRead(magTracks);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed == eMagReadErr) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MagRead").setCostTime(l_endTime - l_beginTime)("ReadMag::MagRead t1Status:%d, t2Status:%d, t3Status:%d, t1Len:%d, t2Len:%d, t3Len:%d",
				magTracks.track[0].eStatus, magTracks.track[1].eStatus, magTracks.track[2].eStatus, magTracks.track[0].dwSize, magTracks.track[1].dwSize, magTracks.track[2].dwSize);
			bReadMag = true;//读卡成功
			ctx->Ans.magStatus = 1;//成功
			ctx->Ans.track1 = (char*)magTracks.track[0].data;
			ctx->Ans.track2 = (char*)magTracks.track[1].data;
			ctx->Ans.track3 = (char*)magTracks.track[2].data;
			ctx->Ans.track1Size = magTracks.track[0].dwSize;
			ctx->Ans.track2Size = magTracks.track[1].dwSize;
			ctx->Ans.track3Size = magTracks.track[2].dwSize;
			ctx->Ans.track1Status = (int)magTracks.track[0].eStatus;
			ctx->Ans.track2Status = (int)magTracks.track[1].eStatus;
			ctx->Ans.track3Status = (int)magTracks.track[2].eStatus;
		}
		else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ReadMag::MagRead fail");
			SetErrorAndLog(eMagReadErr, MEC_DEVAPI_CARDISSUER_MagRead, "DevAdapter::MagRead", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadMag::MagRead fail");
			bReadMag = false;//读卡失败
			ctx->Ans.magStatus = 0;//失败
			ctx->Ans.track1 = "";
			ctx->Ans.track2 = "";
			ctx->Ans.track3 = "";
			ctx->Ans.track1Size = 0;
			ctx->Ans.track2Size = 0;
			ctx->Ans.track3Size = 0;
			ctx->Ans.track1Status = 1;
			ctx->Ans.track2Status = 1;
			ctx->Ans.track3Status = 1;
		}
		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());
			bReadMag = false;//读卡失败
			ctx->Ans.magStatus = 0;//失败
			break;
		}

		if (Error_Succeed == eMagReadErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand 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.magStatus = 0;//失败
				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)
			{
				if (magTracks.track[1].data[i] == 0x3d || magTracks.track[1].data[i] == 0x3e || magTracks.track[1].data[i] == 0x44)// fixpoint (3d是=，3e是 >), 运通卡要考虑分隔符为D的情况
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleString::Format("<ReadMag::MagRead>, split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("<ReadMag::MagRead>, split track is err, pos:%d", pos);
				//ctx->Ans.magStatus = 0;//失败
				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.magStatus = 1;//成功
				//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;
				bReadCardInfo = true;//成功
				m_currCardNo = track2Data.t2Account;
				t2Account = track2Data.t2Account;
				if (m_issueStatus)
				{
					//设置为mixed从读卡失败恢复为成功时才触发同步计数和写运行时
					SetDevState(DEVICE_STATUS_NORMAL);
				}
			}
			if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)) && (track2Data.t2Account.GetLength() != 8))
			{

				//ctx->Ans.magStatus = 1;//成功
				//ctx->Ans.t2Account = (char*)ddd;
				//ctx->Ans.t2Region = "";
				//ctx->Ans.t2CardSerial = "";
				//ctx->Ans.t2CVC = "";
				//ctx->Ans.t2ExpireDate = "";
				bReadCardInfo = true;//成功
				m_currCardNo = (char*)ddd;
				t2Account = (char*)ddd;
				delete[]ddd;

			}
			if (tmpMag2 != NULL)
			{
				delete[]tmpMag2;
				tmpMag2 = NULL;
			}
			CSimpleString maskCardno = MaskCardno(m_currCardNo.GetData());

			CSimpleStringA cardInfo(true);
			cardInfo = CSimpleStringA::Format("cardBin:%s , len:%d", maskCardno.GetData(), m_currCardNo.GetLength());
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardBin, cardInfo.GetData());

			//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());
			//}

			break;
		}
	} while (readTries < READ_TRY_NUM);

	return 0;
}

int CCardIssuerFSM::CheckCardType(CSimpleStringA cardNo, bool bReadMag, int& ICtype)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr;
	//oilyang@20230331
	//1、发卡且读磁成功，不再继续检测IC，一律ICType=1，以便读取IC
	//2、其他情况（发卡未读到磁条或前端插卡），先查询户口系统进行卡片介质判定：
	//	2a：户口系统返回非纯磁条介质类型，ICType以户口为准（ICType影响后续IC读取，即：都会读IC）
	//	2b：其他情况（户口系统访问错（未走户口系统查或访问微服务失败或未返回介质类型或返回纯磁条卡），一律探测是否芯片卡
	if (m_issueStatus && bReadMag)//发卡默认给芯片卡，且读到磁道（考虑卡片放错）
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType>, issueStatus is true and read mag OK");
		ICtype = 1;
	}
	else {
		int cardTypeFromHost = 0;
		bool bMismatch = false;
		//开关控制是否主机查询cardtype
		if (m_eacQueryFlag == 1) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType>, begin query host to check cardType");
			cardTypeFromHost = JudgeCardType(cardNo, bMismatch);//0：失败 1：复合 2：磁条 3：ic
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType>, cardTypeFromHost=%d", cardTypeFromHost);
		}
		if (cardTypeFromHost > 0 && cardTypeFromHost != 2)//户口系统返回非纯磁条介质类型
		{
			ICtype = cardTypeFromHost;
			//卡号不同则直接返回报错
			if (m_bUseCardnoMismatch && bMismatch)
			{
				return 1;//账户和户口系统的最新账户不匹配
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType>, begin detect cardType");
			//主动探测
			int activeCardType;
			int icRetryTimes = 0;
			bool bIC(false);
			while (1)
			{//for poor mag only card,we always retry...
				l_beginTime = GetTickCountRVC();
				bIC = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER, m_hDevHelper, activeCardType);
				l_endTime = GetTickCountRVC();
				if (!bIC)
					icRetryTimes++;
				else
					break;
				Sleep(500);
				if (icRetryTimes >= m_ICRetryTimes)
					break;
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType::DetectIfICCard>, bIC:%d", bIC);
			if (!bIC) {
				ErrorCodeEnum eErrCode = Error_Unexpect;
				CSimpleStringA ApiName = "";
				CSimpleStringA alarmMsg = "";
				CSimpleStringA csErrMsgWithReturnCode = "";
				GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setResultCode("RTA23CT")(csErrMsgWithReturnCode.GetData());
				LogWarn(Severity_Middle, Error_Unexpect, 0x2030000a, alarmMsg.GetData());
			}

			//ic探测成功，0.无磁条IC 1.复合 2.磁条 3.纯IC 
			if (bIC) {
				if (bReadMag) {
					ICtype = 1;
				}
				else {
					ICtype = 3;
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MaybeIC_Only, "<CheckCardType>, maybe IC only.");
				}
				//释放资源
				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->DeactivateICCard();
				l_endTime = GetTickCountRVC();

				if (eErr != Error_Succeed) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CheckCardType::DeactivateICCard err");
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "CheckCardType::DeactivateICCard err");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("CheckCardType::DeactivateICCard");
				}

				l_beginTime = GetTickCountRVC();
				eErr = m_hDevHelper->ReleaseIC();
				l_endTime = GetTickCountRVC();

				if (eErr != Error_Succeed) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CheckCardType::ReleaseIC err");
					SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "CheckCardType::ReleaseIC err");
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("CheckCardType::ReleaseIC");
				}
			}
			else {
				//判断是否支持非接
				if (!IfUseRf()) {
					m_bUseRFTillNext = false;//无非接
					if (bReadMag) {
						ICtype = 2;
					}
					else {
						ICtype = 0;
						//既没有读到磁条，又不是IC，很大概率是插反了
						LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<CheckCardType>, 既没读到磁条，又没检测到IC，可能插反了");
					}
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<CheckCardType>, begin useRF detect cardType");
					m_bUseRFTillNext = true;//使用非接

					l_beginTime = GetTickCountRVC();
					eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
					l_endTime = GetTickCountRVC();

					if (eErr != Error_Succeed)
					{
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CheckCardType::MoveCard err");
						SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "CheckCardType::MoveCard err");
					}
					else {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("CheckCardType::MoveCard, (CI_MOVECARD_RF_POSITION)");
					}

					icRetryTimes = 0;
					bool bICRF(false);
					while (1)
					{//for poor mag only card,we always retry...
						l_beginTime = GetTickCountRVC();
						bICRF = m_pCardProcess->DetectIfICCard(CARD_MACHINE_ISSUER_RF, m_hDevHelper, activeCardType);
						l_endTime = GetTickCountRVC();
						if (!bICRF)
							icRetryTimes++;
						else
							break;
						Sleep(500);
						if (icRetryTimes >= m_ICRetryTimes)
							break;
					}
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<CheckCardType::DetectIfICCard_RF>, bIC:%d", bICRF);
					if (!bICRF) {
						ErrorCodeEnum eErrCode = Error_Unexpect;
						CSimpleStringA ApiName = "";
						CSimpleStringA alarmMsg = "";
						CSimpleStringA csErrMsgWithReturnCode = "";
						GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setResultCode("RTA23C6")(csErrMsgWithReturnCode.GetData());
						LogWarn(Severity_Middle, Error_Unexpect, 0x20300017, alarmMsg.GetData());
					}

					if (!(bICRF && activeCardType == 'A')) {
						bICRF = false;
					}

					if (bICRF) {
						if (bReadMag) {
							ICtype = 1;
						}
						else {
							ICtype = 3;
							LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_MaybeIC_Only, "<CheckCardType>, maybe IC only.");
						}
						//释放资源
						l_beginTime = GetTickCountRVC();
						eErr = m_hDevHelper->DeactContactlessICCard();
						l_endTime = GetTickCountRVC();

						if (eErr != Error_Succeed) {
							DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CheckCardType::DeactContactlessICCard err");
							SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "CheckCardType::DeactContactlessICCard err");
						}
						else {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("ReadCard_RF::DeactContactlessICCard");
						}
					}
					else {
						if (bReadMag) {
							ICtype = 2;
						}
						else {
							ICtype = 0;
							//既没有读到磁条，又不是IC，很大概率是插反了
							LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_Maybe_InsertCard_InWrongStyle, "<CheckCardType>, 既没读到磁条，又没检测到IC，可能插反了");
						}
					}
				}

			}
		}
	}

	CSimpleStringA cardType = CSimpleStringA::Format("cardType:%d", ICtype);
	//LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_CardType, cardType.GetData());
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(cardType.GetData());
	return 0;
}

int CCardIssuerFSM::PreOnlineJS_Contact(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx, bool& bICOK, bool& bContinue)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PreOnlineJS_Contact) IC接触读卡");
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("PreOnlineJS_Contact, aid[%s], business data[%s]", ctx->Req.aid.GetData(), ctx->Req.businessData.GetData());

	m_pCardProcess->DataInit();
	//数据已读出，开始pmoc流程
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());
	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)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, the front BusinessData have not provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, the aid from business is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);

	if (retDetectAndRead < 0)
	{
		ErrorCodeEnum eErrCode = Error_Unexpect;
		CSimpleStringA ApiName = "";
		CSimpleStringA alarmMsg = "";
		CSimpleStringA csErrMsgWithReturnCode = "";

		if (IfUseRf()) {
			bContinue = true; //继续后面的非接流程
			if (retDetectAndRead == -1) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("检测卡片类型时上电失败");
				GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);

				if (m_issueStatus) {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
				}
				else {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
				}
			}
			else if (retDetectAndRead == -2) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220320", "读取IC数据失败");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220303", "读取IC数据失败");
				}
			}
			else if (retDetectAndRead == -3) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
				if (m_issueStatus) {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220320", "retDetectAndRead = -3");
				}
				else {
					SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220303", "retDetectAndRead = -3");
				}
			}
		}
		else {
			if (retDetectAndRead == -1) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("检测卡片类型时上电失败");
				GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);

				if (m_issueStatus) {
					if (IsInBusiness()) {
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
						LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed, alarmMsg.GetData());
					}
					else {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA230V")(csErrMsgWithReturnCode.GetData());
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed, alarmMsg.GetData());
					}
					ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveICCard_Failed);
				}
				else {
					if (IsInBusiness()) {
						DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
						LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed, alarmMsg.GetData());
					}
					else {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA230M")(csErrMsgWithReturnCode.GetData());
						LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed, alarmMsg.GetData());
					}
					ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_ActiveICCard_Failed);
				}
			}
			else if (retDetectAndRead == -2) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
				DWORD dwTmpUserErrCode = 0;
				if (m_issueStatus) {
					dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "读取IC数据失败");
				}
				else {
					dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "读取IC数据失败");
				}
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			}
			else if (retDetectAndRead == -3) {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
				DWORD dwTmpUserErrCode = 0;
				if (m_issueStatus) {
					dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "retDetectAndRead =-3");
				}
				else {
					dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ICCommand, "DevAdapter::ICCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "retDetectAndRead =-3");
				}
				ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
			}
		}
		bICOK = false;
		return 0;//上电读卡失败
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, 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;

	if (ctx->Ans.result.GetLength() == 0)
	{
		if (IfUseRf()) {
			bContinue = true; //继续后面的非接流程
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>，TermActionAnalyze result len = 0");
			ctx->Ans.icState = 0;
			ctx->Answer(Error_Succeed);
		}
		return 0;
	}

	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 track2(false, 0x57, 0x00), ICCardSerial(false, 0x5f, 0x34), appExpiryDate(false, 0x5f, 0x24);
	ErrorCodeEnum eErr = Error_Unexpect;
	string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType("0"), t2ICExpireDate("");

	char* pExpireDate = new char[12];//获取ic有效期
	ZeroMemory(pExpireDate, 12);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, appExpiryDate, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_Contact>, can't find expire date");
		if (IfUseRf()) {
			bContinue = true; //继续后面的非接流程
			delete[] pExpireDate;
			return 0;
		}
	}
	else {
		HexBuf2StrBuf(appExpiryDate.value, &pExpireDate, appExpiryDate.lenth);
		t2ICExpireDate = pExpireDate;
	}
	delete[] pExpireDate;


	char* pICCardSerial = new char[4];//获取ic序号
	ZeroMemory(pICCardSerial, 4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, ICCardSerial, false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_Contact>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
		t2ICCardSerial = pICCardSerial;
	}
	delete[] pICCardSerial;


	char* pICTrack2 = new char[128];//获取等效磁条2
	ZeroMemory(pICTrack2, 128);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineCrossJS_Contact>, ic no track2 data");
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();
		if (eErr != Error_Succeed) {
			SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("PreOnlineJS_Contact::ReleaseIC");
		}
	}
	else
	{
		HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
		t2ICTrack2 = pICTrack2;

		int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
		pICTrack2[37] = '\0';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, ic.track2, split 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;
		}
		else {
			LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_Split_ICTrack2_Failed, CSimpleStringA::Format("<PreOnlineJS_Contact> SplitTrack2 fail,ic pTrack2.len:%d", strlen(icTrack2Data)));
		}
		if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)))
		{
			t2ICAccount = (char*)ddd;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str());
		}
		delete[]ddd;
	}
	delete[]pICTrack2;

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		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;

	//json格式返回
	std::map<std::string, std::string> msgInfo;
	msgInfo["ACTION"] = actionType.c_str();
	msgInfo["ATC_CODE"] = tmpResult.substr(6, 4).c_str();
	msgInfo["ARQC_CODE"] = tmpResult.substr(10, 16).c_str();
	msgInfo["MAC"] = tmpResult.substr(26, tmpResult.length() - 26 - 4).c_str();
	CSimpleStringA arqcLenStr = arqcLen;
	msgInfo["ARQC_SIZE"] = arqcLenStr.GetData();
	CSimpleStringA arqcData = m_pDataToARQC;
	msgInfo["ARQC_DATA"] = arqcData.GetData();
	msgInfo["T2TRACK2_DATA"] = t2ICTrack2.c_str();
	msgInfo["EXPIRE_DATE"] = t2ICExpireDate.c_str();
	msgInfo["T2CARD_SERIAL"] = t2ICCardSerial.c_str();
	msgInfo["CARD_CAT"] = cardType.c_str();
	msgInfo["IC_TAGS"] = baseICData.c_str();

	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(msgInfo);
	result = strResult.second.c_str();

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("data to host result=%s,len=%d", result.c_str(), result.length());

	string 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 + "|"
		+ "T2TRACK2(len)," + CSimpleStringA::Format("%d", t2ICTrack2.length()).GetData() + "|"
		+ "EXPIREDATE(len)," + CSimpleStringA::Format("%d", t2ICExpireDate.length()).GetData() + "|"
		+ "T2CARDSERIAL(len), " + CSimpleStringA::Format("%d", t2ICCardSerial.length()).GetData() + "|"
		+ "CARDCAT, " + cardType + "|"
		+ "ICTAGS, " + CSimpleStringA::Format("%d", baseICData.length()).GetData();

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, data to host(less)[%s]", txtresult.c_str());

	m_currCardNo = t2ICAccount.c_str();
	//LogWarn(Severity_Low, Error_Unexpect, CardIssuerStore_UserErrorCode_CardBin, cardInfo.GetData());

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

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

	ctx->Ans.result = result.c_str();
	ctx->Ans.icState = 1;//成功
	bICOK = true;
	bContinue = false;
	ctx->Answer(Error_Succeed);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	return 0;//不再继续后面的非接流程
}

int CCardIssuerFSM::PreOnlineJS_RF(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(PreOnlineJS_RF) IC非接读卡");
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum eErr = m_hDevHelper->MoveCard(CI_MOVECARD_RF_POSITION);
	l_endTime = GetTickCountRVC();
	if (eErr == Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::MoveCard").setCostTime(l_endTime - l_beginTime)("PreOnlineJS_RF::MoveCard, (CI_MOVECARD_RF_POSITION)");
	}
	else {
		SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_MoveCard, "DevAdapter::MoveCard", __FUNCTION__, false, l_endTime - l_beginTime, "QLR040220340", "PreOnlineJS_RF::MoveCard err");
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("PreOnlineJS_RF, aid[%s], business data[%s]", ctx->Req.aid.GetData(), ctx->Req.businessData.GetData());

	m_pCardProcess->DataInit();
	//数据已读出，开始pmoc流程
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());
	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)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, the front BusinessData have not provide aid data.");
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, m_aidList, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, the aid from business is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		int icRetryTimes = 0;
		while (1)
		{
			l_beginTime = GetTickCountRVC();
			retDetectAndRead = m_pCardProcess->DetectAndReadICData(CARD_MACHINE_ISSUER_RF, m_hDevHelper, preAIDs, activeCardType, m_issueStatus);
			l_endTime = GetTickCountRVC();
			if (retDetectAndRead == -1)//only retry for active ic card failed!
				icRetryTimes++;
			else
				break;
			Sleep(500);
			if (icRetryTimes >= m_ICRetryTimes)
				break;
		}
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, After invoke DetectAndReadICData, retDetectAndRead:%d, activeCardType:%d", retDetectAndRead, activeCardType);

	if (retDetectAndRead < 0)
	{
		ErrorCodeEnum eErrCode = Error_Unexpect;
		CSimpleStringA ApiName = "";
		CSimpleStringA alarmMsg = "";
		CSimpleStringA csErrMsgWithReturnCode = "";

		if (retDetectAndRead == -1) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("检测卡片类型时上电失败（非接）");
			GetCardProcessLastErr(eErrCode, ApiName, alarmMsg, csErrMsgWithReturnCode);

			if (m_issueStatus) {
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA2327")(csErrMsgWithReturnCode.GetData());
					LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed, alarmMsg.GetData());
				}
				else {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220320").setResultCode("RTA2327")(csErrMsgWithReturnCode.GetData());
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed, alarmMsg.GetData());
				}

				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_IssueCard_ActiveRF_Failed);
			}
			else {
				if (IsInBusiness())
				{
					DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA2326")(csErrMsgWithReturnCode.GetData());
					LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed, alarmMsg.GetData());
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(ApiName.GetData()).setCostTime(l_endTime - l_beginTime).setLogCode("QLR040220303").setResultCode("RTA2326")(csErrMsgWithReturnCode.GetData());
					LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed, alarmMsg.GetData());
				}

				ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_ActiveContactlessICCard_Failed);
			}
		}
		else if (retDetectAndRead == -2) {

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读取IC数据失败");
			DWORD dwTmpUserErrCode = 0;
			if (m_issueStatus) {
				dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "读取IC数据失败");
			}
			else {
				dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "读取IC数据失败");
			}
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
		else if (retDetectAndRead == -3) {

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("IC卡建立应用列表失败");
			DWORD dwTmpUserErrCode = 0;
			if (m_issueStatus) {
				dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220320", "retDetectAndRead=-3");
			}
			else {
				dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_RFTypeABCommand, "DevAdapter::RFTypeABCommand", __FUNCTION__, IsInBusiness(), l_endTime - l_beginTime, "QLR040220303", "retDetectAndRead=-3");
			}
			ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		}
		return 0;//上电读卡失败
	}

	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(CARD_MACHINE_ISSUER_RF, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	if (retTAA != 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>, 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;

	if (ctx->Ans.result.GetLength() == 0)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("<PreOnlineJS_RF>，TermActionAnalyze result len = 0");
		ctx->Ans.icState = 0;
		ctx->Answer(Error_Succeed);
		return 0;
	}

	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 track2(false, 0x57, 0x00), ICCardSerial(false, 0x5f, 0x34), appExpiryDate(false, 0x5f, 0x24);
	string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType("0"), t2ICExpireDate("");

	char* pExpireDate = new char[12];//获取ic有效期
	ZeroMemory(pExpireDate, 12);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, appExpiryDate, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_RF>, can't find expire date");
	}
	else {
		HexBuf2StrBuf(appExpiryDate.value, &pExpireDate, appExpiryDate.lenth);
		t2ICExpireDate = pExpireDate;
	}
	delete[] pExpireDate;


	char* pICCardSerial = new char[4];//获取ic序号
	ZeroMemory(pICCardSerial, 4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, ICCardSerial, false) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_RF>, can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
		t2ICCardSerial = pICCardSerial;
	}
	delete[] pICCardSerial;



	char* pICTrack2 = new char[128];//获取等效磁条2
	ZeroMemory(pICTrack2, 128);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA23E1")("<PreOnlineJS_RF>, ic no track2 data");
	}
	else
	{
		HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
		t2ICTrack2 = pICTrack2;

		int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
		pICTrack2[37] = '\0';
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("<PreOnlineJS_RF>, ic.track2, split 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;
		}
		else {
			LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_Split_ICTrack2_Failed, CSimpleStringA::Format("<PreOnlineJS_RF> SplitTrack2 fail,ic pTrack2.len:%d", strlen(icTrack2Data)));
		}
		if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)))
		{
			t2ICAccount = (char*)ddd;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("count:%s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str());
		}
		delete[]ddd;
	}
	delete[]pICTrack2;

	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1) {
		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;

	//json格式返回
	std::map<std::string, std::string> msgInfo;
	msgInfo["ACTION"] = actionType.c_str();
	msgInfo["ATC_CODE"] = tmpResult.substr(6, 4).c_str();
	msgInfo["ARQC_CODE"] = tmpResult.substr(10, 16).c_str();
	msgInfo["MAC"] = tmpResult.substr(26, tmpResult.length() - 26 - 4).c_str();
	CSimpleStringA arqcLenStr = arqcLen;
	msgInfo["ARQC_SIZE"] = arqcLenStr.GetData();
	CSimpleStringA arqcData = m_pDataToARQC;
	msgInfo["ARQC_DATA"] = arqcData.GetData();
	msgInfo["T2TRACK2_DATA"] = t2ICTrack2.c_str();
	msgInfo["EXPIRE_DATE"] = t2ICExpireDate.c_str();
	msgInfo["T2CARD_SERIAL"] = t2ICCardSerial.c_str();
	msgInfo["CARD_CAT"] = cardType.c_str();
	msgInfo["IC_TAGS"] = baseICData.c_str();

	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(msgInfo);
	result = strResult.second.c_str();

	//DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("data to host result=%s,len=%d", result.c_str(), result.length());

	string 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 + "|"
		+ "T2TRACK2(len)," + CSimpleStringA::Format("%d", t2ICTrack2.length()).GetData() + "|"
		+ "EXPIREDATE(len)," + CSimpleStringA::Format("%d", t2ICExpireDate.length()).GetData() + "|"
		+ "T2CARDSERIAL(len), " + CSimpleStringA::Format("%d", t2ICCardSerial.length()).GetData() + "|"
		+ "CARDCAT, " + cardType + "|"
		+ "ICTAGS, " + CSimpleStringA::Format("%d", baseICData.length()).GetData();

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("<PreOnlineJS_Contact>, data to host(less)[%s]", txtresult.c_str());

	m_currCardNo = t2ICAccount.c_str();

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

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

	ctx->Ans.result = result.c_str();
	ctx->Ans.icState = 1;//成功
	ctx->Answer(Error_Succeed);
	LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_ReadByRF, CSimpleStringA::Format("PreOnline_RF ok.iIssue:%d ", m_issueStatus));
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220306")();
	return 0;
}

int CCardIssuerFSM::ReadJS(SpReqAnsContext<CardIssuerStandService_ReadJS_Req, CardIssuerStandService_ReadJS_Ans>::Pointer ctx)
{
	//判断是否有卡，无卡则报错
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("读卡开始");
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCountRVC();
	ErrorCodeEnum errCode = m_hDevHelper->GetDevStatus(m_devStatus);
	l_endTime = GetTickCountRVC();

	if (Error_Succeed == errCode)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevStatus").setCostTime(l_endTime - l_beginTime)("ReadJS::GetDevStatus, m_devStatus.eMedia:%d", m_devStatus.eMedia);
		if (m_devStatus.eMedia != CI_MEDIA_PRESENT) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReadJS read fail , has no card.");
			ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Read_NoCard_Failed);//无卡
			return 1;//跳转到无卡状态？
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ReadJS::GetDevStatus err");
		DWORD dwTmpUserErrCode = SetErrorAndLog(errCode, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, l_endTime - l_beginTime, "", "ReadJS::GetDevStatus err");
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
		return 0;
	}

	//有卡读磁,返回读磁操作和磁条解析结果。
	bool bReadCardInfo(false), bReadMag(false);
	CSimpleStringA t2Account("");
	ReadMag(ctx, bReadCardInfo, bReadMag, t2Account);//读卡

	//判定卡片ICtype
	int ICtype = 0;//0：失败 1：复合 2：磁条 3：ic
	m_bUseRFTillNext = false;//默认初始值
	int ret = CheckCardType(t2Account, bReadMag, ICtype);

	if (ret == 0) {
		if (ICtype == 3) {
			ctx->Ans.magStatus = 0;//单IC设置磁条为空，后续进行ic上电
		}

		if (ICtype == 0) {
			ctx->Ans.magStatus = 0;
			ctx->Ans.icState = 0;
			ctx->Ans.icMode = -1;
			ctx->Ans.result = "";
			ctx->Answer(Error_Succeed);//无磁无IC直接返回
		}
		else if (ICtype == 2) {
			ctx->Ans.magStatus = 1;
			ctx->Ans.icState = 0;
			ctx->Ans.icMode = -1;
			ctx->Ans.result = "";
			ctx->Answer(Error_Succeed);//单磁条直接返回
		}
		else if (ICtype == 1 || ICtype == 3) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to PreOnline");//联机上电
			ctx->Ans.icState = 0;//默认值
			ctx->Ans.icMode = -1;//默认值
			if (m_bUseRFTillNext) {
				ctx->Ans.icMode = 1;
				PreOnlineJS_RF(ctx);
				PowerOffIC(1);
			}
			else {
				//先接触上电，有条件进行非接上电
				bool bCtOK = false;
				bool bContinue = false;//是否继续非接流程
				ctx->Ans.icMode = 0;
				PreOnlineJS_Contact(ctx, bCtOK, bContinue);
				PowerOffIC(0);
				if (bContinue) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PreOnlineJS_Contact 用非接兜底");
					ctx->Ans.icMode = 1;
					PreOnlineJS_RF(ctx);
					PowerOffIC(1);
				}
			}
		}
		return 0;
	}
	else {
		ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Account_EAC_Mismatch);//账户和户口系统的最新账户不匹配
		return 0;
	}
}

int CCardIssuerFSM::InsertJS(SpReqAnsContext<CardIssuerStandService_InsertJS_Req, CardIssuerStandService_InsertJS_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;//是否还继续使用
	//查询插卡前卡机是否有卡
	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr = Error_Unexpect;
	l_beginTime = GetTickCountRVC();
	eErr = m_hDevHelper->GetDevStatus(m_devStatus);
	l_endTime = GetTickCountRVC();
	if (Error_Succeed == eErr) {
		if (m_devStatus.eMedia == CI_MEDIA_PRESENT) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertJS::InternalInsert,internal has card before insert");
			ctx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_Insert_Card_HasCard_Failed);
			return 5;
		}
	}
	else {
		DWORD dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, 10, "QLR040220303", "");
		return 1;
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
	}
	//等待插卡
	int rc = InternalInsert();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("InsertJS::InternalInsert, result:%d", rc));
	LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_GREEN_OFF, "CardReader warning off");
	if (rc == 0) {
		FSMSetIssueFlag(0);
		m_bCardFromHopper = false;
		//LogWarn(Severity_Low, Error_Succeed, CardIssuer_UserErrorCode_InsertCardSucceed, "InsertJS, insert succeed");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertJS, insert succeed");
		m_bUseRFTillNext = false;
		ctx->Answer(Error_Succeed);
	}
	else if (rc == 2)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertJS, insert timeout");
		ctx->Answer(Error_TimeOut,CardIssuer_UserErrorCode_Insert_Card_TimeOut);
	}
	else if (rc == 3 || rc == 4)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InsertJS, insert cancel");
		ctx->Answer(Error_Cancel, CardIssuer_UserErrorCode_Insert_Card_Cancel);
	}
	else
	{
		DWORD dwTmpUserErrCode = SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_CARDISSUER_GetDevStatus, "DevAdapter::GetDevStatus", __FUNCTION__, false, 10, "QLR040220303", "");
		ctx->Answer(Error_Unexpect, dwTmpUserErrCode);
	}
	return rc;
}

int CCardIssuerFSM::InternalInsert()
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr = Error_Unexpect;
	int acceptTries = 0, errRet = 0;//0成功，1查询状态失败 2超时 3取消 4取消有卡
	//m_bWaitingAccept = true;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("InternalInsert, m_bExit:%d, m_bCancelInsert:%d, m_bWaitAccepteMore:%d",m_bExit, m_bCancelInsert, m_bWaitAccepteMore));
	bool bHasSetCardInType = false;
	DWORD64 dwStart = GetTickCountRVC();
	DWORD64 dwEnd = dwStart;

	errRet = 2;//默认是超时
	do {
		if (m_bExit)
		{	//页面退到首页
			m_bCancelInsert = true;
			errRet = 3;
			break;
		}
		if (m_bCancelInsert)
		{	//取消插卡
			errRet = 3;
			break;
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->GetDevStatus(m_devStatus);
		l_endTime = GetTickCountRVC();

		if (Error_Succeed == eErr)
		{
			//成功
			if (m_devStatus.eMedia == CI_MEDIA_PRESENT)
			{
				LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuerStand op.");
				errRet = 0;
				break;//插卡成功
			}
			else if (m_devStatus.eMedia == CI_MEDIA_NOTPRESENT)
			{
				//无卡
				Sleep(ACCEPT_TRY_INTERVAL);
				//打开进口
				if (!m_bCancelInsert) {
					if (!bHasSetCardInType) {
						l_beginTime = GetTickCountRVC();
						eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_ALL);
						l_endTime = GetTickCountRVC();
						if (Error_Succeed == eErr) {
							bHasSetCardInType = true;
						}
						else {
							DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalInsert::SetCardInType CI_CARD_IN_TYPE_ALL err");
							SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalInsert::SetCardInType CI_CARD_IN_TYPE_ALL err");
						}
					}	
				}

			}
		}
		else
		{
			//失败
			Sleep(ACCEPT_TRY_INTERVAL*3);
			errRet = 1;
			break;//查询硬件状态失败。???要退吗
		}

		dwEnd = GetTickCountRVC();
	} while ((dwEnd - dwStart) < 58 * 1000);

	m_bExit = false;

	if (errRet == 0 || errRet ==1) {
		//关闭进口
		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
		l_endTime = GetTickCountRVC();
		if (Error_Succeed != eErr)
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN");
		}
	}
	else {
		//2和3情况
		if (m_bCancelInsert) {
			//判定是否有卡，有卡则走吐卡流程
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->GetDevStatus(m_devStatus);
			l_endTime = GetTickCountRVC();
			if (Error_Succeed == eErr) {
				if (m_devStatus.eMedia == CI_MEDIA_PRESENT) {
					errRet = 4;//取消时有卡
				}
				else {
					errRet = 3;//取消无卡
				}
			}
			else {
				errRet = 1;//查询硬件状态失败。???要退吗
			}
		}
		else {
			errRet = 2;//正常超时
		}

		if (errRet != 4) {
			//关闭进口
			l_beginTime = GetTickCountRVC();
			eErr = m_hDevHelper->SetCardInType(CI_CARD_IN_TYPE_FORBIDDEN);
			l_endTime = GetTickCountRVC();
			if (Error_Succeed != eErr)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
				SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_SetCardInType, "DevAdapter::SetCardInType", __FUNCTION__, false, l_endTime - l_beginTime, "", "InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN err");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetCardInType").setCostTime(l_endTime - l_beginTime)("InternalInsert::SetCardInType CI_CARD_IN_TYPE_FORBIDDEN");
			}
		}
	}
	return errRet;
}



DWORD CCardIssuerFSM::GetFsmStateErrCode()
{
	int state = GetFSMState();
	switch (state)
	{
	case 2:
		return CardIssuer_UserErrorCode_PROCESS_IDLE;
	case 3:
		return CardIssuer_UserErrorCode_PROCESS_ACCEPT;
	case 4:
		return CardIssuer_UserErrorCode_PROCESS_HOLD;
	case 5:
	case 15:
		return CardIssuer_UserErrorCode_PROCESS_READ;
	case 6:
		return CardIssuer_UserErrorCode_PROCESS_EJECT;
	case 7:
		return CardIssuer_UserErrorCode_PROCESS_WAIT_FETCH;
	case 8:
		return CardIssuer_UserErrorCode_PROCESS_CAPTURE;
	case 9:
		return CardIssuer_UserErrorCode_PROCESS_FAULT;
	case 10:
	case 16:
		return CardIssuer_UserErrorCode_PROCESS_ISSUE;
	default:
		return CardIssuer_UserErrorCode_EntityInStateCannotProcess;
	}
}

CSimpleStringA CCardIssuerFSM::MaskCardno(const char* cardno)
{
	CSimpleStringA maskCardno = "";

	if (cardno == NULL) {
		maskCardno = "(null)****(null)";
	}
	else {
		CSimpleStringA xTestStr(cardno);
		if (xTestStr.GetLength() == 0) {
			maskCardno = "(null)****(null)";
		}
		else if (xTestStr.GetLength() > 6) {
			maskCardno = CSimpleStringA::Format("%s****%s", xTestStr.SubString(0, 6).GetData(), xTestStr.SubString(xTestStr.GetLength() - 4, 4).GetData());
		}
		else {
			maskCardno = CSimpleStringA::Format("%s****", xTestStr.GetData());
		}
	}

	return maskCardno;
}

void CCardIssuerFSM::GetCardProcessLastErr(ErrorCodeEnum& eErrCode, CSimpleStringA& ApiName, CSimpleStringA& alarmMsg, CSimpleStringA& csErrMsgWithReturnCode)
{
	if (m_pCardProcess == NULL) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetCardProcessLastErr m_pCardProcess is null");
		eErrCode = Error_Null;
		ApiName = "";
		alarmMsg = "";
		csErrMsgWithReturnCode = "";
		return;
	}

	ErrorCodeEnum lastErrCode = Error_Succeed;
	CSimpleStringA lastErrMsg = "";
	CSimpleStringA lastApiName = "";
	m_pCardProcess->getCardAssistLastErr(lastErrCode, lastErrMsg, lastApiName);

	const CSimpleStringA alarmMsgStr = CSimpleStringA::Format("{\"Function\":\"%s\", \"DevApi\":\"%s\", \"ReturnCode\":\"%s\", \"Msg\":\"%s\", \"Context\":\"%s\"}"
		, __FUNCTION__, lastApiName.GetData(), SpStrError(lastErrCode), lastErrMsg.GetData(), "");

	std::map<std::string, std::string> msgInfo;
	msgInfo["ReturnCode"] = SpStrError(lastErrCode);
	msgInfo["ErrMsg"] = lastErrMsg.GetData();
	msgInfo["Context"] = "";
	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(msgInfo);
	CSimpleStringA csErrMsgWithReturnCodeStr = strResult.second.c_str();

	eErrCode = lastErrCode;
	ApiName = lastApiName;
	alarmMsg = alarmMsgStr.GetData();
	csErrMsgWithReturnCode = csErrMsgWithReturnCodeStr.GetData();
}

int CCardIssuerFSM::QuickSelfCheckImpl()
{
	//通知健康快速自检
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI("QuickSelfCheckImpl")("快速自检开始");
	int ret = 0;//失败
	ErrorCodeEnum eErr = Error_Unexpect;
	HealthManager::HealthManagerService_ClientBase* pClient = new HealthManager::HealthManagerService_ClientBase(GetEntityBase());
	eErr = pClient->Connect();
	if (eErr == Error_Succeed)
	{
		HealthManager::HealthManagerService_RealCheck_Req req1 = {};
		HealthManager::HealthManagerService_RealCheck_Ans ans1 = {};
		req1.name = "CardIssuerStand";
		if (Error_Succeed == (*pClient)(EntityResource::getLink().upgradeLink())->RealCheck(req1, ans1, 10000))
		{
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI("QuickSelfCheckImpl")("RealCheck success");
			ret = 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("QuickSelfCheckImpl")("RealCheck fail");
			ret = 0;
		}
		pClient->GetFunction()->CloseSession();
		//pClient->SafeDelete();
		return ret;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("QuickSelfCheckImpl")("connect to HealthManager fail,err=%d", (int)eErr);
		pClient->SafeDelete();
		return ret;
	}
}

int CCardIssuerFSM::PowerOffIC(int type)
{
	int ret = 0;
	long l_beginTime, l_endTime;
	if (type == 0) {
		l_beginTime = GetTickCountRVC();
		ErrorCodeEnum eErr = m_hDevHelper->DeactivateICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactivateICCard, "DevAdapter::DeactivateICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "PowerOffIC::DeactivateICCard err");
			ret = 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactivateICCard").setCostTime(l_endTime - l_beginTime)("PowerOffIC::DeactivateICCard");
		}

		l_beginTime = GetTickCountRVC();
		eErr = m_hDevHelper->ReleaseIC();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_ReleaseIC, "DevAdapter::ReleaseIC", __FUNCTION__, false, l_endTime - l_beginTime, "", "PowerOffIC::ReleaseIC err");
			ret = 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::ReleaseIC").setCostTime(l_endTime - l_beginTime)("PowerOffIC::ReleaseIC");
		}

	}
	else {
		l_beginTime = GetTickCountRVC();
		ErrorCodeEnum eErr = m_hDevHelper->DeactContactlessICCard();
		l_endTime = GetTickCountRVC();

		if (eErr != Error_Succeed) {
			SetErrorAndLog(eErr, MEC_DEVAPI_CARDISSUER_DeactContactlessICCard, "DevAdapter::DeactContactlessICCard", __FUNCTION__, false, l_endTime - l_beginTime, "", "");
			ret = 1;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DeactContactlessICCard").setCostTime(l_endTime - l_beginTime)("PowerOffIC::DeactContactlessICCard");
		}
	}
	return ret;
}

void CCardIssuerFSM::OnStateTrans(int iSrcState, int iDstState)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("trans from %s to %s", GetStateName(iSrcState), GetStateName(iDstState));
}