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_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_GetInputJS(SpReqAnsContext<PinPadService_GetInputJS_Req, PinPadService_GetInputJS_Ans>::Pointer ctx);
	void Handle_InputCancelJS(SpReqAnsContext<PinPadService_InputCancelJS_Req, PinPadService_InputCancelJS_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);
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) 
	{ 
		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*)
	{
		return new PinPadServerSession(this);
	}

	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 GetInputJS(SpReqAnsContext<PinPadService_GetInputJS_Req, PinPadService_GetInputJS_Ans>::Pointer ctx)
	{
		if (!m_fsm.GetDevInitFlag())
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else {
			m_fsm.SetJSCtx(ctx);
			GetInputJSEvent* e = new GetInputJSEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}
	void InputCancelJS(SpReqAnsContext<PinPadService_InputCancelJS_Req, PinPadService_InputCancelJS_Ans>::Pointer ctx)
	{
		if (!m_fsm.GetDevInitFlag())
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else if (_stricmp(m_fsm.GetCurrStateName(), "Input") != 0)
			ctx->Answer(Error_Unexpect, PinPad_UserErrorCode_NotInGetInput);
		else
		{
			InputCancelEvent* e = new InputCancelEvent();
			m_fsm.PostEventFIFO(e);
		}
	}
	void GetInputSM(SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctx)
	{
		if (!m_fsm.GetDevInitFlag())
		{
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
			LogWarn(Severity_Middle, Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed, "Open PinPad failed(GetInputSM)");
		}else{
			m_fsm.SetCtx(ctx);
			GetInputSMEvent* e = new GetInputSMEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}	
	}
	void LoadKeysSM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadService_LoadKeysSM_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag())
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else{
			LoadKeySMEvent *evt = new LoadKeySMEvent();
			evt->ctx = ctx;
			m_fsm.PostEventFIFO(evt);
		}
	}
	void EncryptDataSM(SpReqAnsContext<PinPadService_EncryptDataSM_Req, PinPadService_EncryptDataSM_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag())
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else{
			EncryptSMEvent *evt = new EncryptSMEvent();
			evt->ctx = ctx;
			m_fsm.PostEventFIFO(evt);
		}
	}
	void QueryFunc(SpReqAnsContext<PinPadService_QueryFunc_Req, PinPadService_QueryFunc_Ans>::Pointer ctx)
	{
		if (m_fsm.GetDevInitFlag())
		{
			m_fsm.GetEncryptKey(ctx->Ans.encryptkey, ctx->Ans.reserved1);
			ctx->Answer(Error_Succeed);
		}
		else{
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		}
	}
	void GetCheckCode(SpReqAnsContext<PinPadService_GetCheckCode_Req, PinPadService_GetCheckCode_Ans>::Pointer ctx)
	{
		if(!m_fsm.GetDevInitFlag())
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else{
			GetCheckCodeEvent *evt = new GetCheckCodeEvent();
			evt->ctx = ctx;
			m_fsm.PostEventFIFO(evt);
		}
	}
	void GetDevInfo(SpReqAnsContext<PinPadService_GetDevInfo_Req, PinPadService_GetDevInfo_Ans>::Pointer ctx)
	{
		if (m_fsm.GetDeviceOpeningFlag())
			ctx->Answer(Error_NotInit, PinPad_UserErrorCode_PinPad_DevOpenFailed);
		else if (m_fsm.GetDevInitFlag())
		{
			DevCategoryInfo devInfo;
			memset(&devInfo, 0, sizeof(devInfo));
			ErrorCodeEnum eGetDevInfo = m_fsm.GetDevInfo(devInfo);
			if (eGetDevInfo == Error_Succeed)
			{
				ctx->Ans.model = devInfo.szModel;
				ctx->Ans.type = devInfo.szType;
			}
			ctx->Ans.state = eGetDevInfo;
			ctx->Answer(Error_Succeed);
		}
		else
			ctx->Answer(Error_DevNotAvailable, PinPad_UserErrorCode_PinPad_DevOpenFailed);
	}
	void DoInputCancelJS(SpReqAnsContext<PinPadService_InputCancelJS_Req, PinPadService_InputCancelJS_Ans>::Pointer ctx);
	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;

};
struct InputCancelJSTask : public ITaskSp
{
	CPinPadEntity* pEntity;
	SpReqAnsContext<PinPadService_InputCancelJS_Req, PinPadService_InputCancelJS_Ans>::Pointer ctx;
	InputCancelJSTask(CPinPadEntity* entity) : pEntity(entity) {}
	void Process()
	{
		pEntity->DoInputCancelJS(ctx);
	}
};
#endif //__MOD_PINPAD_H