myvtm/Module/mod_ContactlessCard/mod_ContactlessCard.h

#ifndef _MOD_CONTACTLESS_H
#define _MOD_CONTACTLESS_H
#pragma once
#include "stdafx.h"
#include "ContactlessFSM.h"
#include "DevEntityCommBase.hpp"
#include "modVer.h"

class CContactlessCardEntity;

class ContactlessCardServerSession : public ContactlessCardService_ServerSessionBase
{
public:
	ContactlessCardServerSession(CContactlessCardEntity* pEntity):m_pEntity(pEntity){}
	virtual ~ContactlessCardServerSession(){}
	virtual void Handle_Insert(SpReqAnsContext<ContactlessCardService_Insert_Req, ContactlessCardService_Insert_Ans>::Pointer ctx);
	virtual void Handle_CancelInsert(SpOnewayCallContext<ContactlessCardService_CancelInsert_Info>::Pointer ctx);
	virtual void Handle_InsertWaitMore(SpOnewayCallContext<ContactlessCardService_InsertWaitMore_Info>::Pointer ctx);
	virtual void Handle_PreOnline(SpReqAnsContext<ContactlessCardService_PreOnline_Req, ContactlessCardService_PreOnline_Ans>::Pointer ctx);
	virtual void Handle_PostOnline(SpReqAnsContext<ContactlessCardService_PostOnline_Req, ContactlessCardService_PostOnline_Ans>::Pointer ctx);
	virtual void Handle_Eject(SpReqAnsContext<ContactlessCardService_Eject_Req, ContactlessCardService_Eject_Ans>::Pointer ctx);
	virtual void Handle_Exit(SpOnewayCallContext<ContactlessCardService_Exit_Info>::Pointer ctx);
	virtual void Handle_QueryCardInfo(SpReqAnsContext<ContactlessCardService_QueryCardInfo_Req, ContactlessCardService_QueryCardInfo_Ans>::Pointer ctx);
	virtual void Handle_GetDevInfo(SpReqAnsContext<ContactlessCardService_GetDevInfo_Req, ContactlessCardService_GetDevInfo_Ans>::Pointer ctx);

	//new interface
	virtual void Handle_CancelReadJS(SpOnewayCallContext<ContactlessCardService_CancelReadJS_Info>::Pointer ctx);
	virtual void Handle_ReadJS(SpReqAnsContext<ContactlessCardService_ReadJS_Req, ContactlessCardService_ReadJS_Ans>::Pointer ctx);
	virtual void Handle_PostOnlineJS(SpReqAnsContext<ContactlessCardService_PostOnlineJS_Req, ContactlessCardService_PostOnlineJS_Ans>::Pointer ctx);
	virtual void Handle_EjectJS(SpReqAnsContext<ContactlessCardService_EjectJS_Req, ContactlessCardService_EjectJS_Ans>::Pointer ctx);
	virtual void Handle_QueryHasCardJS(SpReqAnsContext<ContactlessCardService_QueryHasCardJS_Req, ContactlessCardService_QueryHasCardJS_Ans>::Pointer ctx);

private:
	CContactlessCardEntity* m_pEntity;
};

class CContactlessCardEntity : public CDevAdptEntityBase, public ISysVarListener
{
public:
	CContactlessCardEntity()
	{
	}
	virtual ~CContactlessCardEntity(){}
	virtual const char *GetEntityName() const { return "ContactlessCard"; }
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		LOG_FUNCTION();

