myvtm/Module/mod_pinpad/mod_PinPad.h

#ifndef __MOD_PINPAD_H
#define __MOD_PINPAD_H

#include "SpBase.h"
#include "PinPadFSM.h"
#include "DevEntityCommBase.hpp"

class PinPadServerSession : public PinPad::PinPadService_ServerSessionBase
{
public:
	PinPadServerSession(CPinPadEntity* pEntity):m_pEntity(pEntity){}
	virtual ~PinPadServerSession(){}
	void Handle_GetInput(SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx);
	void Handle_InputWaitMore(SpOnewayCallContext<PinPadService_InputWaitMore_Info>::Pointer ctx);
	void Handle_InputCancel(SpOnewayCallContext<PinPadService_InputCancel_Info>::Pointer ctx);
	void Handle_Exit(SpOnewayCallContext<PinPadService_Exit_Info>::Pointer ctx);
	void Handle_LoadKeys(SpReqAnsContext<PinPadService_LoadKeys_Req, PinPadService_LoadKeys_Ans>::Pointer ctx);
	void Handle_EncryptData(SpReqAnsContext<PinPadService_EncryptData_Req, PinPadService_EncryptData_Ans>::Pointer ctx);
	void Handle_GetDevInfo(SpReqAnsContext<PinPadService_GetDevInfo_Req, PinPadService_GetDevInfo_Ans>::Pointer ctx);
	void Handle_GetInputSM(SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctx);
	void Handle_LoadKeysSM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadService_LoadKeysSM_Ans>::Pointer ctx);
	void Handle_EncryptDataSM(SpReqAnsContext<PinPadService_EncryptDataSM_Req, PinPadService_EncryptDataSM_Ans>::Pointer ctx);
	void Handle_QueryFunc(SpReqAnsContext<PinPadService_QueryFunc_Req, PinPadService_QueryFunc_Ans>::Pointer ctx);
	void Handle_GetCheckCode(SpReqAnsContext<PinPadService_GetCheckCode_Req, PinPadService_GetCheckCode_Ans>::Pointer ctx);
	void Handle_CrossTermCall(SpReqAnsContext<PinPadService_CrossTermCall_Req, PinPadService_CrossTermCall_Ans>::Pointer ctx);
	void Handle_CrossTermInvokeInfo(SpOnewayCallContext<PinPadService_CrossTermInvokeInfo_Info>::Pointer ctx);
private:
	CPinPadEntity* m_pEntity;
};

class CPinPadEntity : public CDevAdptEntityBase, public ISysVarListener
{
public:
	CPinPadEntity():m_state(-1){}
	virtual ~CPinPadEntity(){}
	virtual const char *GetEntityName() const { return "PinPad"; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		GetVendorLibName();
		ErrorCodeEnum Error = __OnStart(Error_Succeed);
		GetFunction()->RegistSysVarEvent("UIState", this);
		pTransactionContext->SendAnswer(Error);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		//ErrorCodeEnum Error = __OnClose(Error_Succeed);
		//MessageBoxA(0,0,0,0);
		//m_fsm.OnExit();
		m_fsm.PostExitEvent();
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum Error = __OnPause(Error_Succeed);
		pTransactionContext->SendAnswer(Error); 
	}

