myvtm/Module/mod_cardissuer/mod_cardissuer.h

#include "CardIssuer_server_g.h"
#include "CardIssuer_def_g.h"
//#include "CardIssuerClass.h"
#include "CardIssuerFSM.h"
using namespace CardIssuer;

//#pragma comment(lib,"CardIssuer.lib")
class CCardIssuerEntity;

class CardIssuerServerSession : public CardIssuerService_ServerSessionBase
{
public:
	CardIssuerServerSession(CCardIssuerEntity* pEntity):m_pEntity(pEntity){}
	virtual ~CardIssuerServerSession(){}
	virtual void Handle_Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx);
	virtual void Handle_Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx);
	virtual void Handle_Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx);
	virtual void Handle_Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx);
	virtual void Handle_CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx);
	virtual void Handle_InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx);
	virtual void Handle_Issue(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx);
	virtual void Handle_PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx);
	virtual void Handle_PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx);
	virtual void Handle_Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx);	
	virtual void Handle_GetMaterialCount(SpReqAnsContext<CardIssuerService_GetMaterialCount_Req, CardIssuerService_GetMaterialCount_Ans>::Pointer ctx);
	virtual void Handle_SetMaterialCount(SpReqAnsContext<CardIssuerService_SetMaterialCount_Req, CardIssuerService_SetMaterialCount_Ans>::Pointer ctx);
	virtual void Handle_SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx);
	virtual void Handle_ReadEx(SpReqAnsContext<CardIssuerService_ReadEx_Req, CardIssuerService_ReadEx_Ans>::Pointer ctx);
	virtual void Handle_QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx);
	virtual void Handle_WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx);
	virtual void Handle_GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx);
	virtual void Handle_SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx);
	virtual void Handle_SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx);
	virtual void Handle_GetSCIInfo(SpReqAnsContext<CardIssuerService_GetSCIInfo_Req, CardIssuerService_GetSCIInfo_Ans>::Pointer ctx);
	virtual void Handle_IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx);
	virtual void Handle_OpenSafeLock(SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx);
	virtual void Handle_SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx);
	virtual void Handle_QueryPrinterStatus(SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx);
	virtual void Handle_Print(SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx);
	virtual void Handle_QuerySCIList(SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx);
	virtual void Handle_BindSCI(SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx);
	virtual void Handle_PreOnlineOnStore(SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx);
	virtual void Handle_NotifyPreonline(SpReqAnsContext<CardIssuerService_NotifyPreonline_Req, CardIssuerService_NotifyPreonline_Ans>::Pointer ctx);
	virtual void Handle_QueryCardInfoOnStore(SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx);
	virtual void Handle_GetAddCardInfo(SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req, CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx);
	virtual void Handle_GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx);
private:
	CCardIssuerEntity* m_pEntity;
};

