myvtm/Module/mod_cardswiper/CardSwiperFSM.h

#ifndef __CARD_SWIPER_FSM_H
#define __CARD_SWIPER_FSM_H

#pragma once
#include "stdafx.h"
#include "SpFSM.h"
#include "sm2.h"
#include "sm3.h"
#include "public.h"
#include "EventCode.h"
#include "CardSwiper_UserErrorCode.h"

#include "HealthManager_client_g.h"
#include "HealthManager_def_g.h"
using namespace HealthManager;

#include "PinPad_client_g.h"
using namespace PinPad;

#include "DevFSMCommBase.hpp"

class HealthMngClient : public HealthManagerService_ClientBase
{
public:
	HealthMngClient(CEntityBase* pEntity);
};

const int ONE_K = 1024;

const int FAILED_MAXTIMES_TO_RESET = 2;

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_CANCELINSERT,
	USER_EVT_GET_MATERIAL,
	USER_EVT_SET_MATERIAL,
	USER_EVT_QUERY_CARD_INFO,
	USER_EVT_QUERY_CARD_INFO_FINISHED,
	USER_EVT_MAGDATA_TRANSFER_INIT,
	USER_EVT_MAGDATA_TRANSFER_INIT_FINISHED,
	USER_EVT_MAGDATA_TRANSFER_INIT_V2,
	USER_EVT_MAGDATA_TRANSFER_INIT_V2_FINISHED,
	USER_EVT_DEV_DISCONNECTED,
	USER_EVT_DEV_CONNECTED,
	USER_EVT_WAITREMOVE,
	USER_EVT_WAITTODIE,
	USER_EVT_WAITTODIE_TIMEOUT,
	USER_EVT_ENCRYPTED_CHANNEL,
	USER_EVT_QUERY_FWB_LIST,
	USER_EVT_QUERY_FWB_LIST_FINISHED,
	USER_EVT_BIND_FWB,
	USER_EVT_BIND_FWB_FINISHED,
};
struct FWBRecord
{
	CSimpleStringA name;
	CSimpleStringA remoteMac;
};
#include "CardSwiper_server_g.h"
#include "CardSwiper_msg_g.h"
#include "CardSwiperClass.h"
#include "CardAssist.h"
#include "ICDataElement.h"
using namespace CardSwiper;
#include "AccessAuthorization_client_g.h"
using namespace AccessAuthorization;
#include "DevErrorCode.h"

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

