myvtm/Module/mod_HSPScanner/mod_HSPScanner.h

#ifndef _MOD_HSPSCANNER_H_
#define _MOD_HSPSCANNER_H_

#pragma once

#ifndef _WIN32
#include "modVer.h"
#include "SpTest.h"
#include "DevEntityCommBase.hpp"
#endif //NOT _WIN32
#include "HSPScannerFSM.h"


using namespace HSPScanner;

class CHSPScannerEntity;

class CHSPScannerServerSession: public HSPScannerService_ServerSessionBase
{

public:
	CHSPScannerServerSession(CHSPScannerEntity *pEntity):m_pEntity(pEntity){}
	virtual ~CHSPScannerServerSession(){}

	virtual void Handle_StartPreview(SpReqAnsContext<HSPScannerService_StartPreview_Req, 
		HSPScannerService_StartPreview_Ans>::Pointer ctx);

	virtual void Handle_CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx);

	virtual void Handle_ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req, 
		HSPScannerService_ScanImage_Ans>::Pointer ctx);

	virtual void Handle_ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx);

	virtual void Handle_SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer ctx);

	virtual void Handle_SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req, 
		HSPScannerService_SetWinPos_Ans>::Pointer ctx);

	virtual void Handle_ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
		HSPScannerService_ShowProperty_Ans>::Pointer ctx);

	virtual void Handle_GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx);

	virtual void Handle_GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx);

	virtual void Handle_Exit(SpOnewayCallContext<HSPScannerService_Exit_Info>::Pointer ctx);

private:
	CHSPScannerEntity *m_pEntity;
};


class CHSPScannerEntity : public CDevAdptEntityBase, public ISysVarListener
{
public:
	CHSPScannerEntity() {}
	virtual ~CHSPScannerEntity() {}
	virtual const char *GetEntityName() const { return "HSPScanner"; }

#ifndef _WIN32
	const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	ON_ENTITYT_TEST()
#endif //NOT _WIN32

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

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum erroCode = m_fsm.Init(this);
		pTransactionContext->SendAnswer(erroCode);
	}

	virtual void OnStarted()
	{

	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		ErrorCodeEnum ec = Error_Succeed;
#ifdef TWINKLE_LOCAL_DEBUG
		int ret = m_fsm.UnitTest("");
		if(ret != 0) {
			LogError(Severity_High, Error_Unexpect, ret, CSimpleStringA::Format("line: %d", ret));
		}
		ec = (ErrorCodeEnum)(ret);
#endif //TWINKLE_LOCAL_DEBUG
		pTransactionContext->SendAnswer(ec);
	}
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		ErrorCodeEnum erroCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(erroCode);
	}

	virtual void OnSysVarEvent(const char* pszKey,
		const char* pszValue, const char* pszOldValue, const char* pszEntityName);

	void Preview(SpReqAnsContext<HSPScannerService_StartPreview_Req,
		HSPScannerService_StartPreview_Ans>::Pointer ctx)
	{
		StartPreviewEvent* pEvent = new StartPreviewEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void CancelPreview(SpReqAnsContext<HSPScannerService_CancelPreview_Req,
		HSPScannerService_CancelPreview_Ans>::Pointer ctx)
	{
		StopPreviewEvent* pEvent = new StopPreviewEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ScanImage(SpReqAnsContext<HSPScannerService_ScanImage_Req,
		HSPScannerService_ScanImage_Ans>::Pointer ctx)
	{
		ScanImageEvent* pEvent = new ScanImageEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ScanImageEx(SpReqAnsContext<HSPScannerService_ScanImageEx_Req,
		HSPScannerService_ScanImageEx_Ans>::Pointer ctx)
	{
		ScanImageExEvent* pEvent = new ScanImageExEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void Exit(SpOnewayCallContext<HSPScannerService_Exit_Info>::Pointer ctx)
	{
		m_fsm.PostEventFIFO(new FSMEvent(USER_EVT_EXIT));
	}

	void GetDevInfo(SpReqAnsContext<HSPScannerService_GetDevInfo_Req,
		HSPScannerService_GetDevInfo_Ans>::Pointer ctx)
	{
		m_fsm.GetDevInfo(ctx);
		//GetDevInfoEvent* pEvent = new GetDevInfoEvent();
		//pEvent->m_ctx = ctx;
		//m_fsm.PostEventFIFO(pEvent);
	}

	void GetDevStatus(SpReqAnsContext<HSPScannerService_GetDevStatus_Req,
		HSPScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		GetDevStatusEvent* pEvent = new GetDevStatusEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void SetWinPos(SpReqAnsContext<HSPScannerService_SetWinPos_Req,
		HSPScannerService_SetWinPos_Ans>::Pointer ctx)
	{
		SetWinPosEvent* pEvent = new SetWinPosEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void ShowProperty(SpReqAnsContext<HSPScannerService_ShowProperty_Req,
		HSPScannerService_ShowProperty_Ans>::Pointer ctx)
	{
		ShowPropertyEvent* pEvent = new ShowPropertyEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void SetProperty(SpReqAnsContext<HSPScannerService_SetProperty_Req,
		HSPScannerService_SetProperty_Ans>::Pointer ctx)
	{
		SetPropertyEvent* pEvent = new SetPropertyEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

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

	virtual bool IsService() const { return true; }
	virtual bool IsMultiThread() const { return true; }; 

	protected:
#if defined(_MSC_VER)
		ErrorCodeEnum CustomVendorLibInfo();
#endif //_MSC_VER

private:
	CHSPScannerFSM m_fsm;
};

#endif