	virtual ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError)
	{
		LOG_FUNCTION();
		//MessageBoxA(0,0,0,0);
		ErrorCodeEnum Error = m_fsm.Init(this);		
		return Error;
	}
	virtual ErrorCodeEnum __OnPause(ErrorCodeEnum preOperationError)
	{
		LOG_FUNCTION();
		return Error_Succeed;
	}

	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		LOG_FUNCTION();
		return new PinPadServerSession(this);
	}

	void GetInput(SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		GetInputEvent *e = new GetInputEvent();
		e->ctx = ctx;
		m_fsm.SetCtx(ctx,NULL);
		m_fsm.PostEventFIFO(e);
	}
	void InputWaitMore(SpOnewayCallContext<PinPadService_InputWaitMore_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		InputWaitingMoreEvent *e = new InputWaitingMoreEvent();
		m_fsm.PostEventFIFO(e);
	}

	void InputCancel(SpOnewayCallContext<PinPadService_InputCancel_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		InputCancelEvent *e = new InputCancelEvent();
		m_fsm.PostEventFIFO(e);
	}
	void Exit(SpOnewayCallContext<PinPadService_Exit_Info>::Pointer ctx)
	{
		//LOG_FUNCTION();
		FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
		m_fsm.PostEventFIFO(evt);
	}
	void LoadKeys(SpReqAnsContext<PinPadService_LoadKeys_Req, PinPadService_LoadKeys_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		LoadKeyEvent *evt = new LoadKeyEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}

	void EncryptData(SpReqAnsContext<PinPadService_EncryptData_Req, PinPadService_EncryptData_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		EncryptEvent *evt = new EncryptEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}
	void GetInputSM(SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		m_fsm.SetCtx(NULL, ctx, true);
		if (m_fsm.IsRVCIL())
		{
			CBlob bbSend;
			SpObject2Blob(ctx->Req, bbSend);
			//m_fsm.SaveCtx(PinPadService_Method_GetInputSM, ctx);
			//ctx.AddRef();
			m_fsm.LocalCallHeartBeat(PinPadService_Method_GetInputSM, bbSend,true);
		}
		else
		{
			GetInputSMEvent *e = new GetInputSMEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}
	void LoadKeysSM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadService_LoadKeysSM_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		LoadKeySMEvent *evt = new LoadKeySMEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}
	void EncryptDataSM(SpReqAnsContext<PinPadService_EncryptDataSM_Req, PinPadService_EncryptDataSM_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		EncryptSMEvent *evt = new EncryptSMEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}
	void QueryFunc(SpReqAnsContext<PinPadService_QueryFunc_Req, PinPadService_QueryFunc_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (m_fsm.GetDevInitFlag())
		{
			m_fsm.GetEncryptKey(ctx->Ans.encryptkey, ctx->Ans.reserved1);
			ctx->Answer(Error_Succeed);
		}
		else
			ctx->Answer(Error_DevNotAvailable);
	}
	void GetCheckCode(SpReqAnsContext<PinPadService_GetCheckCode_Req, PinPadService_GetCheckCode_Ans>::Pointer ctx)
	{
		GetCheckCodeEvent *evt = new GetCheckCodeEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}
	void CrossTermCall(SpReqAnsContext<PinPadService_CrossTermCall_Req, PinPadService_CrossTermCall_Ans>::Pointer ctx)
	{
		m_fsm.CrossTermCall(ctx);
	}
	void CrossTermInvokeInfo(SpOnewayCallContext<PinPadService_CrossTermInvokeInfo_Info>::Pointer ctx)
	{
		m_fsm.CrossTermInvokeInfo(ctx);
	}
	void GetDevInfo(SpReqAnsContext<PinPadService_GetDevInfo_Req, PinPadService_GetDevInfo_Ans>::Pointer ctx)
	{
		if(m_fsm.IsNeedPinPad())
		{
			DevCategoryInfo devInfo;
			if (m_fsm.GetDevInfo(devInfo))
			{
				ctx->Ans.model = devInfo.szModel;
				ctx->Ans.type = devInfo.szType;
				Dbg("szModel:%s", (const char*)ctx->Ans.model);
			}
			ctx->Ans.state = devInfo.eState;
		}
		else // 回单打印设备 --Josephus at 8:08:22 201746
		{
			ctx->Ans.model = "";
			ctx->Ans.type = "";
			ctx->Ans.state = DEVICE_STATUS_NORMAL;
		}
		ctx->Answer(Error_Succeed);
	}
	bool GetDevInitInfo() { return m_fsm.GetDevInitFlag(); }
	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;}
	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}
protected:
private:
	CPinPadFSM m_fsm;
	int m_state;

};

#endif //__MOD_PINPAD_H