class CCardSwiperEntity;
class CCardSwiperFSM;

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
};
class CardReadEvent : public FSMEvent
{
public:
	CardReadEvent() : FSMEvent(USER_EVT_READ){}
	~CardReadEvent(){}
	SpReqAnsContext<CardSwiperService_Read_Req,CardSwiperService_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<CardSwiperService_Read_Req,CardSwiperService_Read_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			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<CardSwiperService_PreOnline_Req,CardSwiperService_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<CardSwiperService_PostOnline_Req,CardSwiperService_PostOnline_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class QueryCardInfoEvent : public FSMEvent
{
public:
	QueryCardInfoEvent() : FSMEvent(USER_EVT_QUERY_CARD_INFO){}
	~QueryCardInfoEvent(){}
	SpReqAnsContext<CardSwiperService_QueryCardInfo_Req,CardSwiperService_QueryCardInfo_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
			ctx->Answer(Error_InvalidState);
	}
protected:
private:
};
class MagDataTransferInitEvent : public FSMEvent
{
public:
	MagDataTransferInitEvent() : FSMEvent(USER_EVT_MAGDATA_TRANSFER_INIT){}
	~MagDataTransferInitEvent(){}
	SpReqAnsContext<CardSwiperService_MagTransferInit_Req,CardSwiperService_MagTransferInit_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("mag data transfer init unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class MagDataTransferInitFinishedEvent : public FSMEvent
{
public:
	MagDataTransferInitFinishedEvent() : FSMEvent(USER_EVT_MAGDATA_TRANSFER_INIT_FINISHED){}
	~MagDataTransferInitFinishedEvent(){}
	SpReqAnsContext<CardSwiperService_MagTransferInit_Req,CardSwiperService_MagTransferInit_Ans>::Pointer ctx;
	virtual void OnUnhandled() 
	{
		if (ctx != NULL)
		{
			Dbg("card read unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
protected:
private:
};
class QueryFWBListEvent : public FSMEvent
{
public:
	QueryFWBListEvent() : FSMEvent(USER_EVT_QUERY_FWB_LIST) {}
	~QueryFWBListEvent() {}
	SpReqAnsContext<CardSwiperService_QueryFWBList_Req, CardSwiperService_QueryFWBList_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("query fwb list unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class BindFWBEvent : public FSMEvent
{
public:
	BindFWBEvent() : FSMEvent(USER_EVT_BIND_FWB) {}
	~BindFWBEvent() {}
	SpReqAnsContext<CardSwiperService_BindFWB_Req, CardSwiperService_BindFWB_Ans>::Pointer ctx;
	virtual void OnUnhandled()
	{
		if (ctx != NULL)
		{
			Dbg("bind fwb unhandled");
			ctx->Answer(Error_InvalidState);
		}
	}
};
class CCardSwiperFSM : public CCommDevFSM<CCardSwiperFSM, CardSwiperClass>, public IFSMStateHooker
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11};
	BEGIN_FSM_STATE(CCardSwiperFSM)
		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,"Reading",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,"Failed",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"WaitingFetch",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s7,"MagTransInit",s7_on_entry,s7_on_exit,s7_on_event)
		FSM_STATE_ENTRY(s8,"DeviceOff",s8_on_entry,s8_on_exit,s8_on_event)
		FSM_STATE_ENTRY(s9,"WaitingRemove",s9_on_entry,s9_on_exit,s9_on_event)
		FSM_STATE_ENTRY(s10,"WaitingDie",s10_on_entry,s10_on_exit,s10_on_event)
		FSM_STATE_ENTRY(s11, "FWB", s11_on_entry, s11_on_exit, s11_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(CCardSwiperFSM,s0)
		FSM_RULE_ENTRY(s0,s1,USER_EVT_INIT,0)
		FSM_RULE_ENTRY(s0, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_INITFINISHED,0)
		FSM_RULE_ENTRY(s1, s5, USER_EVT_INITFINISHED, 5)
		//  --Josephus at 11:25:31 2016126
		FSM_RULE_ENTRY(s1,s8,USER_EVT_INITFINISHED,1)
		FSM_RULE_ENTRY(s1,s1, USER_EVT_INITFINISHED , 2)
		FSM_RULE_ENTRY(s1, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s4, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s2,s3,USER_EVT_READ,0)
		FSM_RULE_ENTRY(s2,s6,USER_EVT_EJECT,0)
		FSM_RULE_ENTRY(s2,s7,USER_EVT_MAGDATA_TRANSFER_INIT,0)
		FSM_RULE_ENTRY(s2, s11, USER_EVT_QUERY_FWB_LIST, 0)
		FSM_RULE_ENTRY(s2, s11, USER_EVT_BIND_FWB, 0)
		//  --Josephus at 11:27:29 2016126
		FSM_RULE_ENTRY(s2, s8, USER_EVT_DEV_DISCONNECTED, 0)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_READFINISHED,0)
		FSM_RULE_ENTRY(s3,s5,USER_EVT_READFINISHED,1)
		//FSM_RULE_ENTRY(s3,s4,USER_EVT_READFINISHED,2)
		FSM_RULE_ENTRY(s3, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s3,s2,USER_EVT_EXIT,0)
		FSM_RULE_ENTRY(s5, s0, USER_EVT_RESETFINISHED, 0)
		FSM_RULE_ENTRY(s5, s5, USER_EVT_RESETFINISHED, 1)
		FSM_RULE_ENTRY(s5, FSM_STATE_EXIT, USER_EVT_QUIT, 0)
		FSM_RULE_ENTRY(s6,s2,USER_EVT_EJECTFINISHED,0)
		FSM_RULE_ENTRY(s6,s2,USER_EVT_EJECTFINISHED,1)
		FSM_RULE_ENTRY(s6,s2,USER_EVT_EJECTFINISHED,2)
		FSM_RULE_ENTRY(s7,s2,USER_EVT_MAGDATA_TRANSFER_INIT_FINISHED,0)

		FSM_RULE_ENTRY(s5, s8, USER_EVT_DEV_DISCONNECTED, 0)
		FSM_RULE_ENTRY(s8, s5, USER_EVT_DEV_CONNECTED, 0)
		FSM_RULE_ENTRY(s8, s10, USER_EVT_DEV_CONNECTED, 1)
		//oilyang@20200407 s8 no need to change FSM state
		//FSM_RULE_ENTRY(s8, s11, USER_EVT_QUERY_FWB_LIST, 0)
		//FSM_RULE_ENTRY(s8, s11, USER_EVT_BIND_FWB, 0)
		FSM_RULE_ENTRY(s8, s0, USER_EVT_BIND_FWB_FINISHED, 0)
		FSM_RULE_ENTRY(s8, s2, USER_EVT_BIND_FWB_FINISHED, 2)
		FSM_RULE_ENTRY(s8, FSM_STATE_EXIT, USER_EVT_QUIT, 0)

		FSM_RULE_ENTRY(s5, s9, USER_EVT_WAITREMOVE, 0)
		FSM_RULE_ENTRY(s9, s8, USER_EVT_DEV_DISCONNECTED, 0)
		FSM_RULE_ENTRY(s9, s3, USER_EVT_READ, 0)
		FSM_RULE_ENTRY(s9, s6, USER_EVT_EJECT,0)
		FSM_RULE_ENTRY(s9, s7, USER_EVT_MAGDATA_TRANSFER_INIT,0)

		FSM_RULE_ENTRY(s10, s5, USER_EVT_WAITTODIE_TIMEOUT, 0)
		FSM_RULE_ENTRY(s5, s10, USER_EVT_WAITTODIE, 0)

		FSM_RULE_ENTRY(s11, s2, USER_EVT_QUERY_FWB_LIST_FINISHED, 2)
		FSM_RULE_ENTRY(s11, s0, USER_EVT_BIND_FWB_FINISHED, 0)
		FSM_RULE_ENTRY(s11, s2, USER_EVT_BIND_FWB_FINISHED, 2)
		END_FSM_RULE()

		CCardSwiperFSM() : 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_bCancelRead(false),m_csVendor(""),m_csMachineType(""),m_csSite("")
	, m_bReading(false), m_bNeedInitCh(true), m_connStatus(0), m_connChecking(false), m_periodResetCount(0)
	,m_dwPeriodResetTime(0), m_bCancelQueryConn(true), m_nLastSentMsg(-1), m_nReadFailCnt(0), m_nAAStatus(-1)
	, m_bResetInsertMore(false), m_csDevNo(""), m_bDoingBindFWB(false), m_bDevOpenEx(false),m_bBTScan(false)
	, m_bInMainPage(false),m_pubKey(nullptr)
	{
		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x202);
	}
	~CCardSwiperFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

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

	ErrorCodeEnum Load(CSimpleStringA csDevSN="");
	ErrorCodeEnum DataTransferInit();
	int Initial(CSimpleStringA csDevSN="",bool bInitChannel = true);
	bool GetDevStatus();
	/*
	-1: !Error_succeed
	3: CancelRead
	1: device failed
	4: timeout
	5: unknown or ID card. returned directly
	6: rebuild channel.
	\*/
	int ReadCard(SpReqAnsContext<CardSwiperService_Read_Req,CardSwiperService_Read_Ans>::Pointer ctx);
	int PreOnline(SpReqAnsContext<CardSwiperService_PreOnline_Req,CardSwiperService_PreOnline_Ans>::Pointer ctx);
	int PostOnline(SpReqAnsContext<CardSwiperService_PostOnline_Req,CardSwiperService_PostOnline_Ans>::Pointer ctx);
	int QueryCardInfo(SpReqAnsContext<CardSwiperService_QueryCardInfo_Req,CardSwiperService_QueryCardInfo_Ans>::Pointer ctx);
	int Reset();
	int Eject();
	int MagTransInit(SpReqAnsContext<CardSwiperService_MagTransferInit_Req,CardSwiperService_MagTransferInit_Ans>::Pointer ctx);
	//oiltmp 测试南天新加密通道
	int TransInitEx(bool bPassvie = false);
	int QueryFWBList(SpReqAnsContext<CardSwiperService_QueryFWBList_Req, CardSwiperService_QueryFWBList_Ans>::Pointer ctx,int fsmState);
	int BindFWB(SpReqAnsContext<CardSwiperService_BindFWB_Req, CardSwiperService_BindFWB_Ans>::Pointer ctx, int fsmState);
	int DetectCardTypeInfoByAccount(char *pAccount, int len, char *pT3=NULL, int t3Len=0);
	void LoadCMBBin();
	void SetExitFlag(bool bFlag=true){m_bExit = bFlag;}
	//LPIDCCARDDATA* GetIDCData(){return lppCardData;}
	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	int QueryConnInfo(int nFlag = 0);
	int QueryConnStatus(){ return m_connStatus; }
	DevStateEnum GetDevState(){ return m_eDevState;}
	void SetMainPageFlag(bool bValue) { m_bInMainPage = bValue; }

	int DoAbortRead();
	int SplitDevModelInfo();
	char *m_pubKey;//oiltest

	bool IsReading()
	{
		return m_bReading;
	}
	bool IsNeedInitChannel()
	{
		return m_bNeedInitCh;
	}
	ErrorCodeEnum CommitSuicide();
	ErrorCodeEnum CheckPinPadStatus();
	ErrorCodeEnum CheckDevCtrlStatus();
	ErrorCodeEnum CheckIDCerStatus();
	ErrorCodeEnum ReStartRelateEntity(LPCTSTR szEntityName = "");
	void ShowFatalrForConnect(LPCTSTR szMessage, BOOL bFatal = TRUE)
	{
		static int nDisConnectTimes = 0;
		if(bFatal)
		{
			nDisConnectTimes++;
			GetEntityBase()->GetFunction()->ShowFatalError(szMessage);
		}
		else if(nDisConnectTimes != 0)
		{
			nDisConnectTimes = 0;
			GetEntityBase()->GetFunction()->ShowFatalError(szMessage);
		}
		return;
	}
	void ShowFatalrForTransferChannel(int nChannelType, BOOL bFatal = TRUE)
	{
		static int nFailBuiltTimes = 0;
		CSimpleStringA csMessage;
		if(bFatal)
		{
			csMessage = CSimpleStringA::Format("CardSwiper加密传输通道V%d建立失败！", nChannelType);
			if(nFailBuiltTimes == 0)
			{
				GetEntityBase()->GetFunction()->ShowFatalError((LPCTSTR)csMessage);
				LogWarn(Severity_Middle, Error_NotInit, 
					nChannelType == 1 ? LOG_ERR_CARDSWIPER_BUILT_CHANNELV1_FAILED: LOG_ERR_CARDSWIPER_BUILT_CHANNELV2_FAILED,
					(LPCTSTR)csMessage);
			}
			else
			{
				LogWarn(Severity_Middle, Error_NotInit, 
					nChannelType == 1 ? LOG_ERR_CARDSWIPER_BUILT_CHANNELV1_FAILED: LOG_ERR_CARDSWIPER_BUILT_CHANNELV2_FAILED,
					(LPCTSTR)csMessage);
			}
			nFailBuiltTimes++;
			
		}
		else if(nFailBuiltTimes != 0)
		{
			csMessage = CSimpleStringA::Format("CardSwiper加密传输通道V%d建立成功！", nChannelType);
			nFailBuiltTimes = 0;
			GetEntityBase()->GetFunction()->ShowFatalError((LPCTSTR)csMessage);
		}
		return;
	}
	//The list of value of nInforType:
	//0: device is disconnected.
	//1: device is connected and available.
	//2: device is recovering.
	//3: device is unavailable and tell AM to remove the device off pad and connect it again.
	//4: device is not ready, need to wait a moment.
	//5: the ReadCardType of Swiping Magnetic stripe card is unavailable (Built Transfer encrypted channel failed).
	//6: The PinPad is unavailable.
	//7: The entity is going to die, the business have better do nothing.
	//8: device is still unavailalble after removing and connecting action.
	//9: device is busing reading card.
	//10:clear all the notify components. 
	void SendDevStatusMsg(int nInforType, bool bForce = false)
	{
		if(m_nLastSentMsg == nInforType && !bForce)
		{
			Dbg("Stop from sending msg %d.", nInforType);
			return;
		}

		if(nInforType == 10 && (m_nLastSentMsg == 2 || m_nLastSentMsg == 0))
		{
			Dbg("Needless to clear Lst: %d.", m_nLastSentMsg);
			return;
		}

		Dbg("================");
		switch (nInforType)
		{
		case 0:
			Dbg(" device is disconnected.");
			break;
		case 1:
			Dbg(" device is connected and available.");
			break;
		case 2:
			Dbg(" device is recovering.");
			break;
		case 3:
			Dbg(" device is unavailable and tell AM to remove the device off pad and connect it.");
			break;
		case 4:
			Dbg(" device is not ready, need to wait a moment.");
			break;
		case 5:
			Dbg(" the ReadCardType of Swiping Magnetic stripe card is unavailable (Built Transfer encrypted channel failed).");
			break;
		case 6:
			Dbg(" The PinPad is unavailable.");
			break;
		case 7:
			Dbg("The entity is going to die, the business have better do nothing.");
			break;
		case 8:
			Dbg(" device is still unavailalble after removing and connecting action.");
			break;
		case 9:
			Dbg("device is busing reading card.");
			nInforType = 1;
			Dbg("change Msg from 9 to 1 !!!");
			break;
		case 10:
			Dbg("clear all the notify components.");
			nInforType = 1;
			Dbg("change Msg from 10 to 1 !!!");
			break;
		default:
			Dbg(" Unknown information type %d.", nInforType);
			break;
		}
		m_nLastSentMsg = nInforType;
		Dbg("================");
		//if(nInforType == 0 || nInforType == 1)
		{
			Dbg("Really send msg %d.", nInforType);
			ConnectStatus evt;
			evt.status = nInforType;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(ConnectStatus), 
				SP_MSG_SIG_OF(ConnectStatus), evt);
		}
	}

	void RecordRunCfg(CSimpleStringA csState);

	void OnStateTrans(int iSrcState, int iDstState)
	{
		Dbg("State changes from %s[%d] to %s[%d].", 
			GetState(iSrcState)->pszName, iSrcState, GetState(iDstState)->pszName, iDstState);
		m_nLstSate = iSrcState;
	}

	ErrorCodeEnum GetAllInOneState(CSimpleStringA& csState)
	{
		csState = m_csAllInOneState;
		return Error_Succeed;
	}

	int GetAccessAuthState();
	//-1：初始状态 0: 准入成功， 1： 准入失败， 2： 未准入
	void SetAAState(int val);
	//-1：初始状态 0: 准入成功， 1： 准入失败， 2： 未准入
	int GetAAState()
	{
		if(m_nAAStatus == -1)
		{
			SetAAState(GetAccessAuthState());
		}
		return m_nAAStatus;
	}
	bool IsCryptMachinaType()
	{
		//oilyang@20200426 delete RVC.Desk2S
		if (_strnicmp(m_csMachineType, "RVC.PAD", strlen("RVC.PAD")) == 0 )
			//_strnicmp(m_csMachineType, "RVC.Desk2S", strlen("RVC.Desk2S")) == 0)
			return true;
		else
			return false;
	}
	void SetAcceptWaitMore(bool bValue);
	bool GetAcceptWaitMore() { return m_bWaitAccepteMore; };
	void InsertWaitMore();
	int FWBBluetoothScanTask();
	int nameToBthAddr(bool isSearchNearBy);//oiltest

protected:
	//LPIDCCARDDATA* lppCardData;
	int m_iInsertTries;
	int m_resetTries;
	int m_ejectTries;
private:
	//m_periodResetCount:一定时间内重置计数
	int m_resetTimes,m_testThreadCount,m_connStatus,m_periodResetCount;
	//m_dwPeriodResetTime:一定时间内第一次重启时间
	DWORD m_dwPeriodResetTime;
	lpCMBdecodeMag2 cmdDecodeMag2 = nullptr;
	lpCMBdecodeEx cmdDecodeEx = nullptr;
	bool m_devInit,m_bCancelAccept,m_bWaitingAccept,m_bWaitAccepteMore,m_bExit,m_bCancelRead
		, m_bSM, m_bOnlineOnly, m_bCDA, m_bReading,m_bNeedInitCh,m_connChecking,m_bResetInsertMore
		, m_bDoingBindFWB, m_bDevOpenEx, m_bBTScan, m_bInMainPage;
	
	ErrorCodeEnum m_testResult;

	bool m_bCancelQueryConn;
	int m_nLastSentMsg;
	CSimpleStringA m_csAllInOneState;
	int m_nLstSate;
	int m_nReadFailCnt;
	int m_nAAStatus;

	//int m_CardInit,m_CardRemains,m_CardIssued,m_CardCaptured,m_CardMixed,m_CardPercent;
	CardSwiperStatus devStatus;
	DevStateEnum m_eDevState;
	CCardProcess *m_pCardProcess;
	CardReadType m_eReadType;
	//	CardTypeEnum m_cardType;
	//about IC 
	//BYTE m_CPUType,m_AIP[2],m_appVersion[2],m_TSI[2],m_TVR[5],m_IACReject[5],m_IACOnline[5],m_IACDefault[5]
	//,m_P1,m_randData[4],m_CVR[4];
	//LPBYTE m_pTACReject,m_pIACOnline,m_pTACOnline,m_pIACDefault,m_pTACDefault;
	char *m_pDataToARQC;
	long xxTest;
	CSimpleStringA m_csVendor,m_csMachineType,m_csSite,m_csCM,m_csPM,m_csDevNo;
	WORD m_majorVerion, m_minorVerion;
	int m_version,m_batch;
	int m_nSplitRes;
	//BYTE m_APDUsendBuf[1024];
	//int m_lenAPDU;
	char m_AuthCode[2];
	//bool m_bOnlineOnly,m_bCDA;
	//ICData gpoData;
	//vector<ICData> m_vICData,m_vBusData;
	//vector<ADFRecord> m_vADFRec;
	vector<CMBBin> m_vBin;
	BYTE m_r1[ONE_K / 8], m_r2[ONE_K / 8], m_r3[ONE_K / 8], m_priKey[ONE_K / 2], m_devPubKey[ONE_K / 2];
	vector<FWBRecord> m_vFWBRecords;

	int SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData);
	//deprecated: please replace it with 'LogErrMsg'  [4/1/2020 10:51 @Gifur]
	//void LogErrInfo(const char*);
	void SwitchDataForSave(bool bSet,char *&pData);
	//deprecated: please replace it with 'LogErrMsg'  [4/1/2020 11:03 @Gifur]
	//void LogDevErrorInfo();
	int ProcessEnChannel(bool bIgnore = false);
	int IsValidFWBName(const char* pName, int len);
	ErrorCodeEnum AfterBindUpdateFWBNameToRunCfg(const char* name, bool bBind);
	void AddToFWBRecords(const char* name, const char* remoteMac, bool bFirst);
	void ClearFWBRecords();
	int ScanNearbyBTDevice();
	void ClearHandleOjbects();
	CSimpleStringA TransferAboutVendorShortName(CSimpleStringA name);
	DevCategoryInfo m_devCat;


};
struct InitTask : public ITaskSp
{
	CCardSwiperFSM* fsm;

