myvtm/Module/mod_cardissuer/CardIssuerFSM.h

#ifndef __CARD_ISSUER_FSM_H
#define __CARD_ISSUER_FSM_H

#pragma once

#include "SpFSM.h"
#include "DevErrorCode.h"
#include "DevEntityCommBase.hpp"
#include "DevFSMCommBase.hpp"
#include "DeviceBaseHelper.h"
enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_INITFINISHED,
	USER_EVT_ACCEPT,
	USER_EVT_ACCEPT_CANCEL,
	USER_EVT_ACCEPTFINISHED,
	USER_EVT_ISSUE,
	USER_EVT_ISSUE_FINISHED,
	//USER_EVT_READ,
	USER_EVT_EJECT,
	USER_EVT_CAPTURE,
	//USER_EVT_READFINISHED,
	USER_EVT_EJECTFINISHED,
	USER_EVT_WAITFINISHED,
	USER_EVT_CAPTUREFINISHED,
	USER_EVT_WAITFETCHINGTIMEOUT,
	USER_EVT_PREONLINE,
	USER_EVT_POSTONLINE,
	USER_EVT_PREONLINEFINISHED,
	USER_EVT_POSTONLINEFINISHED,
	USER_EVT_RESET,
	USER_EVT_RESETFINISHED,
	USER_EVT_EXIT,
	USER_EVT_GET_MATERIAL,
	USER_EVT_SET_MATERIAL,
	USER_EVT_READEX,
	USER_EVT_READEX_FINISHED,
	USER_EVT_READ_NEW,
	USER_EVT_READ_NEW_FINISHED,
	USER_EVT_WRITE,
	USER_EVT_WRITE_FINISHED,
	USER_EVT_CONNECT,
	USER_EVT_CONNECT_FINISHED,
	USER_EVT_TRANSFER_TO_NOCFGDEV,
	USER_EVT_GET_MATERIAL_EX,
	USER_EVT_SET_MATERIAL_EX,
	USER_EVT_ISSUE_EX,
	USER_EVT_ISSUE_EX_FINISHED,
	USER_EVT_OPEN_SAFELOCK,
	USER_EVT_OPEN_SAFELOCK_FINISHED,
	USER_EVT_BLUETOOTH_CHECK_FINISHED,
	USER_EVT_BLUETOOTH_DISCONNECT,
	USER_EVT_SAM_IC,
	USER_EVT_SAM_IC_FINISHED,
	USER_EVT_QUERY_PRINT_STATUS,
	USER_EVT_QUERY_PRINT_STATUS_FINISHED,
	USER_EVT_PRINT,
	USER_EVT_PRINT_FINISHED,
	USER_EVT_QUERY_SCI_LIST,
	USER_EVT_QUERY_SCI_LIST_FINISHED,
	USER_EVT_BIND_SCI,
	USER_EVT_BIND_SCI_FINISHED,
	USER_EVT_BACK_TO_INIT,
	USER_EVT_PREONLINE_ON_STORE,
	USER_EVT_PREONLINE_ON_STORE_FINISHED,
	USER_EVT_QUERYCARDINFO_ON_STORE,
	USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED,
	USER_EVT_PRINT_CARD_IM,
	USER_EVT_PRINT_CARD_IM_FINISHED,
};
enum SAMICCommandType
{
	//SAM
	SAMICCommand_SAM_Select = 0,
	SAMICCommand_SAM_Active,
	SAMICCommand_SAM_Deactivate,
	SAMICCommand_SAM_WarmReset,
	SAMICCommand_SAM_QueryStatus,
	SAMICCommand_SAM_Command,
	//IC
	SAMICCommand_IC_Active = 100,
	SAMICCommand_IC_Deactivate,
	SAMICCommand_IC_WarmReset,
	SAMICCommand_IC_Command,
	SAMICCommand_RFIC_Active,
	SAMICCommand_RFIC_Deactivate,
	SAMICCommand_RFIC_Command,
};

#include "CardIssuer_server_g.h"

#include "CardIssuerClass.h"
#include "CardAssist.h"
#include "ICDataElement.h"
using namespace CardIssuer;
#include "GUIConsole_client_g.h"
using namespace GUIConsole;
#include "HeartBeat_client_g.h"
using namespace HeartBeat;
#include "AccessAuthorization_client_g.h"
using namespace AccessAuthorization;

typedef int(*lpCMBdecodeMag2)(char* Mag2Data, char * data);
typedef int(*lpCMBdecodeEx)( char* MagData, char * type, char * data);
typedef ErrorCodeEnum (*lpCreateDevCom)(DeviceBaseClass *&baseObj);
typedef ErrorCodeEnum (*lpReleaseDevCom)(DeviceBaseClass *&pBaseObj);
typedef int(__stdcall *pfEncryptDukptHSM)(unsigned char* EncryptedData, unsigned char* bdk, unsigned char* curksn, unsigned char* DecryptedData);
typedef int(__stdcall *pfGetEncrypedData)(unsigned char* BDK, unsigned char* KSN, unsigned char*random, unsigned char* result);
class CCardIssuerEntity;
class CCardIssuerFSM;
const int ONE_K = 1024;
const int HOPPER_NUM = 12;

struct Track2Data
{
	int status;
	CSimpleStringA t2Account;
	CSimpleStringA t2Region;
	CSimpleStringA t2CardSerial;
	CSimpleStringA t2CVC;
	CSimpleStringA t2ExpireDate;
};
struct CMBBin
{
	CSimpleStringA bin;//6 byte long
	bool bIC;//IC:true or mag:false
	bool bDC;//debit:true,credit:false
};
struct SCIRecord
{
	CSimpleStringA name;
	CSimpleStringA remoteMac;
};

class CardInitFinishedEvent : public FSMEvent
{
public:
	CardInitFinishedEvent() : FSMEvent(USER_EVT_INITFINISHED){}
	~CardInitFinishedEvent(){}
	SpReqAnsContext<CardIssuerService_Insert_Req,CardIssuerService_Insert_Ans>::Pointer ctx;

protected:
private:
};