		ErrorCodeEnum eStart = m_fsm.Init(this);
		GetFunction()->RegistSysVarEvent("UIState", this);
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	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->SendAnswer(Error); 
	}
	virtual ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError)
	{	
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnPause(ErrorCodeEnum preOperationError)
	{
		return Error_Succeed;
	}
	virtual ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError)
	{
		return Error_Succeed;
	}

	void Insert(SpReqAnsContext<ContactlessCardService_Insert_Req, ContactlessCardService_Insert_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag()){
			ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_Read_OpenFailed);
			LogWarn(Severity_Middle, Error_DevNotAvailable, ContactlessCard_UserErrorCode_Read_OpenFailed, "ReadCard but DevOpen failed.");
		}
		else{
			m_fsm.SetExitFlag(false);
			CardAcceptEvent* e = new CardAcceptEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}

	void CancelInsert(SpOnewayCallContext<ContactlessCardService_CancelInsert_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag()){
			LogWarn(Severity_Middle, Error_DevNotAvailable, ContactlessCard_UserErrorCode_Cancel_OpenFailed, "CancelInsert but DevOpen failed.");
		}else{
			FSMEvent *evt = new FSMEvent(USER_EVT_ACCEPT_CANCEL);
			m_fsm.PostEventFIFO(evt);
		}
	}
	void InsertWaitMore(SpOnewayCallContext<ContactlessCardService_InsertWaitMore_Info>::Pointer ctx)
	{
		if (m_fsm.GetWaitFlag())
			m_fsm.SetWaitMore();
	}
	void PreOnline(SpReqAnsContext<ContactlessCardService_PreOnline_Req, ContactlessCardService_PreOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		PreOnlineEvent* e = new PreOnlineEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void PostOnline(SpReqAnsContext<ContactlessCardService_PostOnline_Req, ContactlessCardService_PostOnline_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		PostOnlineEvent* e = new PostOnlineEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void Eject(SpReqAnsContext<ContactlessCardService_Eject_Req, ContactlessCardService_Eject_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		CardEjectEvent* e = new CardEjectEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}

	void Exit(SpOnewayCallContext<ContactlessCardService_Exit_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if(!m_fsm.GetDevInitFlag()){
			LogWarn(Severity_Middle, Error_DevNotAvailable, ContactlessCard_UserErrorCode_Exit_OpenFailed, "Exit but DevOpen failed.");
		}else{
			FSMEvent *evt = new FSMEvent(USER_EVT_EXIT);
			m_fsm.PostEventFIFO(evt);
		}
	}

	void QueryCardInfo(SpReqAnsContext<ContactlessCardService_QueryCardInfo_Req, ContactlessCardService_QueryCardInfo_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		QueryCardInfoEvent* e = new QueryCardInfoEvent();
		e->ctx = ctx;
		m_fsm.PostEventFIFO(e);
	}
	void GetDevInfo(SpReqAnsContext<ContactlessCardService_GetDevInfo_Req, ContactlessCardService_GetDevInfo_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		ctx->Ans.state = m_fsm.GetDevState();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("GetDevInfo %d", ctx->Ans.state);

		if (m_fsm.GetDevInitingFlag()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo device is opening,state return 0");
			ctx->Ans.state = DEVICE_STATUS_NOT_READY;
			ctx->Answer(Error_NotInit, ContactlessCard_UserErrorCode_DevOpen_Failed);
		}
		else {
			if (!m_fsm.GetDevInitFlag()) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetDevInfo device is not open,state return 0");
				ctx->Ans.state = DEVICE_STATUS_NOT_READY;
				ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed);
			}
			else {
				ctx->Answer(Error_Succeed);
			}
		}
	}

	//new interface

	void CancelReadJS(SpOnewayCallContext<ContactlessCardService_CancelReadJS_Info>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			LogWarn(Severity_Middle, Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed, "CancelInsert but DevOpen failed.");
		}
		else {
			FSMEvent* evt = new FSMEvent(USER_EVT_JS_READ_CANCEL);
			m_fsm.PostEventFIFO(evt);
		}
	}

	void ReadJS(SpReqAnsContext<ContactlessCardService_ReadJS_Req, ContactlessCardService_ReadJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Idle") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("ReadJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			ReadJSEvent* pEvt = new ReadJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}
	}

	void PostOnlineJS(SpReqAnsContext<ContactlessCardService_PostOnlineJS_Req, ContactlessCardService_PostOnlineJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Idle") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("PostOnlineJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			PostOnlineJSEvent* pEvt = new PostOnlineJSEvent();
			pEvt->ctx = ctx;
			m_fsm.PostEventFIFO(pEvt);
		}
	}

	void EjectJS(SpReqAnsContext<ContactlessCardService_EjectJS_Req, ContactlessCardService_EjectJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed);
		}
		else if (_stricmp(m_fsm.GetCurrStateName(), "Idle") != 0) {
			DWORD errCode = m_fsm.GetFsmStateErrCode();
			int state = m_fsm.GetFSMState();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode(m_fsm.getRTACode(errCode))("EjectJS req is unhandled ,CurrState=%d", state);
			ctx->Answer(Error_Unexpect, errCode);
		}
		else {
			EjectJSEvent* e = new EjectJSEvent();
			e->ctx = ctx;
			m_fsm.PostEventFIFO(e);
		}
	}

	void QueryHasCardJS(SpReqAnsContext<ContactlessCardService_QueryHasCardJS_Req, ContactlessCardService_QueryHasCardJS_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();
		if (!m_fsm.GetDevInitFlag()) {
			ctx->Answer(Error_DevNotAvailable, ContactlessCard_UserErrorCode_DevOpen_Failed);
		}
		else {
			m_fsm.QueryHasCardJS(ctx);
		}
	}

	virtual void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}
	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		return new ContactlessCardServerSession(this);
	}
	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:
	CContactlessCardFSM m_fsm;

private:
};


#endif //_MOD_CONTACTLESS_H