myvtm/Module/mod_CardReadAdapter/CardReadAdapterFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "CardReadAdapterFSM.h"
#include "EventCode.h"
#include <algorithm>
#include <map>
using namespace std;
//CSimpleStringA<T> ambigulous
#define _ATL_NO_AUTOMATIC_NAMESPACE
//#include <atltime.h>
#define ReadCard_TIMEOUT	62000	//web的超时时间是65s
#define ReadCard_Min_Time	12000	//Read+PreOnline 
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
}
class CCardReadAdapterEntity;
void CCardReadAdapterFSM::s0_on_entry()
{
	LOG_FUNCTION();
	CSystemStaticInfo sysInfo;

	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();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machineType:%s,terminalNo:%s,machineVersion:%d.%d", (const char*)m_csMachineType, (const char*)m_terminalNo
	, m_majorVerion, m_minorVerion);

	///**TODO(Gifur@8/17/2023): 覆盖其他需要字段 */
	const auto terminInfo = SP::Module::Comm::GetTerminalMachineInfo(GetEntityBase());
	m_eMachineType = terminInfo.type;

	FSMEvent *pEvt;

	pEvt = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(pEvt);
}

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

unsigned int CCardReadAdapterFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s0 evt %d", pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT:
	{
		InitTask* task = new InitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
						  pEvt->SetHandled();
						  return 0;
	}
		break;
	default:
		break;
	}
	return 0;
}
//Initializing
void CCardReadAdapterFSM::s1_on_entry()
{
	LOG_FUNCTION();
}
void CCardReadAdapterFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardReadAdapterFSM::s1_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s1 evt %d", pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	case USER_EVT_INIT_FINISHED:
		pEvt->SetHandled();
		return pEvt->param1;
	default:
		break;
	}
	return 0;
}
//Idle
void CCardReadAdapterFSM::s2_on_entry()
{
	LOG_FUNCTION();
	//GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_IDLE);
	m_resetTimes = 0;
	m_testResult = Error_Succeed;
	m_bIssuingExit = false;
	m_bCancelAccept = false;
	m_lastS2Event = m_lastS2EvtParam1 = 0;
	m_busCtx.eCardProcStage = Card_ProcStage_Idle;
}
void CCardReadAdapterFSM::s2_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardReadAdapterFSM::s2_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s2 evt(%d),param1:%d", pEvt->iEvt,pEvt->param1);
	m_lastS2Event = pEvt->iEvt;
	m_lastS2EvtParam1 = pEvt->param1;
	int ret = 0;
	switch (pEvt->iEvt)
	{
		case USER_EVT_READ:
		{
			//oilyang@20200426 according to MachineType ***AND MachineVersion*** to decide which Card-like entity to be called
			//RVC.Stand2S, RVC.CardStore
			//	ContactlessCard:
			//		--RVC.Stand2S
			//	CardIssuerStand or CardIssuerStore:
			//		--no matter what MachineType is,just call it 
			pEvt->SetHandled();
			CardReadEvent* cre = dynamic_cast<CardReadEvent*>(pEvt);
			bool bCardIssuer, bContactlessCard;
			bCardIssuer = bContactlessCard = false;
			if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
			{
				ContactlessCardReadTask* cTask = new ContactlessCardReadTask(this);
				cTask->ctx = cre->ctx;
				if (IsTheEntity(cre->ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK())
				{
					bContactlessCard = true;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(cTask);
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_USER)("ReadTask to ContactlessCard");
				}
			}
			//oilyang@20200426 暂时未发现这行代码的用处，可能简版？后来废弃。暂时保留，后续考虑去掉
			if ((cre->ctx->Req.reserved1.GetCount() == 0 || cre->ctx->Req.reserved1[0] != 1))//except for cross call
			{
				CardIssuerReadTask* iTask = new CardIssuerReadTask(this);
				iTask->ctx = cre->ctx;
				if (IsTheEntity(cre->ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK())
				{
					bCardIssuer = true;
					GetEntityBase()->GetFunction()->PostThreadPoolTask(iTask);
				}
				if (bCardIssuer || bContactlessCard)
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("ReadTask, bCardIssuer,bContactlessCard:%d,%d", bCardIssuer, bContactlessCard);
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("ReadTask: can't find the right entity.");
					ret = 1;//no need to change to "Working" state
					cre->ctx->Answer(Error_Unexpect);
				}
			}
		}
			break;
	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_WRITE:
	{
		pEvt->SetHandled();
		CardWriteEvent* cwe = dynamic_cast<CardWriteEvent*>(pEvt);
		WriteTask* task = new WriteTask(this);
		task->ctx = cwe->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		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_EXIT:
	{
		m_busCtx.eCardFromWhich = Card_In_No_Where;
		pEvt->SetHandled();
		DoExitTask* task = new DoExitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_EJECT:
	{
		pEvt->SetHandled();
		CardEjectEvent* cee = dynamic_cast<CardEjectEvent*>(pEvt);
		EjectTask* task = new EjectTask(this);
		task->ctx = cee->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_SET_SOME_FLAG:
	{
		pEvt->SetHandled();
		SetSomeFlagEvent* ssfe = dynamic_cast<SetSomeFlagEvent*>(pEvt);
		SetSomeFlagTask* task = new SetSomeFlagTask(this);
		task->ctx = ssfe->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_GET_DEV_INFO:
	{
		pEvt->SetHandled();
		GetDevInfoEvent* gdie = dynamic_cast<GetDevInfoEvent*>(pEvt);
		GetDevInfoTask* task = new GetDevInfoTask(this);
		task->ctx = gdie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* qcie = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = qcie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	case USER_EVT_ISSUE:
	{
		pEvt->SetHandled();
		CardIssueEvent* cee = dynamic_cast<CardIssueEvent*>(pEvt);
		IssueTask* task = new IssueTask(this);
		task->ctx = cee->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_CAPTURE:
	{
		pEvt->SetHandled();
		CardCaptureEvent* cee = dynamic_cast<CardCaptureEvent*>(pEvt);
		CaptureTask* task = new CaptureTask(this);
		task->ctx = cee->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_GET_MATERIAL:
	{
		pEvt->SetHandled();
		GetMaterialEvent *gme = dynamic_cast<GetMaterialEvent*>(pEvt);
		GetMaterialCountTask *task = new GetMaterialCountTask(this);
		task->ctx = gme->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		break;
	}
	case USER_EVT_SET_MATERIAL:
	{
		pEvt->SetHandled();
		SetMaterialEvent *sme = dynamic_cast<SetMaterialEvent*>(pEvt);
		SetMaterialCountTask *task = new SetMaterialCountTask(this);
		task->ctx = sme->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		break;
	}
	case USER_EVT_GET_SCI_INFO:
	{
		pEvt->SetHandled();
		GetSCIInfoEvent* gsie = dynamic_cast<GetSCIInfoEvent*>(pEvt);
		GetSCIInfoTask* task = new GetSCIInfoTask(this);
		task->ctx = gsie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_OPEN_SAFELOCK:
	{
		pEvt->SetHandled();
		OpenSafeLockEvent *osle = dynamic_cast<OpenSafeLockEvent*>(pEvt);
		OpenSafeLockTask* task = new OpenSafeLockTask(this);
		task->ctx = osle->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_MAGTRANS_INIT:
	{
		pEvt->SetHandled();
		MagTransferInitEvent* mtie = dynamic_cast<MagTransferInitEvent*>(pEvt);
		MagTransferInitTask* task = new MagTransferInitTask(this);
		task->ctx = mtie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_CONN_INFO:
	{
		pEvt->SetHandled();
		QueryConnInfoEvent* qcie = dynamic_cast<QueryConnInfoEvent*>(pEvt);
		QueryConnInfoTask* task = new QueryConnInfoTask(this);
		task->ctx = qcie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_SAM_IC_COMMAND:
	{
		pEvt->SetHandled();
		SAMICCommandEvent* samice = dynamic_cast<SAMICCommandEvent*>(pEvt);
		SAMICCommandTask* task = new SAMICCommandTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_PRINTER_STATUS:
	{
		pEvt->SetHandled();
		QueryPrinterStatusEvent* samice = dynamic_cast<QueryPrinterStatusEvent*>(pEvt);
		QueryPrinterStatusTask* task = new QueryPrinterStatusTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_PRINT:
	{
		pEvt->SetHandled();
		PrintEvent* samice = dynamic_cast<PrintEvent*>(pEvt);
		PrintTask* task = new PrintTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_SCILIST:
	{
		pEvt->SetHandled();
		QuerySCIListEvent* samice = dynamic_cast<QuerySCIListEvent*>(pEvt);
		QuerySCIListTask* task = new QuerySCIListTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_BIND_SCI:
	{
		pEvt->SetHandled();
		BindSCIEvent* samice = dynamic_cast<BindSCIEvent*>(pEvt);
		BindSCITask* task = new BindSCITask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_PREONLINE_ON_STORE:
	{
		pEvt->SetHandled();
		PreOnlineOnStoreEvent* samice = dynamic_cast<PreOnlineOnStoreEvent*>(pEvt);
		PreOnlineOnStoreTask* task = new PreOnlineOnStoreTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_GET_ADD_CARD_INFO:
	{
		pEvt->SetHandled();
		GetAddCardInfoEvent* samice = dynamic_cast<GetAddCardInfoEvent*>(pEvt);
		GetAddCardInfoTask* task = new GetAddCardInfoTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_CARD_INFO_ON_STORE:
	{
		pEvt->SetHandled();
		QueryCardInfoOnStoreEvent* samice = dynamic_cast<QueryCardInfoOnStoreEvent*>(pEvt);
		QueryCardInfoOnStoreTask* task = new QueryCardInfoOnStoreTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_CROSS_TERM_CALL:
	{
		pEvt->SetHandled();
		CrossTermCallEvent* ctce = dynamic_cast<CrossTermCallEvent*>(pEvt);
		CrossTermCallTask* task = new CrossTermCallTask(this);
		task->ctx = ctce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	case USER_EVT_PRINT_CARD_IM:
	{
		pEvt->SetHandled();
		PrintCardImEvent* pcie = dynamic_cast<PrintCardImEvent*>(pEvt);
		PrintCardImTask* task = new PrintCardImTask(this);
		task->ctx = pcie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	case USER_EVT_QUERY_CI_STATUS:
	{
		pEvt->SetHandled();
		QueryCIStatusEvent* qcse = dynamic_cast<QueryCIStatusEvent*>(pEvt);
		QueryCIStatusTask* task = new QueryCIStatusTask(this);
		task->ctx = qcse->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	default:
		break;
	}
	return ret;
}
//Working
void CCardReadAdapterFSM::s3_on_entry()
{
	LOG_FUNCTION();
}
void CCardReadAdapterFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardReadAdapterFSM::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_NOTIFY_PREONLINE:
	{
		pEvt->SetHandled();
		NotifyPreonlineEvent* samice = dynamic_cast<NotifyPreonlineEvent*>(pEvt);
		NotifyPreOnlineTask* task = new NotifyPreOnlineTask(this);
		task->ctx = samice->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	case USER_EVT_READ_FINISHED:
	{
		pEvt->SetHandled();
		ret = pEvt->param1;
		//if (pEvt->param1 == 0)
		CardReadFinishedEvent* crfe = dynamic_cast<CardReadFinishedEvent*>(pEvt);
		{
			if (m_bCancelAccept)
			{


				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("front cancel");
				crfe->ctx->Answer(Error_Cancel);
				ret = 0;
			}
		}
		if (pEvt->param1 == 7)//CardIssuerStand or CardIssuerStore Timeout,need to cancel ContactlessCard insert
		{
			if (!IsCardIssuerStore()) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand Timeout,need to cancel ContactlessCard insert");
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore Timeout,need to cancel ContactlessCard insert");
			}
			if (IsContactlessCardSessionOK())
				(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
			crfe->ctx->Answer(Error_TimeOut);
			ret = 0;
			break;
		}
		else if (pEvt->param1 == 8)//ContactlessCard Timeout,need to cancel CardIssuerStand or CardIssuerStore insert
		{
			
			if (IsCardIssuerSessionOK()) {
				if (!IsCardIssuerStore()) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ContactlessCard Timeout,need to cancel CardIssuerStand insert");
					(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
				else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ContactlessCard Timeout,need to cancel CardIssuerStore insert");
					(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
			}
				
			crfe->ctx->Answer(Error_TimeOut);
			ret = 0;
			break;
		}
		else if (pEvt->param1 == 9)//ContactlessCard Timeout,need to cancel ContactlessCard insert
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("need to cancel ContactlessCard insert");
			if (IsContactlessCardSessionOK())
				(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
			crfe->ctx->Answer(Error_TimeOut);
			ret = 0;
			break;
		}
		if (m_busCtx.eCardFromWhich == Card_In_ContactlessCard)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("as card in ContactlessCard,to cancel others");
			if (IsCardIssuerSessionOK()) {
				if (!IsCardIssuerStore()) {
					(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
				else {
					(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
			}
		}
		else if (m_busCtx.eCardFromWhich == Card_In_CardIssuer)
		{
			//在读卡时已发送了非接取消读卡请求，此处不再重复发送
			//if (!IsCardIssuerStore()) {
			//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("as card in CardIssuerStand,to cancel others");
			//}
			//else {
			//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("as card in CardIssuerStore,to cancel others");
			//}
			//if (IsContactlessCardSessionOK())
			//	(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
		}
		return ret;
	}
	case USER_EVT_PREONLINE_FINISHED:
		pEvt->SetHandled();
		return 0;
	case USER_EVT_POSTONLINE_FINISHED:
		pEvt->SetHandled();
		return 0;
	case USER_EVT_READ_CANCEL:
		pEvt->SetHandled();
		m_bCancelAccept = true;
		CancelRead();
		break;
	case USER_EVT_READ_WAIT_MORE:
	{
		pEvt->SetHandled();
		ReadWaitMoreTask* task = new ReadWaitMoreTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_EXIT:
	{
		m_busCtx.eCardFromWhich = Card_In_No_Where;
		pEvt->SetHandled();
		DoExitTask* task = new DoExitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_WRITE_FINISHED:
	case USER_EVT_SET_SOME_FLAG_FINISHED:
	case USER_EVT_GET_DEV_INFO_FINISHED:
	case USER_EVT_QUERY_CARD_INFO_FINISHED:
	case USER_EVT_GET_MATERIAL_FINISHED:
	case USER_EVT_SET_MATERIAL_FINISHED:
	case USER_EVT_GET_SCI_INFO_FINISHED:
	case USER_EVT_OPEN_SAFELOCK_FINISHED:
	case USER_EVT_MAGTRANS_INIT_FINISHED:
	case USER_EVT_QUERY_CONN_INFO_FINISHED:
	case USER_EVT_QUIT:
	case USER_EVT_SAM_IC_COMMAND_FINISHED:
	case USER_EVT_QUERY_PRINTER_STATUS_FINISHED:
	case USER_EVT_PRINT_FINISHED:
	case USER_EVT_QUERY_SCILIST_FINISHED:
	case USER_EVT_BIND_SCI_FINISHED:
	case USER_EVT_PREONLINE_ON_STORE_FINISHED:
	case USER_EVT_GET_ADD_CARD_INFO_FINISHED:
	case USER_EVT_NOTIFY_PREONLINE_FINISHED:
	case USER_EVT_QUERY_CARD_INFO_ON_STORE_FINISHED:
	case USER_EVT_CROSS_TERM_CALL_FINISHED:
	case USER_EVT_PRINT_CARD_IM_FINISHED:
	case USER_EVT_QUERY_CI_STATUS_FINISHED:
	case USER_EVT_EJECT_FINISHED:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
//Failed
void CCardReadAdapterFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_lastS2Event = m_lastS2EvtParam1 = 0;
	//GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDISSUER_HOLD);
}
void CCardReadAdapterFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardReadAdapterFSM::s4_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s4 evt(%d)", pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	case USER_EVT_EXIT:
	{
		pEvt->SetHandled();
		DoExitTask* task = new DoExitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_SET_SOME_FLAG:
	{
		pEvt->SetHandled();
		SetSomeFlagEvent* ssfe = dynamic_cast<SetSomeFlagEvent*>(pEvt);
		SetSomeFlagTask* task = new SetSomeFlagTask(this);
		task->ctx = ssfe->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_GET_DEV_INFO:
	{
		pEvt->SetHandled();
		GetDevInfoEvent* gdie = dynamic_cast<GetDevInfoEvent*>(pEvt);
		GetDevInfoTask* task = new GetDevInfoTask(this);
		task->ctx = gdie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* qcie = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = qcie->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
		break;
	default:
		break;
	}
	return 0;
}

ErrorCodeEnum CCardReadAdapterFSM::OnInit()
{
	LOG_FUNCTION();
	m_lastS2Event = m_lastS2EvtParam1 = 0;
	m_busCtx.eCardFromWhich = Card_In_No_Where;
	return Error_Succeed;
}
ErrorCodeEnum CCardReadAdapterFSM::OnExit()
{
	LOG_FUNCTION();
	FSMImpl<CCardReadAdapterFSM>::OnExit();
	return Error_Succeed;
}
int CCardReadAdapterFSM::Initial()
{
	CheckSessionTask *pTask = new CheckSessionTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	ErrorCodeEnum eErr;
	eErr = GetEntityBase()->GetFunction()->SetSysVar("CardEntityState", "E");
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetSysVar CardEntityState failed.%d",eErr);
	}
	return 0;//oiltmp no need to connect. let function "CheckAndReconnectSession" do
}
int CCardReadAdapterFSM::DoWork(int type)
{
	switch (type)
	{
	case USER_EVT_READ:
	{
	}
		break;
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unkown type:%d",type);
		break;
	}
	return 0;
}
int CCardReadAdapterFSM::CardIssuerRead(SpReqAnsContext<CardReadAdapterService_Read_Req, CardReadAdapterService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (m_bCancelAccept || (m_busCtx.eCardFromWhich == Card_In_ContactlessCard))
	{
		char msg[128];
		memset(msg, 0, 128);
		sprintf(msg, "Maybe the thread pool is wrong.CardIssuerRead,bCancel:%d,cardpos:%d", m_bCancelAccept, m_busCtx.eCardFromWhich);
		LogWarn(Severity_Middle, Error_NotInit, CardReadAdapter_UserErrorCode_MayBe_ThreadPool_Wrong, msg);
		return 3;
	}
	ErrorCodeEnum eErr = Error_Unexpect;
	if (IsTheEntity(ctx->Req.module,Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_QueryCardInfo_Req qciReq;
			CardIssuerStandService_QueryCardInfo_Ans qciAns;
			bool bHasCard = false, bNeedPreOnline = false, bCardMismatch = false;
			DWORD dwUsrErrCode = 0;
			CSimpleStringA csRetStr(true);
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->QueryCardInfo(qciReq, qciAns, 10000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				if (qciAns.position == 2)//有卡
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand has card, cancel ContactlessCard.");
					bHasCard = true;
					//oilyang@20220817 为什么要给默认值？Read失败，没有必要PreOnline
					//bNeedPreOnline = true;//不知道卡片类型，默认
					m_busCtx.eCardFromWhich = Card_In_CardIssuer;
					if (IsContactlessCardSessionOK())
						(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
				else if (qciAns.position == 1) //GetDevStatus 调用异常
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStand GetDevStatus failed");
					return 1;
				}
				else
				{
					if (m_bCancelAccept)
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("before call CardIssuerStand->Insert, have received cancel event");
						return 3;
					}
					CardIssuerStandService_Insert_Req req;
					CardIssuerStandService_Insert_Ans ans;
					req.aid = ctx->Req.aid;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to call cardissuerStand insert..");
					m_busCtx.eCardProcStage = Card_ProcStage_WaitForCard;
					eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->Insert(req, ans, 59000, dwUsrErrCode, csRetStr);
					if (eErr == Error_Succeed)
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Card insert into CardIssuerStand, cancel ContactlessCard.");
						bHasCard = true;
						m_busCtx.eCardFromWhich = Card_In_CardIssuer;
						m_busCtx.eCardProcStage = Card_ProcStage_Read;
						if (IsContactlessCardSessionOK())
							(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
					}
					else {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStand Insert return:%d", eErr);
						//oilyang@20200827 if time out, we must told front caller 
						//AND set returned value of 0 to change FSM state
						if (eErr == Error_TimeOut)
						{
							return 7;
						}
						else
							return 1;//oilyang@20190709
					}

				}
				if (bHasCard)
				{
					CardIssuerStandService_Read_Req reqR;
					CardIssuerStandService_Read_Ans ansR;
					reqR.aid = ctx->Req.aid;
					reqR.reserved1 = ctx->Req.lightPos;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("to read ctx->Req.lightPos:%d", ctx->Req.lightPos);
					Sleep(100);//zjw@20190725 以防卡机状态还未跳转，这里就已经触发了Read操作
					eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->Read(reqR, ansR, 50000, dwUsrErrCode, csRetStr);
					if (eErr == Error_Succeed)
					{
						ctx->Ans.track1 = ansR.track1;
						ctx->Ans.track2 = ansR.track2;
						ctx->Ans.track3 = ansR.track3;
						ctx->Ans.ICType = ansR.ICType;
						ctx->Ans.ICCardNo = ansR.ICData;
						ctx->Ans.status = ansR.status;
						///**TODO(Gifur@8/22/2023):  增加单屏机型判断，需要诗友确认*/
						if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
							ctx->Ans.cardPos = CardPos_CardIssuer_Stand2S;
						else
							ctx->Ans.cardPos = CardPos_CardIssuer_Split;
						ctx->Ans.t2Account = ansR.t2Account;
						ctx->Ans.t2Region = ansR.t2Region;
						ctx->Ans.t2CardSerial = ansR.t2CardSerial;
						ctx->Ans.t2CVC = ansR.t2CVC;
						ctx->Ans.t2ExpireDate = ansR.t2ExpireDate;
						if (ansR.ICType == 1 || ansR.ICType == 3)
							bNeedPreOnline = true;
						else
							bNeedPreOnline = false;
					}
					else
					{
						bNeedPreOnline = false;
						if (eErr == Error_DevMedia)
							bCardMismatch = true;
					}
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStand QueryCardInfo failed return:%d", eErr);
				return 1;//oilyang@20190709
			}
			if (bHasCard && bNeedPreOnline)
			{
				CardIssuerStandService_PreOnline_Req req;
				CardIssuerStandService_PreOnline_Ans ans;
				req.businessData = ctx->Req.businessData;
				BroadcastReadICing(0);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to preonline");
				eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
				if (eErr == Error_Succeed)
				{
					ctx->Ans.result = ans.result;
					ctx->Ans.status = 0;
					//oilyang@20220613 既然前面bNeedPreOnline给默认值，这里的判断也就失去了意义
					//if (ctx->Ans.ICType == 1 || ctx->Ans.ICType == 3)
					{
						CardIssuerStandService_SetSomeFlag_Req ssfReq;
						CardIssuerStandService_SetSomeFlag_Ans ssfAns;
						ssfReq.IssueBusiness = 4;
						eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->SetSomeFlag(ssfReq, ssfAns, 5000, dwUsrErrCode);
						if (eErr == Error_Succeed)
							ctx->Ans.ICCardNo = ssfAns.reserved2[0];
						else
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStand SetSomeFlag failed return:%d", eErr);
					}
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStand PreOnline failed return:%d", eErr);
					ctx->Ans.result = "";
					ctx->Ans.status = -1;
				}


			}
			if (bHasCard)
			{
				if (bCardMismatch)
				{
					//oiltmp@20221202 todo Error_DevNotAvailable should be changed if we have negotiated with hangzhou vtm developer
					ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_Account_EAC_Mismatch, csRetStr);
				}
				else
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReadCard, the final errCode:%d,status:%d,dwUsrErrCode:%d", eErr, ctx->Ans.status, dwUsrErrCode);
					Sleep(300);//oilyang@20230202 for hardware entity to trans FSM state
					ctx->Answer(eErr, dwUsrErrCode, csRetStr);
				}
			}
			return 0;
		}
		else {
			CardIssuerStoreService_QueryCardInfo_Req qciReq;
			CardIssuerStoreService_QueryCardInfo_Ans qciAns;
			bool bHasCard = false, bNeedPreOnline = false, bCardMismatch = false;
			DWORD dwUsrErrCode = 0;
			CSimpleStringA csRetStr(true);
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->QueryCardInfo(qciReq, qciAns, 12000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				if (qciAns.position == 2)//有卡
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore has card, cancel ContactlessCard.");
					bHasCard = true;
					//oilyang@20220817 为什么要给默认值？Read失败，没有必要PreOnline
					//bNeedPreOnline = true;//不知道卡片类型，默认
					m_busCtx.eCardFromWhich = Card_In_CardIssuer;
					if (IsContactlessCardSessionOK())
						(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
				}
				else if (qciAns.position == 1) //GetDevStatus 调用异常
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStore GetDevStatus failed");
					return 1;
				}
				else
				{
					if (m_bCancelAccept)
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("before call CardIssuerStore->Insert, have received cancel event");
						return 3;
					}
					CardIssuerStoreService_Insert_Req req;
					CardIssuerStoreService_Insert_Ans ans;
					req.aid = ctx->Req.aid;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to call cardissuerStore insert..");
					m_busCtx.eCardProcStage = Card_ProcStage_WaitForCard;
					eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->Insert(req, ans, 59000, dwUsrErrCode, csRetStr);
					if (eErr == Error_Succeed)
					{
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Card insert into CardIssuerStore, cancel ContactlessCard.");
						bHasCard = true;
						m_busCtx.eCardFromWhich = Card_In_CardIssuer;
						m_busCtx.eCardProcStage = Card_ProcStage_Read;
						if (IsContactlessCardSessionOK())
							(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
					}
					else {
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStore Insert return:%d", eErr);
						//oilyang@20200827 if time out, we must told front caller 
						//AND set returned value of 0 to change FSM state
						if (eErr == Error_TimeOut)
						{
							return 7;
						}
						else
							return 1;//oilyang@20190709
					}

				}
				if (bHasCard)
				{
					CardIssuerStoreService_Read_Req reqR;
					CardIssuerStoreService_Read_Ans ansR;
					reqR.aid = ctx->Req.aid;
					reqR.reserved1 = ctx->Req.lightPos;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("to read ctx->Req.lightPos:%d", ctx->Req.lightPos);
					Sleep(100);//zjw@20190725 以防卡机状态还未跳转，这里就已经触发了Read操作
					eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->Read(reqR, ansR, 50000, dwUsrErrCode, csRetStr);
					if (eErr == Error_Succeed)
					{
						ctx->Ans.track1 = ansR.track1;
						ctx->Ans.track2 = ansR.track2;
						ctx->Ans.track3 = ansR.track3;
						ctx->Ans.ICType = ansR.ICType;
						ctx->Ans.ICCardNo = ansR.ICData;
						ctx->Ans.status = ansR.status;
						///**TODO(Gifur@8/22/2023):  增加单屏机型判断，需要诗友确认*/
						if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
							ctx->Ans.cardPos = CardPos_CardIssuer_Stand2S;
						else
							ctx->Ans.cardPos = CardPos_CardIssuer_Split;
						ctx->Ans.t2Account = ansR.t2Account;
						ctx->Ans.t2Region = ansR.t2Region;
						ctx->Ans.t2CardSerial = ansR.t2CardSerial;
						ctx->Ans.t2CVC = ansR.t2CVC;
						ctx->Ans.t2ExpireDate = ansR.t2ExpireDate;
						if (ansR.ICType == 1 || ansR.ICType == 3)
							bNeedPreOnline = true;
						else
							bNeedPreOnline = false;
					}
					else
					{
						bNeedPreOnline = false;
						if (eErr == Error_DevMedia)
							bCardMismatch = true;
					}
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStore QueryCardInfo failed return:%d", eErr);
				return 1;//oilyang@20190709
			}
			if (bHasCard && bNeedPreOnline)
			{
				CardIssuerStoreService_PreOnline_Req req;
				CardIssuerStoreService_PreOnline_Ans ans;
				req.businessData = ctx->Req.businessData;
				BroadcastReadICing(0);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to preonline");
				eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
				if (eErr == Error_Succeed)
				{
					ctx->Ans.result = ans.result;
					ctx->Ans.status = 0;
					//oilyang@20220613 既然前面bNeedPreOnline给默认值，这里的判断也就失去了意义
					//if (ctx->Ans.ICType == 1 || ctx->Ans.ICType == 3)
					{
						CardIssuerStoreService_SetSomeFlag_Req ssfReq;
						CardIssuerStoreService_SetSomeFlag_Ans ssfAns;
						ssfReq.IssueBusiness = 4;
						eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->SetSomeFlag(ssfReq, ssfAns, 5000, dwUsrErrCode);
						if (eErr == Error_Succeed)
							ctx->Ans.ICCardNo = ssfAns.reserved2[0];
						else
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStore SetSomeFlag failed return:%d", eErr);
					}
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("CardIssuerStore PreOnline failed return:%d", eErr);
					ctx->Ans.result = "";
					ctx->Ans.status = -1;
				}


			}
			if (bHasCard)
			{
				if (bCardMismatch)
				{
					//oiltmp@20221202 todo Error_DevNotAvailable should be changed if we have negotiated with hangzhou vtm developer
					ctx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_Account_EAC_Mismatch, csRetStr);
				}
				else
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReadCard, the final errCode:%d,status:%d,dwUsrErrCode:%d", eErr, ctx->Ans.status, dwUsrErrCode);
					Sleep(300);//oilyang@20230202 for hardware entity to trans FSM state
					ctx->Answer(eErr, dwUsrErrCode, csRetStr);
				}
			}
			return 0;
		}			
	}
	return 1;
}
int CCardReadAdapterFSM::ContactlessCardRead(SpReqAnsContext<CardReadAdapterService_Read_Req, CardReadAdapterService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (m_bCancelAccept || (m_busCtx.eCardFromWhich == Card_In_CardIssuer))
	{
		char msg[128];
		memset(msg, 0, 128);
		sprintf(msg, "Maybe the thread pool is wrong.ContactlessCardRead,bCancel:%d,cardpos:%d", m_bCancelAccept, m_busCtx.eCardFromWhich);
		//oilyang@20220917 发卡时，处于持卡状态，属于误判，然而精准的区分也不容易，暂时这么处理
		//LogWarn(Severity_Middle, Error_NotInit, CardReadAdapter_UserErrorCode_MayBe_ThreadPool_Wrong, msg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(msg);
		return 3;
	}
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD elapsed = 0;
	DWORD dwStart = GetTickCountRVC();
	DWORD dwEnd = GetTickCountRVC();
	int insertloopNum = 0;
	int preloopNum = 0;
	while(elapsed + ReadCard_Min_Time < ReadCard_TIMEOUT)
	{
		if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK())
		{
			bool bFindCard = false;
			ContactlessCardService_Insert_Req req;
			ContactlessCardService_Insert_Ans ans;
			DWORD dwUserCode = 0;
			req.aid = ctx->Req.aid;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to call contactless insert...");
			dwEnd = GetTickCountRVC();
			DWORD dwTimeout = ReadCard_TIMEOUT - (dwEnd-dwStart);
			m_busCtx.eCardFromWhich = Card_In_No_Where;
			m_busCtx.eCardProcStage = Card_ProcStage_WaitForCard;
			if (insertloopNum % 10 == 0) {
				req.reserved1 = "P";
			}
			eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->Insert(req, ans, dwTimeout, dwUserCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.track1 = ans.track1;
				ctx->Ans.track2 = ans.track2;
				ctx->Ans.track3 = ans.track3;
				ctx->Ans.ICType = ans.ICType;
				ctx->Ans.ICCardNo = ans.ICData;
				ctx->Ans.status = ans.status;
				ctx->Ans.cardPos = CardPos_ContactlessCard;
				ctx->Ans.t2Account = ans.t2Account;
				ctx->Ans.t2Region = ans.t2Region; 
				ctx->Ans.t2CardSerial = ans.t2CardSerial;
				ctx->Ans.t2CVC = ans.t2CVC;
				ctx->Ans.t2ExpireDate = ans.t2ExpireDate;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Card in ContactlessCard.");
				m_busCtx.eCardFromWhich = Card_In_ContactlessCard;
				m_busCtx.eCardProcStage = Card_ProcStage_Read;
				//if (IsCardIssuerSessionOK()){
				//	(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->CancelInsert();
				//}
				if (ans.ICType == 4)
				{
					bFindCard = true;
				}else{
					return 0;
				}
			}
			else if (eErr == Error_TimeOut)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ContactlessCard timeout.");
				return 8;
			}else if(eErr == Error_Cancel){
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ContactlessCard canceled or be canceled.");
				return 1;
			}
			else if(eErr == Error_Interact){
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("maybe ICCommand error, need loop!!!");
				dwEnd = GetTickCountRVC();
				elapsed = dwEnd - dwStart;
				Sleep(400);
				insertloopNum++;
				continue;
			}
			else if(eErr == Error_DevNotAvailable || eErr == Error_InvalidState)//设备不可用或实体异常
			{
				//ctx->Answer(eErr, dwUserCode);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("ContactlessCard read failed(%d)(%d)", eErr, dwUserCode));
				return 1;
			}else if(eErr == Error_Unexpect){
				ctx->Answer(eErr, dwUserCode);
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("ContactlessCard read failed(%d)(%d)", eErr, dwUserCode));
				return 2;
			}

			if (bFindCard)
			{
				//oilyang@20210223 add,The Entity FSM is too late to change state ,as the call coming so fast
				Sleep(200);
				dwEnd = GetTickCountRVC();
				DWORD elapsed1 = ReadCard_TIMEOUT - (dwEnd-dwStart);
				if(elapsed1 < 5000)//PreOnline较慢，预留一定时间
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("There is no more time to invoke PreOnline");
					ctx->Ans.result = "";
					return 8;
				}
				ContactlessCardService_PreOnline_Req req;
				ContactlessCardService_PreOnline_Ans ans;
				req.businessData = ctx->Req.businessData;
				BroadcastReadICing(0);
				if (preloopNum % 10 == 0) {
					req.reserved1 = "P";
				}
				eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("ContacelssCard PreOnline result:%d", eErr));
				if (eErr == Error_Succeed)
				{
					ctx->Ans.result = ans.result;
					ctx->Ans.status = 0;
				}else if(eErr == Error_Interact){
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ContacelssCard return Error_Interact, need loop.");
					dwEnd = GetTickCountRVC();
					elapsed = dwEnd - dwStart;
					preloopNum++;
					Sleep(400);
					continue;
				}
				else
				{
					ctx->Ans.result = "";
					ctx->Ans.status = -1;
				}
				ctx->Answer(eErr);
				return 0;
			}
			//ctx->Answer(eErr);
		}else{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("can't find the corresponding Entity.req.Module:%d", ctx->Req.module));
			return 0;
		}
	}
	return 8;
}
int CCardReadAdapterFSM::IssueCard(SpReqAnsContext<CardReadAdapterService_Issue_Req, CardReadAdapterService_Issue_Ans>::Pointer ctx)
{
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_IssueEx_Req req;
			CardIssuerStandService_IssueEx_Ans ans;
			req.hopper = ctx->Req.hopper;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			DWORD dwUsrErrCode = 0;
			CSimpleStringA csRetStr(true);
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->IssueEx(req, ans, 60000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				if (ans.reserved1.GetCount() > 0)
					ctx->Ans.reserved1.Copy(ans.reserved1);
				if (ans.reserved2.GetCount() > 0)
					ctx->Ans.reserved2.Copy(ans.reserved2);
				//  --Josephus at 11:09:47 201747
				//oilyang@20180315 kaku
				//if(m_busCtx.eCardFromWhich == Card_In_No_Where)
				if (req.hopper == 99 || req.hopper == 98 || req.hopper == 89)
				{
					if (ans.reserved1[0] == 0 && ans.reserved1[1] == 0)
						m_busCtx.eCardFromWhich = Card_In_CardIssuer;
				}
				else if (req.hopper == 88 || req.hopper == 87)
				{
					m_busCtx.eCardFromWhich = Card_In_No_Where;
				}
				else
					m_busCtx.eCardFromWhich = Card_In_CardIssuer;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("req.hopper:%d Deem that CardIssuerStand has card after issuing succ. Set busCtx:findCard:%d,cardPos:%d"
					, req.hopper, ans.reserved1[0], ans.reserved1[1]);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStand IssueCard failed return:%d", eErr);
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest IssueEx retStr:%s", csRetStr.GetData());
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
			return 0;
		}
		else {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_IssueEx_Req req;
			CardIssuerStoreService_IssueEx_Ans ans;
			req.hopper = ctx->Req.hopper;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			DWORD dwUsrErrCode = 0;
			CSimpleStringA csRetStr(true);
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->IssueEx(req, ans, 60000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				if (ans.reserved1.GetCount() > 0)
					ctx->Ans.reserved1.Copy(ans.reserved1);
				if (ans.reserved2.GetCount() > 0)
					ctx->Ans.reserved2.Copy(ans.reserved2);
				//  --Josephus at 11:09:47 201747
				//oilyang@20180315 kaku
				//if(m_busCtx.eCardFromWhich == Card_In_No_Where)
				if (req.hopper == 99 || req.hopper == 98 || req.hopper == 89)
				{
					if (ans.reserved1[0] == 0 && ans.reserved1[1] == 0)
						m_busCtx.eCardFromWhich = Card_In_CardIssuer;
				}
				else if (req.hopper == 88 || req.hopper == 87)
				{
					m_busCtx.eCardFromWhich = Card_In_No_Where;
				}
				else
					m_busCtx.eCardFromWhich = Card_In_CardIssuer;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("req.hopper:%d Deem that CardIssuerStore has card after issuing succ. Set busCtx:findCard:%d,cardPos:%d"
					, req.hopper, ans.reserved1[0], ans.reserved1[1]);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CardIssuerStore IssueCard failed return:%d", eErr);
			}
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest IssueEx retStr:%s", csRetStr.GetData());
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
			return 0;
		}
		
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("issue card param error or connection is failed:(module)%d",ctx->Req.module);
		ctx->Answer(Error_Param);
		return 1;
	}
}

void CCardReadAdapterFSM::CancelRead()
{
	ErrorCodeEnum eErr = Error_Unexpect;

	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("CardIssuerStand read canceled by front user.");
			(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->CancelInsert();
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("CardIssuerStore read canceled by front user.");
			(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->CancelInsert();
		}
	}
	if (IsContactlessCardSessionOK())
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("ContactlessCard read canceled by front user.");
		(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
	}

}
void CCardReadAdapterFSM::ReadWaitMore()
{
	ErrorCodeEnum eErr = Error_Unexpect;

	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->InsertWaitMore();
		}
		else {
			(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->InsertWaitMore();
		}
		
	}
	if (IsContactlessCardSessionOK())
	{
		(*m_pContactless)(EntityResource::getLink().upgradeLink())->InsertWaitMore();
	}

}
int CCardReadAdapterFSM::WriteTrack(SpReqAnsContext<CardReadAdapterService_WriteTrack_Req, CardReadAdapterService_WriteTrack_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_WriteTrack_Req req;
			CardIssuerStandService_WriteTrack_Ans ans;
			req.co = ctx->Req.co;
			req.mode = ctx->Req.mode;
			req.track1 = ctx->Req.track1;
			req.track2 = ctx->Req.track2;
			req.track3 = ctx->Req.track3;
			req.reserved = ctx->Req.reserved;
			ErrorCodeEnum eErr = Error_Unexpect;
			DWORD dwUsrErrCode = 0;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->WriteTrack(req, ans, 20000, dwUsrErrCode);
			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("WriteTrack failed.%d", eErr);
				ctx->Answer(eErr, dwUsrErrCode);
			}
			else
			{
				ctx->Ans.result = ans.result;
				ctx->Ans.reserved1 = ans.reserved1;
				ctx->Ans.reserved2 = ans.reserved2;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Write tracks ok.");
				ctx->Answer(Error_Succeed);
			}
		}
		else {
			CardIssuerStoreService_WriteTrack_Req req;
			CardIssuerStoreService_WriteTrack_Ans ans;
			req.co = ctx->Req.co;
			req.mode = ctx->Req.mode;
			req.track1 = ctx->Req.track1;
			req.track2 = ctx->Req.track2;
			req.track3 = ctx->Req.track3;
			req.reserved = ctx->Req.reserved;
			ErrorCodeEnum eErr = Error_Unexpect;
			DWORD dwUsrErrCode = 0;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->WriteTrack(req, ans, 20000, dwUsrErrCode);
			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("WriteTrack failed.%d", eErr);
				ctx->Answer(eErr, dwUsrErrCode);
			}
			else
			{
				ctx->Ans.result = ans.result;
				ctx->Ans.reserved1 = ans.reserved1;
				ctx->Ans.reserved2 = ans.reserved2;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("Write tracks ok.");
				ctx->Answer(Error_Succeed);
			}
		}

	}
	return 0;
}
int CCardReadAdapterFSM::PreOnline(SpReqAnsContext<CardReadAdapterService_PreOnline_Req, CardReadAdapterService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD dwUsrErrCode = 0;
	CSimpleStringA csRetStr(true);
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_PreOnline_Req req;
			CardIssuerStandService_PreOnline_Ans ans;
			req.businessData = ctx->Req.businessData;
			if (!ctx->Req.reserved2[0].IsNullOrEmpty())
				req.reserved1 = ctx->Req.reserved2[0];
			else
				req.reserved1 = "";
			if (!ctx->Req.reserved2[1].IsNullOrEmpty())
				req.reserved2 = ctx->Req.reserved2[1];
			else
				req.reserved2 = "";
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.result = ans.result;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PreOnline, CardIssuerStand PreOnline failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}
		else {
			CardIssuerStoreService_PreOnline_Req req;
			CardIssuerStoreService_PreOnline_Ans ans;
			req.businessData = ctx->Req.businessData;
			if (!ctx->Req.reserved2[0].IsNullOrEmpty())
				req.reserved1 = ctx->Req.reserved2[0];
			else
				req.reserved1 = "";
			if (!ctx->Req.reserved2[1].IsNullOrEmpty())
				req.reserved2 = ctx->Req.reserved2[1];
			else
				req.reserved2 = "";
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.result = ans.result;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PreOnline, CardIssuerStore PreOnline failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}

	}
	else if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK() && m_busCtx.eCardFromWhich == Card_In_ContactlessCard)
	{
		ContactlessCardService_PreOnline_Req req;
		ContactlessCardService_PreOnline_Ans ans;
		req.businessData = ctx->Req.businessData;
		//req.reserved1 = ctx->Req.reserved1;
		//req.reserved2 = ctx->Req.reserved2;
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->PreOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
		if (eErr == Error_Succeed)
		{
			ctx->Ans.result = ans.result;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)(CSimpleStringA::Format("PreOnline, ContactlessCard PreOnline failed return:%d", eErr));
		}
		ctx->Answer(eErr, dwUsrErrCode, csRetStr);
	}
	return 0;
}
int CCardReadAdapterFSM::PostOnline(SpReqAnsContext<CardReadAdapterService_PostOnline_Req, CardReadAdapterService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("<PostOnline>, ctx->Req.module:%d,cardIn(Iss 1,RF 2):%d", ctx->Req.module, m_busCtx.eCardFromWhich);
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD dwUsrErrCode = 0;
	CSimpleStringA csRetStr(true);
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK() && m_busCtx.eCardFromWhich == Card_In_CardIssuer)
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_PostOnline_Req req;
			CardIssuerStandService_PostOnline_Ans ans;
			req.data = ctx->Req.data;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->PostOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.result = ans.result;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("PostOnline, CardIssuerStand PostOnline failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}
		else {
			CardIssuerStoreService_PostOnline_Req req;
			CardIssuerStoreService_PostOnline_Ans ans;
			req.data = ctx->Req.data;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->PostOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.result = ans.result;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("PostOnline, CardIssuerStore PostOnline failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);

		}

	}
	else if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK() && m_busCtx.eCardFromWhich == Card_In_ContactlessCard)
	{
		ContactlessCardService_PostOnline_Req req;
		ContactlessCardService_PostOnline_Ans ans;
		req.data = ctx->Req.data;
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->PostOnline(req, ans, 50000, dwUsrErrCode, csRetStr);
		if (eErr == Error_Succeed)
		{
			ctx->Ans.result = ans.result;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("PostOnline, ContactlessCard PostOnline failed return:%d", eErr);
		}
		ctx->Answer(eErr, dwUsrErrCode, csRetStr);
	}
	return 0;
}
int CCardReadAdapterFSM::EjectCard(SpReqAnsContext<CardReadAdapterService_Eject_Req, CardReadAdapterService_Eject_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Sleep(100);//oilyang@20230202 for hardware entity to trans FSM state
	ErrorCodeEnum eErr = Error_Unexpect;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("before eject card,req.module %d,card in %d", ctx->Req.module,m_busCtx.eCardFromWhich);
	DWORD dwUsrErrCode = 0;
	CSimpleStringA csRetStr(true);
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK() && m_busCtx.eCardFromWhich == Card_In_CardIssuer)
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_Eject_Req req;
			CardIssuerStandService_Eject_Ans ans;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->Eject(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				m_busCtx.eCardFromWhich = Card_In_No_Where;
				m_busCtx.eCardProcStage = Card_ProcStage_Eject;
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CardIssuerStand EjectCard suc.");
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("EjectCard, CardIssuerStand EjectCard failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}
		else {
			CardIssuerStoreService_Eject_Req req;
			CardIssuerStoreService_Eject_Ans ans;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->Eject(req, ans, 50000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				m_busCtx.eCardFromWhich = Card_In_No_Where;
				m_busCtx.eCardProcStage = Card_ProcStage_Eject;
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CardIssuerStore EjectCard suc.");
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("EjectCard, CardIssuerStore EjectCard failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}

	}
	else if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK() && m_busCtx.eCardFromWhich == Card_In_ContactlessCard)
	{
		ContactlessCardService_Eject_Req req;
		ContactlessCardService_Eject_Ans ans;
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->Eject(req, ans, 50000, dwUsrErrCode, csRetStr);
		if (eErr == Error_Succeed)
		{
			m_busCtx.eCardFromWhich = Card_In_No_Where;
			m_busCtx.eCardProcStage = Card_ProcStage_Eject;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ContactlessCard EjectCard suc.");
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("EjectCard, ContactlessCard EjectCard failed return:%d", eErr);
		}
		ctx->Answer(eErr, dwUsrErrCode, csRetStr);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("EjectCard, nothing to do.");
		ctx->Answer(Error_NotExist);
	}
	return 0;
}
int CCardReadAdapterFSM::CaptureCard(SpReqAnsContext<CardReadAdapterService_Capture_Req, CardReadAdapterService_Capture_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Sleep(100);//oilyang@20230202 for hardware entity to trans FSM state
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD dwUsrErrCode = 0;
	CSimpleStringA csRetStr(true);
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK() && m_busCtx.eCardFromWhich == Card_In_CardIssuer)
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_Capture_Req req;
			CardIssuerStandService_Capture_Ans ans;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->Capture(req, ans, 15000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand Capture card suc.");
				m_busCtx.eCardFromWhich = Card_In_No_Where;
				m_busCtx.eCardProcStage = Card_ProcStage_Capture;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CaptureCard, CardIssuerStand Capture failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}
		else {
			CardIssuerStoreService_Capture_Req req;
			CardIssuerStoreService_Capture_Ans ans;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->Capture(req, ans, 15000, dwUsrErrCode, csRetStr);
			if (eErr == Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore Capture card suc.");
				m_busCtx.eCardFromWhich = Card_In_No_Where;
				m_busCtx.eCardProcStage = Card_ProcStage_Capture;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CaptureCard, CardIssuerStore Capture failed return:%d", eErr);
			}
			ctx->Answer(eErr, dwUsrErrCode, csRetStr);
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CaptureCard, Something wrong.the module(%d),cardinwhere(%d)", ctx->Req.module, m_busCtx.eCardFromWhich);
		ctx->Answer(eErr);
	}
	return 0;
}
int CCardReadAdapterFSM::QueryCardInfo(SpReqAnsContext<CardReadAdapterService_QueryCardInfo_Req, CardReadAdapterService_QueryCardInfo_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	DWORD dwUsrErrCode = 0;
	ctx->Ans.CardIssuerPos = ctx->Ans.ContactlessCardPos = ctx->Ans.CardSwiperPos = 0;
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK() && m_busCtx.eCardFromWhich == Card_In_CardIssuer)
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_QueryCardInfo_Req req;
			CardIssuerStandService_QueryCardInfo_Ans ans;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->QueryCardInfo(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				switch (ans.position)
				{
				case 1:
					ctx->Ans.CardIssuerPos = -1;
					break;
				case 2:
					ctx->Ans.CardIssuerPos = 1;
					break;
				default:
					break;
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfo, CardIssuerStand QueryCardInfo failed return:%d", eErr);
			}
		}
		else {
			CardIssuerStoreService_QueryCardInfo_Req req;
			CardIssuerStoreService_QueryCardInfo_Ans ans;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->QueryCardInfo(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				switch (ans.position)
				{
				case 1:
					ctx->Ans.CardIssuerPos = -1;
					break;
				case 2:
					ctx->Ans.CardIssuerPos = 1;
					break;
				default:
					break;
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfo, CardIssuerStore QueryCardInfo failed return:%d", eErr);
			}
		}

	}
	if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK() && m_busCtx.eCardFromWhich == Card_In_ContactlessCard)
	{
		ContactlessCardService_QueryCardInfo_Req req;
		ContactlessCardService_QueryCardInfo_Ans ans;
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->QueryCardInfo(req, ans, 10000, dwUsrErrCode);
		if (eErr == Error_Succeed)
		{
			switch (ans.position)//oiltmp to add
			{
			case 2:
				break;
			case 3:
				break;
			case 4:
				ctx->Ans.ContactlessCardPos = 1;
				break;
			default:
				break;
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfo, ContactlessCard QueryCardInfo failed return:%d", eErr);
			ctx->Ans.ContactlessCardPos = -1;
		}
	}
	ctx->Answer(Error_Succeed);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("<QueryCardInfo>, CardFromWhich:%d, position(CI,CC,CS) %d,%d,%d",
		m_busCtx.eCardFromWhich, ctx->Ans.CardIssuerPos, ctx->Ans.ContactlessCardPos, ctx->Ans.CardSwiperPos);
	return 0;
}
void CCardReadAdapterFSM::CheckAndReconnectSession()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	int cardIssuerCount = 0, contactlessCardCount = 0;
	while (1)
	{
		//the first time to connect or need to reconnect
		//分为卡机和卡库
		if (!IsCardIssuerStore()) {
			if ((m_pCardIssuer == NULL || (m_pCardIssuer != NULL && m_pCardIssuer->QuerySessionClosed())))
			{
				if (m_pCardIssuer != NULL)
				{
					m_pCardIssuer->GetFunction()->CloseSession();
					m_pCardIssuer = NULL;
				}
				m_pCardIssuer = new CardIssuerStandService_ClientBase(GetEntityBase());
				if (m_pCardIssuer != NULL)
				{
					eErr = m_pCardIssuer->Connect();
					if (eErr != Error_Succeed)
					{
						if (cardIssuerCount % 120 == 0)//about 10 minutes can't connect to entity
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("connect to entity CardIssuerStand failed.%d", eErr);
						cardIssuerCount++;
						m_pCardIssuer->SafeDelete();
						m_pCardIssuer = NULL;
					}
					else
					{
						cardIssuerCount = 0;
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Connect to entity CardIssuerStand suc.");
					}
				}
			}
		}
		else {
			//CardIssuerStore
			if ((m_pCardIssuerStore == NULL || (m_pCardIssuerStore != NULL && m_pCardIssuerStore->QuerySessionClosed())))
			{
				if (m_pCardIssuerStore != NULL)
				{
					m_pCardIssuerStore->GetFunction()->CloseSession();
					m_pCardIssuerStore = NULL;
				}
				m_pCardIssuerStore = new CardIssuerStoreService_ClientBase(GetEntityBase());
				if (m_pCardIssuerStore != NULL)
				{
					eErr = m_pCardIssuerStore->Connect();
					if (eErr != Error_Succeed)
					{
						if (cardIssuerCount % 120 == 0)//about 10 minutes can't connect to entity
							DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("connect to entity CardIssuerStore failed.%d", eErr);
						cardIssuerCount++;
						m_pCardIssuerStore->SafeDelete();
						m_pCardIssuerStore = NULL;
					}
					else
					{
						cardIssuerCount = 0;
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Connect to entity CardIssuerStore suc.");
					}
				}
			}
		}
		//ContactlessCard
		if ((m_eMachineType != SP::Module::Comm::RVC_CardStore && m_eMachineType != SP::Module::Comm::RVC_CardPrinter)
			&& (m_pContactless == NULL || (m_pContactless != NULL && m_pContactless->QuerySessionClosed())))
		{
			if (m_pContactless != NULL)
			{
				m_pContactless->GetFunction()->CloseSession();
				m_pContactless = NULL;
			}
			m_pContactless = new ContactlessCardService_ClientBase(GetEntityBase());
			if (m_pContactless != NULL)
			{
				eErr = m_pContactless->Connect();
				if (eErr != Error_Succeed)
				{
					if (contactlessCardCount % 120 == 0)//about 10 minutes can't connect to entity
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("connect to entity ContactlessCard failed.%d", eErr);
					contactlessCardCount++;
					m_pContactless->SafeDelete();
					m_pContactless = NULL;
				}
				else
				{
					contactlessCardCount = 0;
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Connect to entity ContactlessCard suc.");
				}
			}
		}
		Sleep(5000);
	}
}
bool CCardReadAdapterFSM::IsCardIssuerSessionOK()
{
	if (!IsCardIssuerStore()) {
		if (m_pCardIssuer != NULL && !m_pCardIssuer->QuerySessionClosed()) {
			return true;
		}
	}
	else {
		if (m_pCardIssuerStore != NULL && !m_pCardIssuerStore->QuerySessionClosed()) {
			return true;
		}
	}
	return false;
}
bool CCardReadAdapterFSM::IsContactlessCardSessionOK()
{
	if (m_pContactless != NULL && !m_pContactless->QuerySessionClosed())
		return true;
	return false;
}

bool CCardReadAdapterFSM::IsTheEntity(int module,ModuleType eModule)
{
	if (module == 0)
		return true;
	//oilyang@20180409 add req.module==99
	else if (module == 99)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("req.module is 99,machineType is:%s",m_csMachineType.GetData());
		//oilyang@20200730 according to meeting with Ratail/Test/Hangzhou
		//from guodan 20180905
		//99：进卡读卡，功能集向除蓝牙发卡机之外的读卡实体发出进卡读卡指令。
		
		if (eModule == Module_CardIssuer)
		{
			if (m_eMachineType == SP::Module::Comm::RVC_Stand2S
				|| m_eMachineType == SP::Module::Comm::RVC_CardStore
				|| m_eMachineType == SP::Module::Comm::RVC_CardPrinter
				|| m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
				return true;
			else
				return false;
		}
		else
			return true;
	}
	else if ((module&eModule) == eModule)
		return true;
	else
		return false;
}
int CCardReadAdapterFSM::SetSomeFlag(SpReqAnsContext<CardReadAdapterService_SetSomeFlag_Req, CardReadAdapterService_SetSomeFlag_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_SetSomeFlag_Req req;
			CardIssuerStandService_SetSomeFlag_Ans ans;
			req.IssueBusiness = ctx->Req.IssueBusiness;
			req.reserved1.Init(ctx->Req.reserved1.GetCount());
			for (int i = 0; i < ctx->Req.reserved1.GetCount(); ++i)
			{
				req.reserved1[i] = ctx->Req.reserved1[i];
			}
			ErrorCodeEnum eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->SetSomeFlag(req, ans, 10000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStand SetSomeFlag failed return:%d", eErr);
				ctx->Answer(Error_Unexpect);
			}
		}
		else {
			CardIssuerStoreService_SetSomeFlag_Req req;
			CardIssuerStoreService_SetSomeFlag_Ans ans;
			req.IssueBusiness = ctx->Req.IssueBusiness;
			req.reserved1.Init(ctx->Req.reserved1.GetCount());
			for (int i = 0; i < ctx->Req.reserved1.GetCount(); ++i)
			{
				req.reserved1[i] = ctx->Req.reserved1[i];
			}
			ErrorCodeEnum eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->SetSomeFlag(req, ans, 10000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CardIssuerStore SetSomeFlag failed return:%d", eErr);
				ctx->Answer(Error_Unexpect);
			}
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SetSomeFlag is err, session is not ok");
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
int CCardReadAdapterFSM::GetDevInfo(SpReqAnsContext<CardReadAdapterService_GetDevInfo_Req, CardReadAdapterService_GetDevInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	CSimpleStringA csCIType(""), csCIModel(""), csCIVersion(""), csCCType(""), csCCModel(""), csCCVersion(""), csCSType(""), csCSModel(""), csCSVersion("");
	int ciState, ccState, csState;
	bool bCI(false), bCC(false), bCS(false);
	ErrorCodeEnum eErr = Error_Unexpect;
	int count = 0;
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_GetDevInfo_Req req;
			CardIssuerStandService_GetDevInfo_Ans ans;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->GetDevInfo(req, ans, 10000);
			if (eErr == Error_Succeed)
			{
				bCI = true;
				count++;
				csCIType = ans.type;
				csCIModel = ans.model;
				csCIVersion = ans.version;
				ciState = ans.state;
			}
			else if (eErr == Error_DevNotAvailable || eErr == Error_NotInit)//兼容getdevinfo改造，转化打开失败异常情况
			{
				bCI = true;
				count++;
				csCIType = "";
				csCIModel = "";
				csCIVersion = "";
				ciState = 0;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetDevInfo, CardIssuerStand GetDevInfo failed return:%d", eErr);
			}
		}
		else {
			CardIssuerStoreService_GetDevInfo_Req req;
			CardIssuerStoreService_GetDevInfo_Ans ans;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->GetDevInfo(req, ans, 10000);
			if (eErr == Error_Succeed)
			{
				bCI = true;
				count++;
				csCIType = ans.type;
				csCIModel = ans.model;
				csCIVersion = ans.version;
				ciState = ans.state;
			}
			else if (eErr == Error_DevNotAvailable || eErr == Error_NotInit)//兼容getdevinfo改造，转化打开失败异常情况
			{
				bCI = true;
				count++;
				csCIType = "";
				csCIModel = "";
				csCIVersion = "";
				ciState = 0;
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetDevInfo, CardIssuerStore GetDevInfo failed return:%d", eErr);
			}
		}

	}
	if (IsTheEntity(ctx->Req.module, Module_ContactlessCard) && IsContactlessCardSessionOK())
	{
		ContactlessCardService_GetDevInfo_Req req;
		ContactlessCardService_GetDevInfo_Ans ans;
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->GetDevInfo(req, ans, 10000);
		if (eErr == Error_Succeed)
		{
			bCC = true;
			count++;
			csCCType = ans.type;
			csCCModel = ans.model;
			csCCVersion = ans.version;
			ccState = ans.state;
		}
		else if (eErr == Error_DevNotAvailable || eErr == Error_NotInit)//兼容getdevinfo改造，转化打开失败异常情况
		{
			bCC = true;
			count++;
			csCCType = "";
			csCCModel = "";
			csCCVersion = "";
			ccState = 0;
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetDevInfo, ContactlessCard GetDevInfo failed return:%d", eErr);
		}
	}
	ctx->Ans.ModuleNum = count;
	ctx->Ans.ModuleSN.Init(count);
	ctx->Ans.type.Init(count);
	ctx->Ans.model.Init(count);
	ctx->Ans.version.Init(count);
	ctx->Ans.state.Init(count);
	int index = 0;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("count:%d,index:%d,%d,%d,%d",count,index,bCI,bCC,bCS);
	if (bCI)
	{
		ctx->Ans.ModuleSN[index] = Module_CardIssuer;
		ctx->Ans.type[index] = csCIType;
		ctx->Ans.model[index] = csCIModel;
		ctx->Ans.version[index] = csCIVersion;
		ctx->Ans.state[index] = ciState;
		if (!IsCardIssuerStore()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("CardIssuerStand, type:%s, model:%s, version:%s, state:%d",
				csCIType.GetData(), csCIModel.GetData(), csCIVersion.GetData(), ciState);
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("CardIssuerStore, type:%s, model:%s, version:%s, state:%d",
				csCIType.GetData(), csCIModel.GetData(), csCIVersion.GetData(), ciState);
		}
		index++;
	}
	if (bCC)
	{
		ctx->Ans.ModuleSN[index] = Module_ContactlessCard;
		ctx->Ans.type[index] = csCCType;
		ctx->Ans.model[index] = csCCModel;
		ctx->Ans.version[index] = csCCVersion;
		ctx->Ans.state[index] = ccState;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("ContactlessCard, type:%s, model:%s, version:%s, state:%d", 
			csCCType.GetData(), csCCModel.GetData(), csCCVersion.GetData(), ccState);
		index++;
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardReadAdapterFSM::GetMaterialCount(SpReqAnsContext<CardReadAdapterService_GetMaterialCount_Req, CardReadAdapterService_GetMaterialCount_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwUsrErrCode = 0;
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_GetMaterialCountEx_Req req;
			CardIssuerStandService_GetMaterialCountEx_Ans ans;
			req.GetHopper.Copy(ctx->Req.GetHopper);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);

			ErrorCodeEnum eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->GetMaterialCountEx(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.captured = ans.captured;
				ctx->Ans.hasHopper.Copy(ans.hasHopper);
				ctx->Ans.CardBoxNo.Copy(ans.CardBoxNo);
				ctx->Ans.PsbCode.Copy(ans.PsbCode);
				ctx->Ans.PsbName.Copy(ans.PsbName);
				ctx->Ans.Maintainer.Copy(ans.Maintainer);
				ctx->Ans.CardInit.Copy(ans.CardInit);
				ctx->Ans.CardPercent.Copy(ans.CardPercent);
				ctx->Ans.remains.Copy(ans.remains);
				ctx->Ans.issued.Copy(ans.issued);
				ctx->Ans.mixed.Copy(ans.mixed);
				ctx->Ans.MaintainTime.Copy(ans.MaintainTime);
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetMaterialCount, CardIssuerStand GetMaterialCountEx failed return:%d", eErr);
				ctx->Answer(Error_Unexpect, dwUsrErrCode);
			}
		}
		else {
			CardIssuerStoreService_GetMaterialCountEx_Req req;
			CardIssuerStoreService_GetMaterialCountEx_Ans ans;
			req.GetHopper.Copy(ctx->Req.GetHopper);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);

			ErrorCodeEnum eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->GetMaterialCountEx(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.captured = ans.captured;
				ctx->Ans.hasHopper.Copy(ans.hasHopper);
				ctx->Ans.CardBoxNo.Copy(ans.CardBoxNo);
				ctx->Ans.PsbCode.Copy(ans.PsbCode);
				ctx->Ans.PsbName.Copy(ans.PsbName);
				ctx->Ans.Maintainer.Copy(ans.Maintainer);
				ctx->Ans.CardInit.Copy(ans.CardInit);
				ctx->Ans.CardPercent.Copy(ans.CardPercent);
				ctx->Ans.remains.Copy(ans.remains);
				ctx->Ans.issued.Copy(ans.issued);
				ctx->Ans.mixed.Copy(ans.mixed);
				ctx->Ans.MaintainTime.Copy(ans.MaintainTime);
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetMaterialCount, CardIssuerStore GetMaterialCountEx failed return:%d", eErr);
				ctx->Answer(Error_Unexpect, dwUsrErrCode);
			}
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetMaterialCountEx is err, session is not ok");
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
int CCardReadAdapterFSM::SetMaterialCount(SpReqAnsContext<CardReadAdapterService_SetMaterialCount_Req, CardReadAdapterService_SetMaterialCount_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwUsrErrCode = 0;
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			CardIssuerStandService_SetMaterialCountEx_Req req;
			CardIssuerStandService_SetMaterialCountEx_Ans ans;
			req.SetCaptured = ctx->Req.SetCaptured;
			req.captured = ctx->Req.captured;
			req.SetHopper.Copy(ctx->Req.SetHopper);
			req.CardBoxNo.Copy(ctx->Req.CardBoxNo);
			req.PsbCode.Copy(ctx->Req.PsbCode);
			req.PsbName.Copy(ctx->Req.PsbName);
			req.Maintainer.Copy(ctx->Req.Maintainer);
			req.MaintainTime.Copy(ctx->Req.MaintainTime);
			req.CardInit.Copy(ctx->Req.CardInit);
			req.CardPercent.Copy(ctx->Req.CardPercent);
			req.remains.Copy(ctx->Req.remains);
			req.issued.Copy(ctx->Req.issued);
			req.mixed.Copy(ctx->Req.mixed);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			ErrorCodeEnum eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->SetMaterialCountEx(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SetMaterialCount, CardIssuerStand SetMaterialCountEx failed return:%d", eErr);
				ctx->Answer(Error_Unexpect, dwUsrErrCode);
			}
		}
		else {
			CardIssuerStoreService_SetMaterialCountEx_Req req;
			CardIssuerStoreService_SetMaterialCountEx_Ans ans;
			req.SetCaptured = ctx->Req.SetCaptured;
			req.captured = ctx->Req.captured;
			req.SetHopper.Copy(ctx->Req.SetHopper);
			req.CardBoxNo.Copy(ctx->Req.CardBoxNo);
			req.PsbCode.Copy(ctx->Req.PsbCode);
			req.PsbName.Copy(ctx->Req.PsbName);
			req.Maintainer.Copy(ctx->Req.Maintainer);
			req.MaintainTime.Copy(ctx->Req.MaintainTime);
			req.CardInit.Copy(ctx->Req.CardInit);
			req.CardPercent.Copy(ctx->Req.CardPercent);
			req.remains.Copy(ctx->Req.remains);
			req.issued.Copy(ctx->Req.issued);
			req.mixed.Copy(ctx->Req.mixed);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			ErrorCodeEnum eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->SetMaterialCountEx(req, ans, 10000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SetMaterialCount, CardIssuerStore SetMaterialCountEx failed return:%d", eErr);
				ctx->Answer(Error_Unexpect, dwUsrErrCode);
			}
		}
		
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SetMaterialCountEx is err, session is not ok");
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
int CCardReadAdapterFSM::GetSCIInfo(SpReqAnsContext<CardReadAdapterService_GetSCIInfo_Req, CardReadAdapterService_GetSCIInfo_Ans>::Pointer ctx)
{
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_GetSCIInfo_Req req;
			CardIssuerStandService_GetSCIInfo_Ans ans;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->GetSCIInfo(req, ans, 15000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.connected = ans.connected;
				ctx->Ans.DevSN = ans.DevSN;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSCIInfo, CardIssuerStand GetSCIInfo failed return:%d", eErr);
			}
			ctx->Answer(eErr);
		}
		else {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_GetSCIInfo_Req req;
			CardIssuerStoreService_GetSCIInfo_Ans ans;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->GetSCIInfo(req, ans, 15000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.connected = ans.connected;
				ctx->Ans.DevSN = ans.DevSN;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSCIInfo, CardIssuerStore GetSCIInfo failed return:%d", eErr);
			}
			ctx->Answer(eErr);
		}

	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSCIInfo is err, session is not ok");
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
int CCardReadAdapterFSM::OpenSafeLock(SpReqAnsContext<CardReadAdapterService_OpenSafeLock_Req, CardReadAdapterService_OpenSafeLock_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("OpenSafeLock is not deal with");
	ctx->Answer(Error_Unexpect);
	return 0;
}
int CCardReadAdapterFSM::MagTransferInit(SpReqAnsContext<CardReadAdapterService_MagTransferInit_Req, CardReadAdapterService_MagTransferInit_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Entity CardSwiper is not ok.");
	ctx->Answer(Error_Unexpect);
	return 0;
}
int CCardReadAdapterFSM::QueryConnInfo(SpReqAnsContext<CardReadAdapterService_QueryConnInfo_Req, CardReadAdapterService_QueryConnInfo_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Entity CardSwiper is not ok.");
	ctx->Answer(Error_Unexpect);
	return 0;
}
void CCardReadAdapterFSM::DoExit()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->Exit();
		}
		else {
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->Exit();
		}
		
	}
	if (IsContactlessCardSessionOK())
	{
		eErr = (*m_pContactless)(EntityResource::getLink().upgradeLink())->Exit();
	}
}
void CCardReadAdapterFSM::BroadcastReadICing(int status)
{
	ReadICing evt;
	evt.status = status;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("BroadcastReadICing, status:%d", status);
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(ReadICing), SP_MSG_SIG_OF(ReadICing), evt);
}
int CCardReadAdapterFSM::SAMICCommand(SpReqAnsContext<CardReadAdapterService_SAMICCommand_Req, CardReadAdapterService_SAMICCommand_Ans>::Pointer ctx)
{
	if (IsTheEntity(ctx->Req.module, Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_SAMICCommand_Req req;
			CardIssuerStandService_SAMICCommand_Ans ans;
			req.cmdType = ctx->Req.cmdType;
			req.param1.Copy(ctx->Req.param1);
			req.param2.Copy(ctx->Req.param2);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->SAMICCommand(req, ans, 50000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.ret1.Copy(ans.ret1);
				ctx->Ans.ret2.Copy(ans.ret2);
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SAMICCommand, CardIssuerStand SAMICCommand failed return:%d", eErr);

			}
			ctx->Answer(eErr);
			return 0;
		}
		else {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_SAMICCommand_Req req;
			CardIssuerStoreService_SAMICCommand_Ans ans;
			req.cmdType = ctx->Req.cmdType;
			req.param1.Copy(ctx->Req.param1);
			req.param2.Copy(ctx->Req.param2);
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->SAMICCommand(req, ans, 50000);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.ret1.Copy(ans.ret1);
				ctx->Ans.ret2.Copy(ans.ret2);
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SAMICCommand, CardIssuerStore SAMICCommand failed return:%d", eErr);

			}
			ctx->Answer(eErr);
			return 0;
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SAMICCommand param error or connection is failed:(module)%d", ctx->Req.module);
		ctx->Answer(Error_Param);
		return 1;
	}
}
int CCardReadAdapterFSM::QueryPrinterStatus(SpReqAnsContext<CardReadAdapterService_QueryPrinterStatus_Req, CardReadAdapterService_QueryPrinterStatus_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryPrinterStatus is not deal with");
	ctx->Answer(Error_Unexpect);
	return 0;
}
int CCardReadAdapterFSM::Print(SpReqAnsContext<CardReadAdapterService_Print_Req, CardReadAdapterService_Print_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Print is not deal with");
	ctx->Answer(Error_Unexpect);
	return 0;

}
int CCardReadAdapterFSM::QuerySCIList(SpReqAnsContext<CardReadAdapterService_QuerySCIList_Req, CardReadAdapterService_QuerySCIList_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwUsrErrCode = 0;
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QuerySCIList is not deal with");
	ctx->Answer(Error_Unexpect);
	return 0;

}
int CCardReadAdapterFSM::BindSCI(SpReqAnsContext<CardReadAdapterService_BindSCI_Req, CardReadAdapterService_BindSCI_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwUsrErrCode = 0;
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("BindSCI is not deal with");
	ctx->Answer(Error_Unexpect);
	return 0;

}
int CCardReadAdapterFSM::PreOnlineOnStore(SpReqAnsContext<CardReadAdapterService_PreOnlineOnStore_Req, CardReadAdapterService_PreOnlineOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//oilyang@20230525 to call heartbeat directly
	if (!CheckHBSessionOrToConnect())
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("While calling to PreOnlineOnStore, connect to HeartBeat failed.");
		ctx->Answer(Error_DevNotAvailable);
		return 0;
	}
	m_crossCtx = ctx;
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA errMsg(true);

	m_ullCrossStart = GetTickCountRVC();

	if (m_pHBClient != NULL)
	{
		HeartBeatService_CardActive_Req req;
		HeartBeatService_CardActive_Ans ans;
		req.type = 0;
		req.account = ctx->Req.account;
		req.term = ctx->Req.termNo;
		req.data = ctx->Req.businessData;
		req.slot = ctx->Req.slot;

		errMsg = CSimpleStringA::Format("<PreOnlineOnStore>, send CardActive, termNo:%s, slot:%d", req.term.GetData(), req.slot);
		LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Send_CardActive, errMsg.GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220327")("to call heartbeat CardActive");

		eErr = (*m_pHBClient)(EntityResource::getLink().upgradeLink())->CardActive(req, ans, 6000);
		if (eErr == Error_Succeed)
		{
			m_bCardActiveNotify = false;
			WaitCardActiveTask* pTask = new WaitCardActiveTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
		else
		{
			errMsg = CSimpleStringA::Format("CardActive Result(termNo:%s, slot:%d):%d(0x%x)", req.term.GetData(), req.slot, eErr, eErr);
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_PreOnline_Recv_CardActive, errMsg.GetData());
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("have send heartbeat CardActive");
	return 1;//维持s3状态，直到收到返回或超时
}
int CCardReadAdapterFSM::NotifyPreonline(SpReqAnsContext<CardReadAdapterService_NotifyPreonline_Req, CardReadAdapterService_NotifyPreonline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	UINT64 crossEnd = GetTickCountRVC();
	//? ? ? 为什么是110s，重试？从生产实际来看，在25s到40s之间，大部分在30s左右，需要和前端（65s）一致，改成60s oilyang@20221019
	//in 110 second 
	if (m_crossCtx != NULL)
	{
		if ((crossEnd - m_ullCrossStart) < 60 * 1000)
		{
			m_bCardActiveNotify = true;
			m_crossCtx->Ans.cardPos = ctx->Req.cardPos;
			m_crossCtx->Ans.findCard = ctx->Req.findCard;
			m_crossCtx->Ans.result = ctx->Req.data;
			CSimpleStringA outParam = CSimpleStringA::Format("NotifyPreOnline, cardPos:%d, findCard:%d, errCode:%d, userErrCode:%d", ctx->Req.cardPos, ctx->Req.findCard, ctx->Req.errCode, ctx->Req.reserved1[0]);
			LogWarn(Severity_Low, Error_Unexpect, CardIssuer_UserErrorCode_NotifyPreOnline_ParamInfo, outParam.GetData());
			//oilyang@20230629
			//compare with the "ctx->Req.errCode" or "ctx->Req.reserved1[0]" which is stand for UserErrorCode from CardStore
			if (ctx->Req.errCode == Error_Duplication || ctx->Req.reserved1[0] == CardReadAdapter_UserErrorCode_CardIssuer_Is_Working
				|| ctx->Req.reserved1[0] == CardIssuer_UserErrorCode_CardActive_CardStore_Issuing 
				|| ctx->Req.reserved1[0] == CardIssuerStore_UserErrorCode_CardActive_CardStore_Issuing)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA230Q")("卡库正在使用中");
				LogWarn(Severity_Low, Error_Unexpect, CardReadAdapter_UserErrorCode_CardIssuer_Is_Working, "卡库正在使用中");
				m_crossCtx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DupCallPreOnline_WhileInWorking);
			}
			else if (ctx->Req.errCode == Error_TimeOut)//CardStore process cost too long!
			{
				//DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA230W")("跨机时卡库处理耗时过长");
				//LogError(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CardStore_Reply_TooLong, "跨机时卡库处理耗时过长");
				m_crossCtx->Answer(Error_Unexpect, CardIssuer_UserErrorCode_CardStore_Reply_TooLong);
			}
			else if (ctx->Req.errCode == Error_NotExist)//heartbeat service can't find the dest terminal
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA230Y")("跨机时卡库不在线");
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_CardActive_CardStore_OffLine, "跨机时卡库不在线");
				m_crossCtx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_CardActive_CardStore_OffLine);
			}
			else if (ctx->Req.reserved1[0] == CardIssuer_UserErrorCode_DevOpen_Failed || ctx->Req.reserved1[0] == CardIssuerStore_UserErrorCode_DevOpen_Failed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA2311")("卡库卡机未成功打开");
				LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_DevOpen_Failed, "卡库卡机未成功打开");
				m_crossCtx->Answer(Error_DevNotAvailable, CardIssuer_UserErrorCode_DevOpen_Failed);
			}
			else
			{
				if (ctx->Req.errCode != Error_Succeed)
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327")("卡库异常:Req.errCode:%d,  userErrCode:%d(0x%x)", ctx->Req.errCode, ctx->Req.reserved1[0], ctx->Req.reserved1[0]);
					LogWarn(Severity_Middle, Error_Unexpect, CardReadAdapter_UserErrorCode_CardActive_Unexpect,
						CSimpleStringA::Format("卡库异常:Req.errCode:%d,  userErrCode:%d(0x%x)", ctx->Req.errCode, ctx->Req.reserved1[0], ctx->Req.reserved1[0]));
				}
				m_crossCtx->Answer((ErrorCodeEnum)ctx->Req.errCode, MapErrorCodeWhileCallStore(ctx->Req.reserved1[0]));

			}
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA2312")("超时后，才收到卡库返回");
			LogWarn(Severity_Middle, Error_Unexpect, CardIssuer_UserErrorCode_NotifyPreonline_Wait_TooLong, "CardStore return after timeout.");
		}
		m_crossCtx = NULL;
	}

	ctx->Answer(Error_Succeed);

	return 0;
}
int CCardReadAdapterFSM::QueryCardInfoOnStore(SpReqAnsContext<CardReadAdapterService_QueryCardInfoOnStore_Req, CardReadAdapterService_QueryCardInfoOnStore_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			DWORD dwUserErrorCode = 0;
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_QueryCardInfoOnStore_Req req;
			CardIssuerStandService_QueryCardInfoOnStore_Ans ans;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);

			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->QueryCardInfoOnStore(req, ans, INT_MAX / 2 - 5000, dwUserErrorCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.cardPos = ans.cardPos;
				ctx->Ans.findCard = ans.findCard;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfoOnStore, CardIssuerStand QueryCardInfoOnStore failed return:%d", eErr);
				ctx->Answer(eErr, dwUserErrorCode);
			}
		}
		else {
			DWORD dwUserErrorCode = 0;
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_QueryCardInfoOnStore_Req req;
			CardIssuerStoreService_QueryCardInfoOnStore_Ans ans;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);

			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->QueryCardInfoOnStore(req, ans, INT_MAX / 2 - 5000, dwUserErrorCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.cardPos = ans.cardPos;
				ctx->Ans.findCard = ans.findCard;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfoOnStore, CardIssuerStore QueryCardInfoOnStore failed return:%d", eErr);
				ctx->Answer(eErr, dwUserErrorCode);
			}
		}
	
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("QueryCardInfoOnStore is err, session is not ok");
		ctx->Answer(Error_DevNotAvailable, CardReadAdapter_UserErrorCode_PreOnline_CardIssuer_Not_Ok);
	}
	return 0;
}
int CCardReadAdapterFSM::GetAddCardInfo(SpReqAnsContext<CardReadAdapterService_GetAddCardInfo_Req, CardReadAdapterService_GetAddCardInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			DWORD dwUserErrorCode = 0;
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_GetAddCardInfo_Req req;
			CardIssuerStandService_GetAddCardInfo_Ans ans;
			req.isSync = ctx->Req.isSync;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->GetAddCardInfo(req, ans, 10000, dwUserErrorCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.account = ans.account;
				ctx->Ans.cardSerial = ans.cardSerial;
				ctx->Ans.count = ans.count;
				ctx->Ans.slot = ans.slot;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetAddCardInfo, CardIssuerStand GetAddCardInfo failed return:%d,%x", eErr, dwUserErrorCode);
				ctx->Answer(eErr, dwUserErrorCode);
			}
		}
		else {
			DWORD dwUserErrorCode = 0;
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_GetAddCardInfo_Req req;
			CardIssuerStoreService_GetAddCardInfo_Ans ans;
			req.isSync = ctx->Req.isSync;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->GetAddCardInfo(req, ans, 10000, dwUserErrorCode);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.account = ans.account;
				ctx->Ans.cardSerial = ans.cardSerial;
				ctx->Ans.count = ans.count;
				ctx->Ans.slot = ans.slot;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Answer(Error_Succeed);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetAddCardInfo, CardIssuerStore GetAddCardInfo failed return:%d,%x", eErr, dwUserErrorCode);
				ctx->Answer(eErr, dwUserErrorCode);
			}
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetAddCardInfo is err, session is not ok");
		ctx->Answer(Error_DevNotAvailable, CardReadAdapter_UserErrorCode_PreOnline_CardIssuer_Not_Ok);
	}
	return 0;
}
int CCardReadAdapterFSM::Test1(SpReqAnsContext<CardReadAdapterService_Test1_Req, CardReadAdapterService_Test1_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardReadAdapterFSM::Test2(SpReqAnsContext<CardReadAdapterService_Test2_Req, CardReadAdapterService_Test2_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Answer(Error_Succeed);
	return 0;
}
void CCardReadAdapterFSM::SelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}
int CCardReadAdapterFSM::CrossTermCall(SpReqAnsContext<CardReadAdapterService_CrossTermCall_Req, CardReadAdapterService_CrossTermCall_Ans>::Pointer cctx)
{
	ErrorCodeEnum eErr = Error_Deprecated;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossTermCall,type:%x", cctx->Req.type);
	cctx->Answer((ErrorCodeEnum)eErr);
	return 0;
}
void CCardReadAdapterFSM::CrossTermInvokeInfo(SpOnewayCallContext<CardReadAdapterService_CrossTermInvokeInfo_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("entity sn:%x,type:%d,errcode:%x", ctx->Info.nEntityID, ctx->Info.type, ctx->Info.result);
}
int CCardReadAdapterFSM::LocalCallHeartBeat(int method, CBlob &bbSend,bool bTwoWay)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("method id(type):%d", method);
	HeartBeatService_ClientBase* pClient = new HeartBeatService_ClientBase(GetEntityBase());
	if (pClient == NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("create HeartBeat client failed.GetLastError:%d", GetLastError());
		return -1;
	}
	ErrorCodeEnum eErr = Error_Unexpect;
	eErr = pClient->Connect();
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("client connect to HeartBeat failed:%x", eErr);
		return -1;
	}
	HeartBeatService_CrossTermCall_Req req;
	HeartBeatService_CrossTermCall_Ans ans;
	req.nEntityID = 0x21b;
	req.isTwoWay = bTwoWay;
	req.fromTerminalNo = m_terminalNo;
	GetAttachedTerminal(req.toTerminalNo);
	//req.toTerminalNo = "7717715004";
	req.param1 = "";
	req.param2 = "";
	req.paramX = bbSend;
	req.type = method;
	eErr = (*pClient)(EntityResource::getLink().upgradeLink())->CrossTermCall(req, ans, 20000);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossTermCall to HeartBeat from %s to %s, result:%x",
			req.fromTerminalNo.GetData(), req.toTerminalNo.GetData(), eErr);
	return 0;
}
bool CCardReadAdapterFSM::GetAttachedTerminal(CSimpleStringA &csTerm)
{
	return (Error_Succeed == GetEntityBase()->GetFunction()->GetSysVar("AttachedTerminal", csTerm));
}
void CCardReadAdapterFSM::CancelReadForEntity(ModuleType eModule)
{
	LOG_FUNCTION();
	if (IsTheEntity(eModule, Module_CardIssuer) && IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Set cancel read by ContactlessCard flag of CardIssuerStand.");
			CardIssuerStandService_SetSomeFlag_Req req;
			CardIssuerStandService_SetSomeFlag_Ans ans;
			req.IssueBusiness = 3;
			(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->SetSomeFlag(req, ans, 5000);
			(*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->CancelInsert();
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Set cancel read by ContactlessCard flag of CardIssuerStore.");
			CardIssuerStoreService_SetSomeFlag_Req req;
			CardIssuerStoreService_SetSomeFlag_Ans ans;
			req.IssueBusiness = 3;
			(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->SetSomeFlag(req, ans, 5000);
			(*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->CancelInsert();
		}

	}
	if (IsTheEntity(eModule, Module_ContactlessCard) && IsContactlessCardSessionOK())
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Cancel read by CardSwiper of ContactlessCard.");
		(*m_pContactless)(EntityResource::getLink().upgradeLink())->CancelInsert();
	}
}
int CCardReadAdapterFSM::PrintCardIm(SpReqAnsContext<CardReadAdapterService_PrintCardImmediately_Req, CardReadAdapterService_PrintCardImmediately_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_PrintCardImmediately_Req req;
			CardIssuerStandService_PrintCardImmediately_Ans ans;
			req.formFile = ctx->Req.formFile;
			req.printData = ctx->Req.printData;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			int timeout = 60000;
			if (ctx->Req.reserved1.GetCount() > 0 && ctx->Req.reserved1[0] > 50000 && ctx->Req.reserved1[0] < 200000)
				timeout = ctx->Req.reserved1[0];
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PrintCardIm, timeout:%d", timeout);
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->PrintCardImmediately(req, ans, timeout);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.ret = ans.ret;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PrintCardImmediately, CardIssuerStand PrintCardImmediately failed return:%d", eErr);
			}
			ctx->Answer(eErr);
			return 0;
		}
		else {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_PrintCardImmediately_Req req;
			CardIssuerStoreService_PrintCardImmediately_Ans ans;
			req.formFile = ctx->Req.formFile;
			req.printData = ctx->Req.printData;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			int timeout = 60000;
			if (ctx->Req.reserved1.GetCount() > 0 && ctx->Req.reserved1[0] > 50000 && ctx->Req.reserved1[0] < 200000)
				timeout = ctx->Req.reserved1[0];
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PrintCardIm, timeout:%d", timeout);
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->PrintCardImmediately(req, ans, timeout);
			if (eErr == Error_Succeed)
			{
				ctx->Ans.ret = ans.ret;
				ctx->Ans.reserved1.Copy(ans.reserved1);
				ctx->Ans.reserved2.Copy(ans.reserved2);
				ctx->Ans.reserved3.Copy(ans.reserved3);
				ctx->Ans.reserved4.Copy(ans.reserved4);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PrintCardImmediately, CardIssuerStore PrintCardImmediately failed return:%d", eErr);
			}
			ctx->Answer(eErr);
			return 0;
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PrintCardIm is err, session is not ok");
		ctx->Answer(Error_Param);
		return 1;
	}
}
int CCardReadAdapterFSM::QueryCIStatus(SpReqAnsContext<CardReadAdapterService_QueryCIStatus_Req, CardReadAdapterService_QueryCIStatus_Ans>::Pointer ctx)
{
	if (IsCardIssuerSessionOK())
	{
		if (!IsCardIssuerStore()) {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStandService_QueryCIStatus_Req req;
			CardIssuerStandService_QueryCIStatus_Ans ans;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			DWORD dwUsrErrCode = 0;
			eErr = (*m_pCardIssuer)(EntityResource::getLink().upgradeLink())->QueryCIStatus(req, ans, 5000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				if (ans.reserved1.GetCount() > 0)
					ctx->Ans.reserved1.Copy(ans.reserved1);
				if (ans.reserved2.GetCount() > 0)
					ctx->Ans.reserved2.Copy(ans.reserved2);
				if (ans.reserved3.GetCount() > 0)
					ctx->Ans.reserved3.Copy(ans.reserved3);
				if (ans.reserved4.GetCount() > 0)
					ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Ans.retainBin = ans.retainBin;
				if (ans.hopperNo.GetCount() > 0)
				{
					ctx->Ans.hopperNo.Copy(ans.hopperNo);
					ctx->Ans.hopperStatus.Copy(ans.hopperStatus);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("CardIssuerStand QueryCIStatus failed return:%d", eErr));
			}
			ctx->Answer(eErr, dwUsrErrCode);
			return 0;
		}
		else {
			ErrorCodeEnum eErr = Error_Unexpect;
			CardIssuerStoreService_QueryCIStatus_Req req;
			CardIssuerStoreService_QueryCIStatus_Ans ans;
			req.reserved1.Copy(ctx->Req.reserved1);
			req.reserved2.Copy(ctx->Req.reserved2);
			req.reserved3.Copy(ctx->Req.reserved3);
			req.reserved4.Copy(ctx->Req.reserved4);
			DWORD dwUsrErrCode = 0;
			eErr = (*m_pCardIssuerStore)(EntityResource::getLink().upgradeLink())->QueryCIStatus(req, ans, 5000, dwUsrErrCode);
			if (eErr == Error_Succeed)
			{
				if (ans.reserved1.GetCount() > 0)
					ctx->Ans.reserved1.Copy(ans.reserved1);
				if (ans.reserved2.GetCount() > 0)
					ctx->Ans.reserved2.Copy(ans.reserved2);
				if (ans.reserved3.GetCount() > 0)
					ctx->Ans.reserved3.Copy(ans.reserved3);
				if (ans.reserved4.GetCount() > 0)
					ctx->Ans.reserved4.Copy(ans.reserved4);
				ctx->Ans.retainBin = ans.retainBin;
				if (ans.hopperNo.GetCount() > 0)
				{
					ctx->Ans.hopperNo.Copy(ans.hopperNo);
					ctx->Ans.hopperStatus.Copy(ans.hopperStatus);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("CardIssuerStore QueryCIStatus failed return:%d", eErr));
			}
			ctx->Answer(eErr, dwUsrErrCode);
			return 0;
		}

	}
	return 0;
}
void CCardReadAdapterFSM::WaitCardActive()
{
	while (1)
	{
		if (m_bCardActiveNotify)
			break;
		UINT64 crossEnd = GetTickCountRVC();
		if ((crossEnd - m_ullCrossStart) < 62 * 1000)
			Sleep(1000);
		else {
			if (m_crossCtx != NULL)
			{
				FSMEvent* e = new FSMEvent(USER_EVT_PREONLINE_ON_STORE_FINISHED);
				PostEventFIFO(e);

				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode("QLR040220327").setResultCode("RTA2R03")("跨机激活未收到返回，请确认卡库或服务是否正常");
				m_crossCtx->Answer(Error_TimeOut, CardReadAdapter_UserErrorCode_HBService_No_Return);
				LogError(Severity_Middle, Error_Unexpect, CardReadAdapter_UserErrorCode_HBService_No_Return, "CardActive havn't return in 60s");
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("record for HealthManager test 1792 to kill CardIsser");
				break;
			}
		}
	}
}
bool CCardReadAdapterFSM::CheckHBSessionOrToConnect()
{
	if (m_pHBClient != NULL && !m_pHBClient->QuerySessionClosed())
		return true;
	else
	{
		ErrorCodeEnum eErr = Error_Unexpect;
		m_pHBClient = new HeartBeatService_ClientBase(GetEntityBase());
		if (m_pHBClient != NULL) {
			eErr = m_pHBClient->Connect();
			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("connect to HeartBeat failed:%d(0x%x)", eErr, eErr);
				return false;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("connect to HeartBeat suc.");
				return true;
			}
		}
		else
			return false;
	}
}