myvtm/Module/mod_ResourceWatcher/mod_ResourceWatcher.h

#pragma once

#include "modVer.h"
#include "SpTest.h"
#include "ResourceWatcherFSM.h"

class ResourceWatcherEntity;

class ResourceWatcherServiceSession : public ResourceWatcherService_ServerSessionBase
{
public:

	ResourceWatcherServiceSession(ResourceWatcherEntity* pEntity) : m_pEntity(pEntity) {}

	virtual ~ResourceWatcherServiceSession() {}

	virtual void Handle_Fetch(SpReqAnsContext<ResourceWatcherService_Fetch_Req,
		ResourceWatcherService_Fetch_Ans>::Pointer ctx);

	virtual void Handle_GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req,
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx);
	
	virtual void Handle_GetCardSwiper(SpReqAnsContext<ResourceWatcherService_GetCardSwiper_Req, ResourceWatcherService_GetCardSwiper_Ans>::Pointer ctx);

	virtual void Handle_GetCpuType(SpReqAnsContext<ResourceWatcherService_GetCpuType_Req, ResourceWatcherService_GetCpuType_Ans>::Pointer ctx);

	virtual void Handle_OperateFile(SpReqAnsContext<ResourceWatcherService_OperateFile_Req, ResourceWatcherService_OperateFile_Ans>::Pointer ctx);

	virtual void Handle_ExtractEventLog(SpReqAnsContext<ResourceWatcherService_ExtractEventLog_Req, ResourceWatcherService_ExtractEventLog_Ans>::Pointer ctx);

private:
	ResourceWatcherEntity* m_pEntity;
};

class ResourceWatcherEntity : public CEntityBase, public IBroadcastListener
{
public:
	ResourceWatcherEntity() {}
	virtual ~ResourceWatcherEntity() {}
	virtual const char* GetEntityName() const { return "ResourceWatcher"; }
    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

    ON_ENTITYT_TEST()

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

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();

		ErrorCodeEnum errorCode = Error_Succeed;
		CSystemStaticInfo StaticInfo;
		errorCode = m_fsm.Init(this);
		if (errorCode == Error_Succeed) {
            CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
            spEntityFunction->GetSystemStaticInfo(StaticInfo);
            if (!StaticInfo.strMachineType.Compare("RVC.Pad", true)) {
                errorCode = spEntityFunction->SubscribeBroadcast("CardSwiper", NULL, this, m_uiCardSwiperStatusListener);
                if (errorCode != Error_Succeed) {
                    LOG_TRACE("Subscribe CardSwiper evt failed 0x%x");
                }
                Dbg("SubScribe CardSwiper status broadcast suc.");
            }
		}
		
		pTransactionContext->SendAnswer(errorCode);
	}

	/*ignore*/
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		//m_fsm.TryToConnect();
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*ignore*/
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*invoke fsm.onExit(), invoked when	entity will be closed*/
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,
		CSmartPointer<ITransactionContext>pTransactionContext)
	{
		ErrorCodeEnum errorCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(errorCode);
	}

	virtual void OnSelfTest(EntityTestEnum eTestType,
		CSmartPointer<ITransactionContext>pTransactionContext)
	{
		m_fsm.SelfTest(eTestType, pTransactionContext);
	}

	virtual bool IsService() const 
	{
		return true;
	}

	virtual bool IsMultiThread() const
	{
		return false;
	}

	void Fetch(SpReqAnsContext<ResourceWatcherService_Fetch_Req,
		ResourceWatcherService_Fetch_Ans>::Pointer ctx)
	{
		FetchEvent* evt = new FetchEvent();
		evt->ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}

	void GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req, 
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx)
	{
		ctx->Answer(Error_NotImpl);
	}

	void GetCSwiperStatus(SpReqAnsContext<ResourceWatcherService_GetCardSwiper_Req,
		ResourceWatcherService_GetCardSwiper_Ans>::Pointer ctx)
	{
		ctx->Ans.status = m_fsm.GetCardSwiperVal();
		ctx->Answer(Error_Succeed);
	}

	void GetCPUType(SpReqAnsContext<ResourceWatcherService_GetCpuType_Req, 
		ResourceWatcherService_GetCpuType_Ans>::Pointer ctx)
	{
		m_fsm.GetCpuType(ctx);
	}

	void OperateFile(
		SpReqAnsContext<ResourceWatcherService_OperateFile_Req, 
		ResourceWatcherService_OperateFile_Ans>::Pointer ctx)
	{
		OperateFileEvent* evt = new OperateFileEvent();
		evt->m_ctx = ctx;
		m_fsm.PostEventFIFO(evt);
	}

	void RetrieveEventLog(SpReqAnsContext<ResourceWatcherService_ExtractEventLog_Req, 
		ResourceWatcherService_ExtractEventLog_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();

#if defined(RVC_OS_WIN)
		m_fsm.PostEventFIFO(new GetEventLogEvent(ctx));
#else
		ctx->Answer(Error_NotSupport);
#endif //RVC_OS_WIN
	}

#if defined(_MSC_VER)
    SP_BEGIN_MSG_DISPATCH_MAP(ResourceWatcherEntity)
        SP_BEGIN_ENTITY_MSG("CardSwiper")
        SP_MSG_HANDLE_NS(CardSwiper, ConnectStatus, OnCardSwiperConnectStatus)
        SP_END_ENTITY_MSG()
        SP_END_MSG_DISPATCH_MAP()
#else
	virtual void OnBroadcastEvent(CUUID SubID, const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer)
	{

	}
#endif //_MSC_VER

private:
		void OnCardSwiperConnectStatus(const char *pszEntityName, DWORD dwMessageId, 
			DWORD dwMessageSignature, CardSwiper::ConnectStatus &evt)
		{
			Dbg("OnCardSwiperConnectStatus %d", evt.status);
			QueryCardSwiper cardswiperStatus;
			cardswiperStatus.status = evt.status;
			m_fsm.m_cardswiperStatus = evt.status;
			SpSendBroadcast(GetFunction(), SP_MSG_OF(QueryCardSwiper), SP_MSG_SIG_OF(QueryCardSwiper),
				cardswiperStatus);
		}

private:
	ResourceWatcherFSM m_fsm;
	CUUID m_uiCardSwiperStatusListener;
};