	InitTask(CCardSwiperFSM* f) : fsm(f) {}

	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_INITFINISHED);
		e->param1 = fsm->Initial();
		fsm->PostEventFIFO(e);
	}
};


struct ReadTask : public ITaskSp
{
	SpReqAnsContext<CardSwiperService_Read_Req,CardSwiperService_Read_Ans>::Pointer ctx;
	CCardSwiperFSM* fsm;
	ReadTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->SetExitFlag(false);
		//fsm->SendDevStatusMsg(9);
		int tmpChannelTest = fsm->IsNeedInitChannel()? 1 : 0;
		if(tmpChannelTest)
		{
			CSimpleStringA csState = "";
			fsm->GetAllInOneState(csState);
			if(csState.IsStartWith("R", true))
			{
				fsm->SendDevStatusMsg(5);
			}
		}
		CardReadFinishedEvent *e = new CardReadFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->ReadCard(ctx);
		e->param2 = tmpChannelTest;
		fsm->PostEventFIFO(e);
	}
};

struct CancelReadTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	CancelReadTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		int nRes = fsm->DoAbortRead();
		if(nRes != -1)
		{
			int checkTimes = 0;
			int checkMaxTimes = 5;
			for(; checkTimes < checkMaxTimes; ++checkTimes)
			{
				if(!fsm->IsReading()) break;
				Sleep(1000);
			}

			if(checkTimes >= checkMaxTimes)
			{
				LogWarn(Severity_Middle, Error_Unexpect, 
					CardSwiper_UserErrorCode_Wait_Too_Much_Time_After_AbortRead,"Wait too much time after AbortRead op.");
			}
		}
	}
};