class CardAcceptEvent : public FSMEvent
{
public:
	CardAcceptEvent() : FSMEvent(USER_EVT_ACCEPT){}
	~CardAcceptEvent(){}
	SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card accept unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class CardIssueEvent : public FSMEvent
{
public:
	CardIssueEvent() : FSMEvent(USER_EVT_ISSUE){}
	~CardIssueEvent(){}
	SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card issue unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class QueryCardInfoOnStoreEvent : public FSMEvent
{
public:
	QueryCardInfoOnStoreEvent() : FSMEvent(USER_EVT_QUERYCARDINFO_ON_STORE){}
	~QueryCardInfoOnStoreEvent(){}
	SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if(ctx != NULL)
		{
			Dbg("Operate CardStore unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};

class CancelAcceptEvent : public FSMEvent
{
public:
	CancelAcceptEvent() : FSMEvent(USER_EVT_ACCEPT_CANCEL){}
	~CancelAcceptEvent(){}
	//SpReqAnsContext<CardReaderService_CancelInsert_Req, CardReaderService_CancelInsert_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		Dbg("card cancel accept unhandled");
		//if (ctx)
		//{
		//	
		//	ctx->Answer(Error_InvalidState);
		//}
	}
};
//class CardReadEvent : public FSMEvent
//{
//public:
//	CardReadEvent() : FSMEvent(USER_EVT_READ){}
//	~CardReadEvent(){}
//	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
//	virtual void OnUnhandled() 
//	{
//		if (ctx != NULL)
//		{
//			Dbg("card read unhandled");
//			ctx->Answer(Error_InvalidState);
//		}
//	}
//protected:
//private:
//};
//class CardReadFinishedEvent : public FSMEvent
//{
//public:
//	CardReadFinishedEvent() : FSMEvent(USER_EVT_READFINISHED){}
//	~CardReadFinishedEvent(){}
//	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
//	virtual void OnUnhandled() 
//	{
//		if (ctx != NULL)
//		{
//			Dbg("card read unhandled");
//			ctx->Answer(Error_InvalidState);
//		}
//	}
//protected:
//private:
//};
class CardReadExEvent : public FSMEvent
{
public:
	CardReadExEvent() : FSMEvent(USER_EVT_READEX){}
	~CardReadExEvent(){}
	SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardReadExFinishedEvent : public FSMEvent
{
public:
	CardReadExFinishedEvent() : FSMEvent(USER_EVT_READEX_FINISHED){}
	~CardReadExFinishedEvent(){}
	SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardReadEvent : public FSMEvent
{
public:
	CardReadEvent() : FSMEvent(USER_EVT_READ_NEW){}
	~CardReadEvent(){}
	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardReadFinishedEvent : public FSMEvent
{
public:
	CardReadFinishedEvent() : FSMEvent(USER_EVT_READ_NEW_FINISHED){}
	~CardReadFinishedEvent(){}
	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled(new)");
			//ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class ResetDeviceEvent : public FSMEvent
{
public:
	ResetDeviceEvent() : FSMEvent(USER_EVT_RESET){}
	~ResetDeviceEvent(){}
protected:
private:
};
class ResetFinishedEvent : public FSMEvent
{
public:
	ResetFinishedEvent() : FSMEvent(USER_EVT_RESETFINISHED){}
	~ResetFinishedEvent(){}
protected:
private:
};
class PreOnlineEvent : public FSMEvent
{
public:
	PreOnlineEvent() : FSMEvent(USER_EVT_PREONLINE){}
	~PreOnlineEvent(){}
	SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class PostOnlineEvent : public FSMEvent
{
public:
	PostOnlineEvent() : FSMEvent(USER_EVT_POSTONLINE){}
	~PostOnlineEvent(){}
	SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardCaptureEvent : public FSMEvent
{
public:
	CardCaptureEvent() : FSMEvent(USER_EVT_CAPTURE){}
	~CardCaptureEvent(){}
	SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}

protected:
private:
};
class CardEjectEvent : public FSMEvent
{
public:
	CardEjectEvent() : FSMEvent(USER_EVT_EJECT){}
	~CardEjectEvent(){}
	SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class GetMaterialEvent : public FSMEvent
{
public:
	GetMaterialEvent() : FSMEvent(USER_EVT_GET_MATERIAL){}
	~GetMaterialEvent(){}
	SpReqAnsContext<CardIssuerService_GetMaterialCount_Req,CardIssuerService_GetMaterialCount_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};

class SetMaterialEvent : public FSMEvent
{
public:
	SetMaterialEvent() : FSMEvent(USER_EVT_SET_MATERIAL){}
	~SetMaterialEvent(){}
	SpReqAnsContext<CardIssuerService_SetMaterialCount_Req,CardIssuerService_SetMaterialCount_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardWriteEvent : public FSMEvent
{
public:
	CardWriteEvent() : FSMEvent(USER_EVT_WRITE){}
	~CardWriteEvent(){}
	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class CardWriteFinishedEvent : public FSMEvent
{
public:
	CardWriteFinishedEvent() : FSMEvent(USER_EVT_WRITE_FINISHED){}
	~CardWriteFinishedEvent(){}
	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled(new)");
			//ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class GetMaterialExEvent : public FSMEvent
{
public:
	GetMaterialExEvent() : FSMEvent(USER_EVT_GET_MATERIAL_EX){}
	~GetMaterialExEvent(){}
	SpReqAnsContext<CardIssuerService_GetMaterialCountEx_Req, CardIssuerService_GetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
}; 
class SetMaterialExEvent : public FSMEvent
{
public:
	SetMaterialExEvent() : FSMEvent(USER_EVT_SET_MATERIAL_EX){}
	~SetMaterialExEvent(){}
	SpReqAnsContext<CardIssuerService_SetMaterialCountEx_Req, CardIssuerService_SetMaterialCountEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class CardIssueExEvent : public FSMEvent
{
public:
	CardIssueExEvent() : FSMEvent(USER_EVT_ISSUE_EX){}
	~CardIssueExEvent(){}
	SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("card issue ex unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class OpenSafeLockEvent : public FSMEvent
{
public:
	OpenSafeLockEvent() : FSMEvent(USER_EVT_OPEN_SAFELOCK){}
	~OpenSafeLockEvent(){}
	SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("open safelock unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class SAMICCommandEvent : public FSMEvent
{
public:
	SAMICCommandEvent() : FSMEvent(USER_EVT_SAM_IC){}
	~SAMICCommandEvent(){}
	SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("sam/ic unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class QueryPrinterStatusEvent : public FSMEvent
{
public:
	QueryPrinterStatusEvent() : FSMEvent(USER_EVT_QUERY_PRINT_STATUS){}
	~QueryPrinterStatusEvent(){}
	SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("query printer status unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class PrintEvent : public FSMEvent
{
public:
	PrintEvent() : FSMEvent(USER_EVT_PRINT){}
	~PrintEvent(){}
	SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("print unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class QuerySCIListEvent : public FSMEvent
{
public:
	QuerySCIListEvent() : FSMEvent(USER_EVT_QUERY_SCI_LIST){}
	~QuerySCIListEvent(){}
	SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("query sci list unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class BindSCIEvent : public FSMEvent
{
public:
	BindSCIEvent() : FSMEvent(USER_EVT_BIND_SCI){}
	~BindSCIEvent(){}
	SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("bind sci unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
}; 
class PreOnlineOnStoreEvent : public FSMEvent
{
public:
	PreOnlineOnStoreEvent() : FSMEvent(USER_EVT_PREONLINE_ON_STORE){}
	virtual ~PreOnlineOnStoreEvent(){}
	SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("preonline on store unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class PrintCardImEvent : public FSMEvent
{
public:
	PrintCardImEvent() : FSMEvent(USER_EVT_PRINT_CARD_IM) {}
	~PrintCardImEvent() {}
	SpReqAnsContext<CardIssuerService_PrintCardImmediately_Req, CardIssuerService_PrintCardImmediately_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class PrintCardImFinishedEvent : public FSMEvent
{
public:
	PrintCardImFinishedEvent() : FSMEvent(USER_EVT_PRINT_CARD_IM_FINISHED) {}
	~PrintCardImFinishedEvent() {}
	SpReqAnsContext<CardIssuerService_PrintCardImmediately_Req, CardIssuerService_PrintCardImmediately_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
};
class CCardIssuerFSM : public FSMImpl<CCardIssuerFSM>
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11,s12,s13,s14,s15,s16,s17,s18};
	BEGIN_FSM_STATE(CCardIssuerFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"Initializing",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"Idle",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"Accepting",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"Hold",s4_on_entry,s4_on_exit,s4_on_event)
		FSM_STATE_ENTRY(s5,"Reading",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"Ejecting",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s7,"WaitFetching",s7_on_entry,s7_on_exit,s7_on_event)
		FSM_STATE_ENTRY(s8,"Capturing",s8_on_entry,s8_on_exit,s8_on_event)
		FSM_STATE_ENTRY(s9,"Failed",s9_on_entry,s9_on_exit,s9_on_event)
		FSM_STATE_ENTRY(s10,"Issuing",s10_on_entry,s10_on_exit,s10_on_event)
		FSM_STATE_ENTRY(s11,"Writing",s11_on_entry,s11_on_exit,s11_on_event)
		FSM_STATE_ENTRY(s12,"Connecting", s12_on_entry, s12_on_exit, s12_on_event)
		FSM_STATE_ENTRY(s13,"NoCfgDev", s13_on_entry, s13_on_exit, s13_on_event)
		FSM_STATE_ENTRY(s14, "SAMIC", s14_on_entry, s14_on_exit, s14_on_event)
		FSM_STATE_ENTRY(s15, "Other", s15_on_entry, s15_on_exit, s15_on_event)
		FSM_STATE_ENTRY(s16, "PreOnlineOnStore", s16_on_entry, s16_on_exit, s16_on_event)
		FSM_STATE_ENTRY(s17, "OperateCardStore", s17_on_entry, s17_on_exit, s17_on_event)
		FSM_STATE_ENTRY(s18, "PrintCardIm", s18_on_entry, s18_on_exit, s18_on_event)
		END_FSM_STATE()

	BEGIN_FSM_RULE(CCardIssuerFSM,s0)
	
		FSM_RULE_ENTRY(s0, s2, USER_EVT_TEST, 0)
		FSM_RULE_ENTRY(s0,s1,USER_EVT_INIT,0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s0, s12, USER_EVT_CONNECT, 0)
		FSM_RULE_ENTRY(s0, s13, USER_EVT_TRANSFER_TO_NOCFGDEV, 0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_INITFINISHED,0)
		FSM_RULE_ENTRY(s1,s9,USER_EVT_INITFINISHED,1)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2,s3,USER_EVT_ACCEPT,0)
//		FSM_RULE_ENTRY(s2,s9,USER_EVT_ACCEPT,1)
		FSM_RULE_ENTRY(s2, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2,s10,USER_EVT_ISSUE,0)
		FSM_RULE_ENTRY(s2, s10, USER_EVT_ISSUE_EX, 0)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_BLUETOOTH_DISCONNECT, 0)
		FSM_RULE_ENTRY(s2, s15, USER_EVT_QUERY_SCI_LIST, 0)
		FSM_RULE_ENTRY(s2, s15, USER_EVT_BIND_SCI, 0)
		FSM_RULE_ENTRY(s2, s16, USER_EVT_PREONLINE, 16)
		FSM_RULE_ENTRY(s2, s17, USER_EVT_QUERYCARDINFO_ON_STORE, 0)
		FSM_RULE_ENTRY(s3,s4,USER_EVT_ACCEPTFINISHED,0)
		FSM_RULE_ENTRY(s3,s9,USER_EVT_ACCEPTFINISHED,1)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_ACCEPTFINISHED,2)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_ACCEPTFINISHED,3)
		FSM_RULE_ENTRY(s3,s7,USER_EVT_ACCEPTFINISHED,4)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_BLUETOOTH_DISCONNECT, 0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_READEX,0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_READ_NEW,0)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_EJECT,0)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_EXIT,0)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_ACCEPT,0)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_EXIT,1)
		FSM_RULE_ENTRY(s4,s8,USER_EVT_CAPTURE,0)
		FSM_RULE_ENTRY(s4,s11,USER_EVT_WRITE,0)
		FSM_RULE_ENTRY(s4, s14, USER_EVT_SAM_IC, 0)
		FSM_RULE_ENTRY(s4, s18, USER_EVT_PRINT_CARD_IM, 0)
		FSM_RULE_ENTRY(s4, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4, s2, USER_EVT_ISSUE_EX_FINISHED, 2)
		FSM_RULE_ENTRY(s4, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
//		FSM_RULE_ENTRY(s5,s4,USER_EVT_READFINISHED,0)
//		FSM_RULE_ENTRY(s5,s9,USER_EVT_READFINISHED,1)
//		FSM_RULE_ENTRY(s5,s2,USER_EVT_READFINISHED,2)
		FSM_RULE_ENTRY(s5,s4,USER_EVT_READEX_FINISHED,0)
		FSM_RULE_ENTRY(s5,s9,USER_EVT_READEX_FINISHED,1)
		FSM_RULE_ENTRY(s5,s2,USER_EVT_READEX_FINISHED,2)
		FSM_RULE_ENTRY(s5,s4,USER_EVT_READ_NEW_FINISHED,0)
		FSM_RULE_ENTRY(s5,s9,USER_EVT_READ_NEW_FINISHED,1)
		FSM_RULE_ENTRY(s5,s2,USER_EVT_READ_NEW_FINISHED,2)
		FSM_RULE_ENTRY(s5, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s5, s4, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s6,s7,USER_EVT_EJECTFINISHED,0)
		FSM_RULE_ENTRY(s6,s9,USER_EVT_EJECTFINISHED,1)
		FSM_RULE_ENTRY(s6, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s7,s2,USER_EVT_WAITFINISHED,0)
		FSM_RULE_ENTRY(s7,s9,USER_EVT_WAITFINISHED,1)
		FSM_RULE_ENTRY(s7,s8,USER_EVT_WAITFINISHED,2)
		FSM_RULE_ENTRY(s7, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s8,s2,USER_EVT_CAPTUREFINISHED,0)
		FSM_RULE_ENTRY(s8,s9,USER_EVT_CAPTUREFINISHED,1)
		FSM_RULE_ENTRY(s8, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s9, s2, USER_EVT_RESETFINISHED, 0)
		FSM_RULE_ENTRY(s9, s0, USER_EVT_RESETFINISHED, 2)
		FSM_RULE_ENTRY(s9, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s9, s0, USER_EVT_BLUETOOTH_DISCONNECT, 0)
		FSM_RULE_ENTRY(s10,s4,USER_EVT_ISSUE_FINISHED,0)
		FSM_RULE_ENTRY(s10,s9,USER_EVT_ISSUE_FINISHED,1)
		FSM_RULE_ENTRY(s10,s2,USER_EVT_ISSUE_FINISHED,2)
		FSM_RULE_ENTRY(s10, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
		FSM_RULE_ENTRY(s10, s4, USER_EVT_ISSUE_EX_FINISHED, 0)
		FSM_RULE_ENTRY(s10, s9, USER_EVT_ISSUE_EX_FINISHED, 1)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_ISSUE_EX_FINISHED, 2)
		FSM_RULE_ENTRY(s10, s6, USER_EVT_ISSUE_EX_FINISHED, 6)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_ISSUE_EX_FINISHED, 8)
		FSM_RULE_ENTRY(s10, s2, USER_EVT_EXIT, 0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,0)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_WRITE_FINISHED,1)
		FSM_RULE_ENTRY(s12, s2, USER_EVT_CONNECT_FINISHED, 0)
		FSM_RULE_ENTRY(s12, s15, USER_EVT_QUERY_SCI_LIST, 0)
		FSM_RULE_ENTRY(s12, s15, USER_EVT_BIND_SCI, 0)
		FSM_RULE_ENTRY(s12, s0, USER_EVT_BACK_TO_INIT, 0)
		FSM_RULE_ENTRY(s13, s12, USER_EVT_CONNECT, 0)
		FSM_RULE_ENTRY(s13, s15, USER_EVT_QUERY_SCI_LIST, 0)
		FSM_RULE_ENTRY(s13, s15, USER_EVT_BIND_SCI, 0)
		FSM_RULE_ENTRY(s14, s4, USER_EVT_SAM_IC_FINISHED, 0)
		FSM_RULE_ENTRY(s15, s2, USER_EVT_QUERY_SCI_LIST_FINISHED, 2)
		FSM_RULE_ENTRY(s15, s12, USER_EVT_QUERY_SCI_LIST_FINISHED, 12)
		FSM_RULE_ENTRY(s15, s13, USER_EVT_QUERY_SCI_LIST_FINISHED, 13)
		FSM_RULE_ENTRY(s15, s13, USER_EVT_BIND_SCI_FINISHED, 0) //解绑成功
		FSM_RULE_ENTRY(s15, s0, USER_EVT_BIND_SCI_FINISHED, 1)  //绑定成功告知终端
		FSM_RULE_ENTRY(s15, s2, USER_EVT_BIND_SCI_FINISHED, 2)
		FSM_RULE_ENTRY(s15, s12, USER_EVT_BIND_SCI_FINISHED, 12)
		FSM_RULE_ENTRY(s15, s13, USER_EVT_BIND_SCI_FINISHED, 13)
		FSM_RULE_ENTRY(s16, s2, USER_EVT_PREONLINE_ON_STORE, 0)
		FSM_RULE_ENTRY(s16, s2, USER_EVT_PREONLINEFINISHED, 0)
		FSM_RULE_ENTRY(s17, s2, USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED, 0)
		FSM_RULE_ENTRY(s17, s2, USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED, 2)
		FSM_RULE_ENTRY(s18, s4, USER_EVT_PRINT_CARD_IM_FINISHED, 0)
		
	END_FSM_RULE()

	CCardIssuerFSM() : m_pCardIssuer(NULL),m_bCancelAccept(false),m_bWaitingAccept(false),
	m_bWaitAccepteMore(false),m_bExit(false),m_resetTimes(0),m_testResult(Error_Succeed)
	//,m_pTACReject(NULL),m_pIACOnline(NULL),m_pTACOnline(NULL),m_pIACDefault(NULL),m_pTACDefault(NULL)
	,m_bCDA(false),m_pDataToARQC(NULL),m_bSM(false),m_bOnlineOnly(false),m_bIssuingExit(false)
	,m_bCardIssued(false),m_issueStatusFromFile(1),m_issueStatus(1),m_currCardNo("")
	, m_captureReason(""), m_bCaptureCfgFlag(false), m_machineType(1)
	, m_currentHopper(1), m_hopperNum(1), EncypteDukptHSM(NULL), m_scanSlot(5), m_bBTConnected(false),m_bOpened(false)
	, m_bBTConncting(false), m_bBTChecking(0), m_bSettingMaterial(false), m_scanCount(0)
	, m_bDoingQueryListOrBindSCI(false), m_maxSlot(0), m_addCardNo(""), m_addCardSerial(""), m_hasCardWhileDevOpen(false)
	, m_bChannelOK(false), m_bForHangzhouSongruiMenjinka(false), m_bCancelByRFIC(false), m_bUnbindType3(false), m_devOpenFailedCount(0)
			, m_bInMainPage(false)
		{
			HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x203);
			cmdDecodeMag2 = NULL;
			cmdDecodeEx = NULL;
			m_aidList.Init(3);
			m_aidList[0] = "A000000333";
			m_aidList[1] = "A0000000108888";
			m_aidList[2] = "A000000790";
		}

	~CCardIssuerFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	//unsigned int sReady_on_event(FSMEvent* event) 
	//{
	//	if (event->iEvt == USER_EVT_READ) {
	//		// new read task
	//		
	//		event->SetHandled();
	//		return 0;
	//	}
	//}

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);
	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);
	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* event);
	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* event);
	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* event);
	void s8_on_entry();
	void s8_on_exit();
	unsigned int s8_on_event(FSMEvent* event);
	void s9_on_entry();
	void s9_on_exit();
	unsigned int s9_on_event(FSMEvent* event);
	void s10_on_entry();
	void s10_on_exit();
	unsigned int s10_on_event(FSMEvent* event);
	void s11_on_entry();
	void s11_on_exit();
	unsigned int s11_on_event(FSMEvent* event);
	void s12_on_entry();
	void s12_on_exit();
	unsigned int s12_on_event(FSMEvent* event);
	void s13_on_entry();
	void s13_on_exit();
	unsigned int s13_on_event(FSMEvent* event);
	void s14_on_entry();
	void s14_on_exit();
	unsigned int s14_on_event(FSMEvent* event);
	void s15_on_entry();
	void s15_on_exit();
	unsigned int s15_on_event(FSMEvent* event);
	void s16_on_entry();
	void s16_on_exit();
	unsigned int s16_on_event(FSMEvent* event);
	void s17_on_entry();
	void s17_on_exit();
	unsigned int s17_on_event(FSMEvent* event);
	void s18_on_entry();
	void s18_on_exit();
	unsigned int s18_on_event(FSMEvent* event);
	// 麓脫脭脣脨脨脢卤脤谩脠隆脡猫卤赂脨貌脕脨潞脜虏垄脟氓驴脮ROOT脜盲脰脙碌脛脨貌脕脨潞脜
	void Load();
	ErrorCodeEnum OpenDevice(BYTE btOpenType, const char *pDevSN);
	int Initial();
	bool GetDevStatus();
	int UnAcceptCard();
	int CaptureCard(SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx);
	int EjectCard(SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx);
	int WaitFetchingCard();
	//int ReadCard(SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx);
	int ReadCardEx(SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx);
	int ReadCard(SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx);
	int PreOnline(SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx);
	int PostOnline(SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx);
	int Reset();
	int InternalAcceptCard();
	int AcceptCard(SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx);
	int IssueCard(SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx, SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx);
	int WriteCard(SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx);
	//deprecate
	//void LogDevErrorInfo();

	bool GetWaitFlag(){return m_bWaitingAccept;}
	void SetWaitMore(){m_bWaitAccepteMore = true;}
	void SetExitFlag(bool bFlag=true){m_bExit = bFlag;}
	bool FSMSetIssueFlag(int value=1);
	void FrontSetIssueFlag(bool bValue = true){ FSMSetIssueFlag(bValue); }
	int QueryIssueFlag(){ return m_issueStatus; }
	bool SetCardCaptured(const int num,bool bNewClear=false);
	bool SetCardIssued(const int num,const int hopper);
	bool SetCardRemains(const int num, const int hopper,bool bInit = false);
	bool SetCardMixed(const int num, const int hopper);
	ErrorCodeEnum MachineMoveCardBackNotHold();
	ErrorCodeEnum MachineMoveCardFrontGate();
	int QueryPrinterStatus(SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx);
	int Print(SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx);
	//bool DetectIfICCard();
	
	int DetectCardTypeInfoByAccount(char *pAccount, int len, char *pT3 = NULL, int t3Len = 0);
	void LoadCMBBin();
	//LPIDCCARDDATA* GetIDCData(){return lppCardData;}
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	DevStateEnum GetDevState()
	{
		if ((m_eDevState == DEVICE_STATUS_NORMAL) 
			&& ((m_bHasHopper[0] && m_mixedEx[0] >= 3) || !m_bHasHopper[0])
			&& ((m_bHasHopper[1] && m_mixedEx[1] >= 3) || !m_bHasHopper[1])
			&& ((m_bHasHopper[2] && m_mixedEx[2] >= 3) || !m_bHasHopper[2]))
			return DEVICE_STATUS_MAINTAINCE;
		else
			return m_eDevState;
	}
	int QueryCardInfo();
	int ConnectSCI();
	int QueryIfCfgSCI();
	int SetDevStateAndSendMsg(const DevStateEnum eState, bool bForceSend = true);
	int DataTransferInitEx();
	int LoadSafeLockDll();
	int EncryptData(SCITempData ramData, SCITempData bdk, SCITempData curksn, SCITempData &encryptedData);
	int OpenSafeLock(SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx);
	int GetSCIInfo(char *&);
	int UpdateLocalRunCfg(CAutoArray<int> hopperArr);
	int SyncDataToDB(bool bMaintain[12],bool bSetCaptured=true);
	void SetHopperNum(int hopperNum);
	int BluetoothCheck();
	void DoExitWhenIdle();
	int SAMICCommand(SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx);
	void PeriodConnect(BOOL anotherThread = TRUE);
	int DetectBluetoothSCI();
	int DetectBluetoothSCIOnLinux();
	int QuerySCIList(SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx,const int);
	int BindSCI(SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx,const int);
	void GetSCINo(CSimpleStringA&);

	void oiltest();
	void oiltestSCI(bool bSCI = true);
	bool WriteSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char *cardSerial,int slot,bool bClear=false);
	bool ReadSlotInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &cardSerial, int slot, int &hasCard);
	bool WriteCardInfo(CSmartPointer<IConfigInfo> &cfgRun, const char *acc, const char* serial, int slot, bool bClear = false, bool bHasCard = false);
	bool ReadCardInfo(CSmartPointer<IConfigInfo> &cfgRun, CSimpleStringA &acc, CSimpleStringA &serial, int slot);
	int PreOnlineOnStore(SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx);
	void NotifyPreOnline(unsigned long errCode,unsigned long findCard, unsigned long cardPos, CSimpleStringA data);
	int IssueCardFromStore(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx,bool isSpec=false);
	int AddCardToStoreStepFirst(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx);
	int AddCardToStoreStepLast(SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctx);
	int FindFirstEmptySlot();
	bool IsValidSlotNum(const int slot);
	bool IsSlotHasCard(const int slot);
	bool OperateCardStore(CSmartPointer<IConfigInfo>&spConfigRun, int slot, int& status);
	void ReturnCardInfo(int slotNum, int status, CSmartPointer<IConfigInfo>&spConfigRun, SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx);
	void ClearLocalRecord(CSmartPointer<IConfigInfo>&spConfigRun);
	bool CheckHasPanKuRecord(CSmartPointer<IConfigInfo>&spConfigRun);
	void AfterPreOnlineOnStore(ErrorCodeEnum eErr,const int slot);
	int QueryCardInfoOnStore(SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx);
	void GetAddCardInfo(SpReqAnsContext<CardIssuerService_GetAddCardInfo_Req, CardIssuerService_GetAddCardInfo_Ans>::Pointer ctx);
	int PrintCardIm(SpReqAnsContext<CardIssuerService_PrintCardImmediately_Req, CardIssuerService_PrintCardImmediately_Ans>::Pointer ctx);
	void DecodeTracksData(const char *track2, DWORD dwT2size, const char *track3, DWORD dwT3size,char *&magData,bool bT2OK=true,bool bT3OK=true);
	int GetFSMState(){ return m_currentFSMState; }
	void GetCardInfo(int &findCard, int &cardPos){findCard = m_findCard; cardPos = m_cardPos;}
	int SplitDevModelInfo();
	void SetCancelByRFICFlag(bool bCancel = true) { m_bCancelByRFIC = bCancel; }
	CSimpleStringA GetPreOnlineICCardNo() { return m_currCardNo; }
	void CloseAndClearDevObj(bool bCheckConnecting = true, bool bCloseOnly = false);

	void SetMainPageFlag(bool bValue) { m_bInMainPage = bValue; }
	DWORD UpdateDEC(DWORD dwVal = 0)
	{
		int reserved = 0;
		reserved = (dwVal & 0xFC000) >> 14;
		HARDWARE_ENTITY_SET_DEVCODE(m_entCode, dwVal, reserved);
		return GetDEC();
	}
	DWORD GetDEC() const
	{
		return HARDWARE_ENTITY_MAKE_ERRORCODE(m_entCode);
	}
	DWORD GetAlarmDEC(DWORD dwValue = 0)
	{
		if (dwValue > 0)
			UpdateDEC(dwValue);
		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
		DWORD dwCode = 0;
		if ((m_entCode.dwVendorErroCode >> 20) == m_entCode.dwEntityId)
			dwCode = m_entCode.dwVendorErroCode;
		else
			dwCode = HARDWARE_ENTITY_MAKE_ERRORCODE_TO_BUSINESS(m_entCode);
		return dwCode;
	}
	DWORD AlarmDEC(const char* pMsgHead, ErrorCodeEnum eErrCode, DWORD defaultDevCode = 0) {
		WORD wdErrCode = 0;
		CSimpleStringA csErrMsg(true);
		ErrorCodeEnum ec = DeviceBaseHelper::GetAndSplitDevErrInfo(m_pCardIssuer, csErrMsg, wdErrCode,pMsgHead);
		if (ec == Error_Succeed && wdErrCode != 0) {
			//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
			if ((defaultDevCode >> 20) == m_entCode.dwEntityId)
				UpdateDEC(defaultDevCode);
			else
				UpdateDEC(wdErrCode);
		}
		else if (defaultDevCode != 0) {
			UpdateDEC(defaultDevCode);
		}
		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
		DWORD dwCode = GetAlarmDEC();
		LogErrMsg(pMsgHead, eErrCode, csErrMsg,dwCode, true);
		return dwCode;
	}
	DWORD AlarmDECToBusiness(const char* pMsgHead, ErrorCodeEnum eErrCode, DWORD defaultDevCode = 0){
		WORD wdErrCode = 0;
		CSimpleStringA csErrMsg(true);
		ErrorCodeEnum ec = DeviceBaseHelper::GetAndSplitDevErrInfo(m_pCardIssuer, csErrMsg, wdErrCode, pMsgHead);
		if (ec == Error_Succeed && wdErrCode != 0) {
			//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
			if ((defaultDevCode >> 20) == m_entCode.dwEntityId)
				UpdateDEC(defaultDevCode);
			else
				UpdateDEC(wdErrCode);
		}
		else if (defaultDevCode != 0) {
			UpdateDEC(defaultDevCode);
		}
		//oilyang@20200528 according the meeting result,throw a LogError while answering ctx
		//oilyang@20200525 if have been set ErrorCode of entity defined (not device),use it directly
		DWORD dwCode = GetAlarmDEC();
		LogErrMsg(pMsgHead, eErrCode, csErrMsg, dwCode, false,true);
		return dwCode;
	}
	void ClearRelatedDEC()
	{
		UpdateDEC();
		m_csAlarmMsg = "NO more information";
	}
	void LogErrMsg(const char *pMsgHead, ErrorCodeEnum eErrCode, const char*pMsgBody, DWORD defaultDevCode = 0, BOOL bAlarm = FALSE, BOOL bError = FALSE);

protected:
	//LPIDCCARDDATA* lppCardData;
	int m_iInsertTries;
	int m_resetTries;
	int m_ejectTries;
private:
	///
	int m_resetTimes;
#ifdef RVC_OS_WIN
	HMODULE m_hVerdorDll;
#else
	void* m_hVerdorDll;
#endif
	//GUIConsoleService_ClientBase *m_pGUIConsoleClient;
	lpCreateDevCom CreateDevComponent;
	lpReleaseDevCom ReleaseDevComponent;
	lpCMBdecodeMag2 cmdDecodeMag2;
	lpCMBdecodeEx cmdDecodeEx;	
	bool m_devInit,m_bCancelAccept,m_bWaitingAccept,m_bWaitAccepteMore,m_bExit,m_bSM
		,m_bOnlineOnly,m_bCDA,m_bIssuingExit,m_bCardIssued,m_bCaptureCfgFlag,m_bHasHopper[HOPPER_NUM]
		,m_bSettingMaterial,m_hasCardWhileDevOpen,m_bChannelOK,m_bCancelByRFIC, m_bInMainPage;
	ErrorCodeEnum m_testResult;
	bool m_bBTConncting, m_bBTConnected, m_bOpened,m_bUnbindType3;
	//m_CardInit,m_CardRemains,m_CardIssued,m_CardMixed,m_CardPercent
	int m_CardCaptured,m_issueStatusFromFile,m_issueStatus;
	//1：默认，2:便携式发卡器，3：未配置
	int m_machineType;
	WORD m_majorVerion, m_minorVerion;
	int m_port,m_baudRate,m_currentHopper,m_scanSlot,m_scanCount,m_devOpenFailedCount/*DevOpenEx连续失败次数*/;
	int m_maxSlot,m_findCard,m_cardPos,m_currentFSMState,m_maxRetainCount/*回收箱容量*/;
	CSimpleStringA m_CardBoxNoEx[HOPPER_NUM], m_PsbCodeEx[HOPPER_NUM], m_PsbNameEx[HOPPER_NUM], m_MaintainerEx[HOPPER_NUM],m_csMaintainTimeEx[HOPPER_NUM];
	int m_CardInitEx[HOPPER_NUM], m_CardPercentEx[HOPPER_NUM], m_remainsEx[HOPPER_NUM], m_issuedEx[HOPPER_NUM], m_mixedEx[HOPPER_NUM],m_hopperNum;
	DWORD m_MaintainTimeEx[HOPPER_NUM];
	BYTE m_connectType, m_r1[128], m_r2[128], m_r3[128], m_priKey[ONE_K / 2], m_devPubKey[ONE_K / 2], m_bdk[64], m_ksn[64];
	CardIssuerStatus m_devStatus;
	CardIssuerClass* m_pCardIssuer;
	DevStateEnum m_eDevState;
	CCardProcess *m_pCardProcess;
	CAutoArray<CSimpleStringA> m_aidList;
	pfEncryptDukptHSM EncypteDukptHSM;
	pfGetEncrypedData GetEncrypedData;
	char *m_pDataToARQC;
	long xxTest;
	CSimpleStringA m_currCardNo, m_captureReason, m_csMachineType, m_csSite, m_csDevSN, m_terminalNo,m_addCardNo,m_addCardSerial
		,m_csCM;
	char m_AuthCode[2];
	vector<CMBBin> m_vBin;
	vector<SCIRecord> m_vSCIRecords;
	bool m_bDoingQueryListOrBindSCI,m_bForHangzhouSongruiMenjinka;
	SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer m_crossCtx;
	UINT64 m_crossStart;
	int m_bBTChecking;
	int SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData);
	int SplitUnionPayTrack2(CSimpleStringA pTrack2,Track2Data &decodeData);
	//void LogErrInfo(const char*);
	bool JustReadCardNo();
	bool RegistCardWhileCaptureCard();
	bool IsValidCardNo(const char*,int);
	int IsValidSCIName(const char*, int);
	void AddToSCIRecords(const char *name, const char * remoteMac, bool bFirst);
	void ClearSCIRecords();
	ErrorCodeEnum AfterBindSyncData(const char*, bool bBind);
	ErrorCodeEnum AfterBindUpdateSCINameToRunCfg(const char *name, bool bBind);
	void GetVendorDllName(CSimpleStringA &dllName);
	bool AccountExchange(const char *origAcc, CSimpleStringA &acc,int dir=1);
	bool SetSlotFlag(int slot,bool bReset=false,bool bClear=false);
	void ClearAllLocalSlotInfo();
	bool LoadCMBPrint(CSimpleStringA csBinPath);
	DevCategoryInfo m_devCat;
	void ToLogWarnInfoAboutTerm();
	HardwareEntityCode m_entCode;
	CSimpleStringA m_csAlarmMsg,m_csVendorDllName;
};
struct InitTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	InitTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_INITFINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};
struct AcceptTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_Insert_Req, CardIssuerService_Insert_Ans>::Pointer ctx;
	AcceptTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_ACCEPTFINISHED);
		e->param1 = fsm->AcceptCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct IssueTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_Issue_Req, CardIssuerService_Issue_Ans>::Pointer ctx;
	SpReqAnsContext<CardIssuerService_IssueEx_Req, CardIssuerService_IssueEx_Ans>::Pointer ctxEx;
	IssueTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e;
		if (ctx != NULL)
			e = new FSMEvent(USER_EVT_ISSUE_FINISHED);
		else if (ctxEx != NULL)
			e = new FSMEvent(USER_EVT_ISSUE_EX_FINISHED);
		else
		{
			Dbg("IssueTask:ctx is null");
			return;
		}
		e->param1 = fsm->IssueCard(ctx,ctxEx);
		fsm->PostEventFIFO(e);
	}
};

struct QueryCardInfoOnStoreTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_QueryCardInfoOnStore_Req, CardIssuerService_QueryCardInfoOnStore_Ans>::Pointer ctx;
	QueryCardInfoOnStoreTask(CCardIssuerFSM* f) : fsm(f){}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent* e;
		if(ctx != NULL)
			e = new FSMEvent(USER_EVT_QUERYCARDINFO_ON_STORE_FINISHED);
		else
		{
			Dbg("QueryCardInfoOnStoreTask: ctx is null");
			return;
		}
		e->param1 = fsm->QueryCardInfoOnStore(ctx);
		fsm->PostEventFIFO(e);
	}
};

//struct ReadTask : public ITaskSp
//{
//	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
//	CCardIssuerFSM* fsm;
//	ReadTask(CCardIssuerFSM* f) : fsm(f) {}
//	void Process()
//	{
//		CardReadFinishedEvent *e = new CardReadFinishedEvent();
//		e->ctx = ctx;
//		e->param1 = fsm->ReadCard(ctx);
//		fsm->PostEventFIFO(e);
//	}
//};
struct ReadExTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_ReadEx_Req,CardIssuerService_ReadEx_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	ReadExTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		CardReadExFinishedEvent *e = new CardReadExFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->ReadCardEx(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct ReadTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_Read_Req,CardIssuerService_Read_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	ReadTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		CardReadFinishedEvent *e = new CardReadFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->ReadCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct PreOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_PreOnline_Req,CardIssuerService_PreOnline_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	PreOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_PREONLINEFINISHED);
		e->param1 = fsm->PreOnline(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct PostOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_PostOnline_Req,CardIssuerService_PostOnline_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	PostOnlineTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_POSTONLINEFINISHED);
		e->param1 = fsm->PostOnline(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct CaptureTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_Capture_Req,CardIssuerService_Capture_Ans>::Pointer ctx;
	CaptureTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_CAPTUREFINISHED);
		e->param1 = fsm->CaptureCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct EjectTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_Eject_Req,CardIssuerService_Eject_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	EjectTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_EJECTFINISHED);
		e->param1 = fsm->EjectCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct WaitFetchingTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	WaitFetchingTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_WAITFINISHED);
		e->param1 = fsm->WaitFetchingCard();
		fsm->PostEventFIFO(e);
	}
};
struct ResetTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	ResetTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		ResetFinishedEvent *e = new ResetFinishedEvent();
		e->param1 = fsm->Reset();
		fsm->PostEventFIFO(e);
	}
};
struct WriteTask : public ITaskSp
{
	SpReqAnsContext<CardIssuerService_WriteTrack_Req,CardIssuerService_WriteTrack_Ans>::Pointer ctx;
	CCardIssuerFSM* fsm;
	WriteTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		CardWriteFinishedEvent *e = new CardWriteFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->WriteCard(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct ConnectTask : public ITaskSp
{
	CCardIssuerFSM* fsm;

	ConnectTask(CCardIssuerFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_CONNECT_FINISHED);
		e->param1 = fsm->ConnectSCI();
		fsm->PostEventFIFO(e);
	}
};
struct PeirodConnectTask : public ITaskSp
{
	CCardIssuerFSM* fsm;