class CCardIssuerEntity : public CEntityBase,public ISysVarListener
{
public:
	CCardIssuerEntity() :bInitialized(false)
	{
		//MessageBoxA(NULL, "", "", MB_OK);
	}
	virtual ~CCardIssuerEntity(){}
	virtual const char *GetEntityName() const { return "CardIssuer"; }
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		LOG_FUNCTION();
		//MessageBoxA(0,0,0,0);
		ErrorCodeEnum eStart = m_fsm.Init(this);
		if (eStart == Error_Succeed)
		{
		}
		GetFunction()->RegistSysVarEvent("UIState", this);
		pTransactionContext->SendAnswer(eStart);
		//ErrorCodeEnum Error = __OnStart(Error_Succeed);
		//pTransactionContext->SendAnswer(Error);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		ErrorCodeEnum Error = __OnStart(Error_Succeed);
		pTransactionContext->SendAnswer(Error);
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum Error = __OnPause(Error_Succeed,pTransactionContext);
		pTransactionContext->SendAnswer(Error); 
	}
	virtual ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError)
	{
		//LOG_FUNCTION();
		////MessageBoxA(0,0,0,0);
		//Init();
		//if (!bInitialized)
		//{
		//	Dbg("test.notinit");
		//	return Error_Unexpect;
		//}
		//HRESULT hr = m_pCardIss->SetCardInType(CI_CARD_IN_TYPE_ALL);
		//Dbg("setcardintype[%d]",hr);
		//if (hr != Error_Succeed)
		//	return ErrorCodeEnum(hr);		
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnPause(ErrorCodeEnum preOperationError, CSmartPointer<ITransactionContext> pTransactionContext)
	{
		//MessageBoxA(0,0,0,0);
		//Test();
		//TestMagCard();
		//TestRFCard();
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError)
	{
		return Error_Succeed;
	}
	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}
	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		Dbg("A new connecting request arrived.");
		m_bNewSessionInit = true;
		return new CardIssuerServerSession(this);
	}
	//bool Init()
	//{
	//	LOG_FUNCTION();
	//	if (CreateDevComponent((DeviceBaseClass *&)m_pCardIss) != Error_Succeed)
	//	{
	//		Dbg("创建cardiss设备模块失败");
	//		return false;
	//	}
	//	ErrorCodeEnum eErr = m_pCardIss->DevOpen(2,115200);
	//	if (eErr != Error_Succeed)
	//	{
	//		DevErrorInfo devErr;
	//		m_pCardIss->GetLastErr(devErr);
	//		Dbg("open failed %s",devErr.szErrMsg);
	//		return false;
	//	}
	//	return true;
		//CardIssuerInitParam cardIssInitParam;
		//cardIssInitParam.dwBaudRate = 115200;
		//cardIssInitParam.btPort = 2;
		//HRESULT hr = m_pCardIss->DevOpen(cardIssInitParam);
		//if (hr != Error_Succeed)
		//{
		//	Dbg("devopen failed[%d]",hr);
		//	return;
		//}
	//	bInitialized = true;
	//}
	void Insert(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_bNewSessionInit = false;
		m_fsm.SetExitFlag(false);
		CardAcceptEvent *e = new CardAcceptEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void Read(SpReqAnsContext<CardIssuerService_Read_Req, CardIssuerService_Read_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardReadEvent* e = new CardReadEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void ReadEx(SpReqAnsContext<CardIssuerService_ReadEx_Req, CardIssuerService_ReadEx_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardReadExEvent* e = new CardReadExEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void Capture(SpReqAnsContext<CardIssuerService_Capture_Req, CardIssuerService_Capture_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardCaptureEvent* e = new CardCaptureEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void Eject(SpReqAnsContext<CardIssuerService_Eject_Req, CardIssuerService_Eject_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardEjectEvent* e = new CardEjectEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void CancelInsert(SpOnewayCallContext<CardIssuerService_CancelInsert_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		CancelAcceptEvent *e = new CancelAcceptEvent();
		m_fsm.PostEventFIFO(e);
	}
	void InsertWaitMore(SpOnewayCallContext<CardIssuerService_InsertWaitMore_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (m_fsm.GetWaitFlag())
			m_fsm.SetWaitMore();
	}
	void Issue(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		CardIssueEvent *pEvt = new CardIssueEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req, CardIssuerService_PreOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (ctx->Req.reserved1.GetLength() > 0 && strnicmp("kaku#", (const char*)ctx->Req.reserved1, 5) == 0)
		{
			int state = m_fsm.GetFSMState();
			if (state == 9)
			{
				ctx->Answer(Error_BridgeNotOK);
				return;
			}
			else if (state != 2)
			{
				ctx->Answer(Error_InvalidState);
				return;
			}
		}
		PreOnlineEvent* e = new PreOnlineEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req, CardIssuerService_PostOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		PostOnlineEvent* e = new PostOnlineEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void Exit(SpOnewayCallContext<CardIssuerService_Exit_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_bNewSessionInit = false;
		FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
		m_fsm.PostEventFIFO(evt);
	}
	void GetMaterialCount(SpReqAnsContext<CardIssuerService_GetMaterialCount_Req, CardIssuerService_GetMaterialCount_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		GetMaterialEvent *pEvt = new GetMaterialEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetMaterialCount(SpReqAnsContext<CardIssuerService_SetMaterialCount_Req, CardIssuerService_SetMaterialCount_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		SetMaterialEvent *pEvt = new SetMaterialEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void QueryCardInfo(SpReqAnsContext<CardIssuerService_QueryCardInfo_Req, CardIssuerService_QueryCardInfo_Ans>::Pointer ctx)
	{
		if (m_bNewSessionInit)
		{
			Dbg("Throw exit event to start init by entity.");
			FSMEvent *pEvt = new FSMEvent(USER_EVT_EXIT);
			m_fsm.PostEventFIFO(pEvt);
			ctx->Ans.position = CI_MEDIA_NOTPRESENT;
			ctx->Answer(Error_Succeed);
		}
		else
		{
			ctx->Ans.position = m_fsm.QueryCardInfo();
			ctx->Answer(Error_Succeed);
		}
	}
	void WriteTrack(SpReqAnsContext<CardIssuerService_WriteTrack_Req, CardIssuerService_WriteTrack_Ans>::Pointer ctx)
	{
		CardWriteEvent *pEvt = new CardWriteEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetIssueFlag(SpOnewayCallContext<CardIssuerService_SetIssueFlag_Info>::Pointer ctx){ m_fsm.FrontSetIssueFlag(true); }
	void GetMaterialCountEx(SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		GetMaterialExEvent *pEvt = new GetMaterialExEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetMaterialCountEx(SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		SetMaterialExEvent *pEvt = new SetMaterialExEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SetSomeFlag(SpReqAnsContext<CardIssuerService_SetSomeFlag_Req, CardIssuerService_SetSomeFlag_Ans>::Pointer ctx)
	{
		Dbg("set issue flag to %d", ctx->Req.IssueBusiness);
		if (ctx->Req.IssueBusiness == 1)
			m_fsm.FrontSetIssueFlag(true);
		else if (ctx->Req.IssueBusiness == 0)
			m_fsm.FrontSetIssueFlag(false);
		else if (ctx->Req.IssueBusiness == 2)//oilyang@20170621 查询方向
		{
			ctx->Ans.reserved1.Init(1);
			ctx->Ans.reserved1[0] = (m_fsm.QueryIssueFlag() ? 0 : 1);//according to yzx
			Dbg("issue direction:%d",ctx->Ans.reserved1[0]);//if 0 capture card eles eject card
		}
		else if (ctx->Req.IssueBusiness == 3)//oilyang@20181210 
		{
			m_fsm.SetCancelByRFICFlag();
		}
		else if (ctx->Req.IssueBusiness == 4)//oilyang@20181220 取ic卡的卡号，不想拆包，调用这个接口获取
		{
			ctx->Ans.reserved2.Init(1);
			ctx->Ans.reserved2[0] = m_fsm.GetPreOnlineICCardNo();
		}
		if (ctx->Req.reserved1.GetCount() > 0)
		{
			Dbg("set hopper num:%d",ctx->Req.reserved1[0]);
			if (ctx->Req.reserved1[0] == 1)
				m_fsm.SetHopperNum(1);
			else if (ctx->Req.reserved1[0] == 3)
				m_fsm.SetHopperNum(3);
		}
		ctx->Answer(Error_Succeed);

	}
	void GetSCIInfo(SpReqAnsContext<CardIssuerService_GetSCIInfo_Req, CardIssuerService_GetSCIInfo_Ans>::Pointer ctx)
	{
		char *pDevSN = NULL;
		pDevSN = new char[32];
		ZeroMemory(pDevSN, 32);
		int ret = m_fsm.GetSCIInfo(pDevSN);
		if (ret < 0)
		{
			Dbg("wrong devsn ,ret %d",ret);
			ctx->Answer(Error_Unexpect);
			if (pDevSN != NULL)
				delete[]pDevSN;
			return;
		}
		ctx->Ans.connected = 1;
		ctx->Ans.DevSN = pDevSN;
		ctx->Answer(Error_Succeed);
		if (pDevSN != NULL)
			delete[]pDevSN;
	}
	void IssueEx(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx)
	{
		m_bNewSessionInit = false;
		CardIssueExEvent *pEvt = new CardIssueExEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void OpenSafeLock(SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx)
	{
		OpenSafeLockEvent *pEvt = new OpenSafeLockEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx)
	{
		SAMICCommandEvent *pEvt = new SAMICCommandEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void QueryPrinterStatus(SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx)
	{
		ctx->Answer(Error_NotImpl);
	}
	void Print(SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx)
	{
		PrintEvent *pEvt = new PrintEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void QuerySCIList(SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx)
	{
		QuerySCIListEvent *pEvt = new QuerySCIListEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void BindSCI(SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx)
	{
		BindSCIEvent *pEvt = new BindSCIEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void PreOnlineOnStore(SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx)
	{
		PreOnlineOnStoreEvent *pEvt = new PreOnlineOnStoreEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void NotifyPreonline(SpReqAnsContext<CardIssuerService_NotifyPreonline_Req, CardIssuerService_NotifyPreonline_Ans>::Pointer ctx)
	{
		m_fsm.NotifyPreOnline(ctx->Req.errCode,ctx->Req.findCard,ctx->Req.cardPos,ctx->Req.data);
	}
	void QueryCardInfoOnStore(SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx)
	{
		QueryCardInfoOnStoreEvent *pEvt = new QueryCardInfoOnStoreEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}
	void GetAddCardInfo(SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req, CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx)
	{
		m_fsm.GetAddCardInfo(ctx);
	}
	void GetDevInfo(SpReqAnsContext<CardIssuerService_GetDevInfo_Req, CardIssuerService_GetDevInfo_Ans>::Pointer ctx)
	{
		ctx->Ans.state = m_fsm.GetDevState();
		Dbg("GetDevInfo %d",ctx->Ans.state);
		ctx->Answer(Error_Succeed);
	}
	void GetSCINo(CSimpleStringA &sciNo)
	{
		m_fsm.GetSCINo(sciNo);
	}
	virtual void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName);
	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return true;}
protected:
private:
	CardIssuerClass* m_pCardIss;
	CCardIssuerFSM m_fsm;
	
	bool bInitialized,m_bNewSessionInit;
	//LONG m_lenAPDU;
	//BYTE m_APDUsendBuf[512];

private:
//	void ConstructAPDU(BYTE cls,BYTE ins,BYTE p1,BYTE p2,BYTE lc,LPBYTE data,LPBYTE le)
//{
//	LOG_FUNCTION();
//	m_lenAPDU = 0;
//	m_APDUsendBuf[0] = cls;
//	m_APDUsendBuf[1] = ins;
//	m_APDUsendBuf[2] = p1;
//	m_APDUsendBuf[3] = p2;
//	m_lenAPDU = 4;
//	if (lc != NULL && data != NULL)
//	{
//		m_APDUsendBuf[4] = lc;
//		m_lenAPDU++;
//		if (lc != 0)
//		{
//			memcpy(m_APDUsendBuf+m_lenAPDU,data,lc);
//			m_lenAPDU += lc;
//		}
//	}
//	if (le != NULL)
//		m_APDUsendBuf[m_lenAPDU++] = (*le);
//	if (!data)
//	{
//		delete[] data;
//		data = NULL;
//	}
//	Dbg("cmd len[%d]",m_lenAPDU);
//}
};