struct ExitTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	ExitTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->DoAbortRead();
	}
};
struct PreOnlineTask : public ITaskSp
{
	SpReqAnsContext<CardSwiperService_PreOnline_Req,CardSwiperService_PreOnline_Ans>::Pointer ctx;
	CCardSwiperFSM* fsm;
	PreOnlineTask(CCardSwiperFSM* 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<CardSwiperService_PostOnline_Req,CardSwiperService_PostOnline_Ans>::Pointer ctx;
	CCardSwiperFSM* fsm;
	PostOnlineTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_POSTONLINEFINISHED);
		e->param1 = fsm->PostOnline(ctx);
		fsm->PostEventFIFO(e);
	}
};



struct ResetTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	ResetTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		ResetFinishedEvent *e = new ResetFinishedEvent();
		e->param1 = fsm->Reset();
		fsm->PostEventFIFO(e);
	}
};
struct EjectTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	EjectTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *pEvt = new FSMEvent(USER_EVT_EJECTFINISHED);
		pEvt->param1 = fsm->Eject();
		fsm->PostEventFIFO(pEvt);
	}
};
struct QueryCardInfoTask : public ITaskSp
{
	SpReqAnsContext<CardSwiperService_QueryCardInfo_Req,CardSwiperService_QueryCardInfo_Ans>::Pointer ctx;
	CCardSwiperFSM* fsm;
	QueryCardInfoTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_QUERY_CARD_INFO_FINISHED);
		e->param1 = fsm->QueryCardInfo(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct MagTransInitTask : public ITaskSp
{
	SpReqAnsContext<CardSwiperService_MagTransferInit_Req,CardSwiperService_MagTransferInit_Ans>::Pointer ctx;
	CCardSwiperFSM* fsm;
	MagTransInitTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		MagDataTransferInitFinishedEvent *e = new MagDataTransferInitFinishedEvent();
		e->ctx = ctx;
		e->param1 = fsm->MagTransInit(ctx);
		fsm->PostEventFIFO(e);
	}
};
struct MagTransInitV2Task : public ITaskSp
{
	CCardSwiperFSM* fsm;
	MagTransInitV2Task(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent *e = new FSMEvent(USER_EVT_MAGDATA_TRANSFER_INIT_V2_FINISHED);
		e->param1 = fsm->TransInitEx(true);
		fsm->PostEventFIFO(e);
	}
};
struct QueryConnectTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	int nReserved;
	QueryConnectTask(CCardSwiperFSM* f) : fsm(f), nReserved(0) {}
	void Process()
	{
		Dbg("Start listerning devcic connect status.");
		fsm->QueryConnInfo(nReserved);
	}
};
struct InsertWaitMoreTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	InsertWaitMoreTask(CCardSwiperFSM* f) : fsm(f){}
	void Process()
	{
		fsm->InsertWaitMore();
	}
};
struct QueryFWBListTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	SpReqAnsContext<CardSwiperService_QueryFWBList_Req, CardSwiperService_QueryFWBList_Ans>::Pointer ctx;
	int fsmState;
	QueryFWBListTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_QUERY_FWB_LIST_FINISHED);
		e->param1 = fsm->QueryFWBList(ctx, fsmState);
		fsm->PostEventFIFO(e);
	}
};
struct BindFWBTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	SpReqAnsContext<CardSwiperService_BindFWB_Req, CardSwiperService_BindFWB_Ans>::Pointer ctx;
	int fsmState;
	BindFWBTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		FSMEvent* e = new FSMEvent(USER_EVT_BIND_FWB_FINISHED);
		e->param1 = fsm->BindFWB(ctx, fsmState);
		fsm->PostEventFIFO(e);
	}
};
struct FWBBluetoothScanTask : public ITaskSp
{
	CCardSwiperFSM* fsm;
	FWBBluetoothScanTask(CCardSwiperFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->FWBBluetoothScanTask();
	}
};
#endif //__CARD_SWIPER_FSM_H