	PeirodConnectTask(CCardIssuerFSM* f) : fsm(f) {}

	void Process()
	{
		fsm->PeriodConnect(FALSE);
	}
};
struct OpenSafeLockTask : public ITaskSp
{
	CCardIssuerFSM* fsm;

	OpenSafeLockTask(CCardIssuerFSM* f) : fsm(f) {}
	SpReqAnsContext<CardIssuerService_OpenSafeLock_Req, CardIssuerService_OpenSafeLock_Ans>::Pointer ctx;
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_OPEN_SAFELOCK_FINISHED);
		e->param1 = fsm->OpenSafeLock(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct BluetoothCheckTask : public ITaskSp
{
	CCardIssuerFSM* fsm;

	BluetoothCheckTask(CCardIssuerFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_BLUETOOTH_CHECK_FINISHED);
		e->param1 = fsm->BluetoothCheck();
		fsm->PostEventFIFO(e);
	}
};
struct DoExitWhenIdleTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	DoExitWhenIdleTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->DoExitWhenIdle();
	}
};
struct SAMICCommandTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_SAMICCommand_Req, CardIssuerService_SAMICCommand_Ans>::Pointer ctx;
	SAMICCommandTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_SAM_IC_FINISHED);
		e->param1 = fsm->SAMICCommand(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct QueryPrinterStatusTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_QueryPrinterStatus_Req, CardIssuerService_QueryPrinterStatus_Ans>::Pointer ctx;
	QueryPrinterStatusTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->QueryPrinterStatus(ctx);
	}
};
struct PrintTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_Print_Req, CardIssuerService_Print_Ans>::Pointer ctx;
	PrintTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_PRINT_FINISHED);
		e->param1 = fsm->Print(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct QuerySCIListTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_QuerySCIList_Req, CardIssuerService_QuerySCIList_Ans>::Pointer ctx;
	int fsmState;
	QuerySCIListTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_QUERY_SCI_LIST_FINISHED);
		e->param1 = fsm->QuerySCIList(ctx, fsmState);
		fsm->PostEventFIFO(e);
	}
};
struct BindSCITask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_BindSCI_Req, CardIssuerService_BindSCI_Ans>::Pointer ctx;
	int fsmState;
	BindSCITask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_BIND_SCI_FINISHED);
		e->param1 = fsm->BindSCI(ctx,fsmState);
		fsm->PostEventFIFO(e);
	}
};
struct PreOnlineOnStoreTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_PreOnlineOnStore_Req, CardIssuerService_PreOnlineOnStore_Ans>::Pointer ctx;
	PreOnlineOnStoreTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_PREONLINE_ON_STORE_FINISHED);
		e->param1 = fsm->PreOnlineOnStore(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct PrintCardImTask : public ITaskSp
{
	CCardIssuerFSM* fsm;
	SpReqAnsContext<CardIssuerService_PrintCardImmediately_Req, CardIssuerService_PrintCardImmediately_Ans>::Pointer ctx;
	PrintCardImTask(CCardIssuerFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_PRINT_CARD_IM_FINISHED);
		e->param1 = fsm->PrintCardIm(ctx);
		fsm->PostEventFIFO(e);
	}
};
#endif //__CARD_ISSUER_FSM_H