myvtm/Module/mod_ScannerSet/mod_ScannerSet.h

#ifndef _MOD_HSPSCANNER_H_
#define _MOD_HSPSCANNER_H_

#pragma once

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

#include "ScannerSetFSM.h"
#include "EventCode.h"
#include "ScannerSet_UserErrorCode.h"


#include "HSPScanner_client_g.h"
#include "MaintainWatcher_client_g.h"

using namespace HSPScanner;
using namespace ScannerSet;

class CScannerEntity;

class ScannerServerSession: public ScannerService_ServerSessionBase
{

public:
	ScannerServerSession(CScannerEntity *pEntity):m_pEntity(pEntity){}
	virtual ~ScannerServerSession(){}

	virtual void Handle_StartPreview(SpReqAnsContext<ScannerService_StartPreview_Req, 
		ScannerService_StartPreview_Ans>::Pointer ctx);

	virtual void Handle_CancelPreview(SpReqAnsContext<ScannerService_CancelPreview_Req,
		ScannerService_CancelPreview_Ans>::Pointer ctx);

	virtual void Handle_ScanImage(SpReqAnsContext<ScannerService_ScanImage_Req, 
		ScannerService_ScanImage_Ans>::Pointer ctx);

	virtual void Handle_SetWindowPos(SpReqAnsContext<ScannerService_SetWindowPos_Req,
		ScannerService_SetWindowPos_Ans>::Pointer ctx);

	virtual void Handle_SetProperty(SpReqAnsContext<ScannerService_SetProperty_Req,
		ScannerService_SetProperty_Ans>::Pointer ctx);

		virtual void Handle_ShowProperty(SpReqAnsContext<ScannerService_ShowProperty_Req,
			ScannerService_ShowProperty_Ans>::Pointer ctx);

	virtual void Handle_GetDevStatus(SpReqAnsContext<ScannerService_GetDevStatus_Req,
		ScannerService_GetDevStatus_Ans>::Pointer ctx);

	virtual void Handle_CrossTermCall(SpReqAnsContext<ScannerService_CrossTermCall_Req,
		ScannerService_CrossTermCall_Ans>::Pointer ctx);

	virtual void Handle_CrossTermInvokeInfo(SpOnewayCallContext<ScannerService_CrossTermInvokeInfo_Info>::Pointer ctx);

	virtual void Handle_GetDevInfo(SpReqAnsContext<ScannerService_GetDevInfo_Req,
		ScannerService_GetDevInfo_Ans>::Pointer ctx);

	virtual void Handle_GetOnlineCameras(SpReqAnsContext<ScannerService_GetOnlineCameras_Req, ScannerService_GetOnlineCameras_Ans>::Pointer ctx);

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

private:
	CScannerEntity *m_pEntity;
};


class HSPScannerClient : public HSPScannerService_ClientBase
{
public:
	HSPScannerClient(CScannerEntity *pEntity);
};
class PortableScannerClient : public PortableScannerService_ClientBase
{
public:
	PortableScannerClient(CScannerEntity *pEntity);
};

class CScannerEntity : public CEntityBase, public ILogListener, public IEntityStateListener
{
public:
	CScannerEntity() {}
	virtual ~CScannerEntity() 
	{
		if(GetFunction()->HasPrivilege()) {
			CSmartPointer<IEntityFunction> pFunc = GetFunction();
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
			pFuncPrivilege->UnregistEntityStateEvent(m_fsm.GetChildEntityName());
		}
	}
	virtual const char *GetEntityName() const { return "ScannerSet"; }

    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

    ON_ENTITYT_TEST()

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

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		ErrorCodeEnum erroCode = m_fsm.Init(this);
		GetFunction()->SubscribeLog(m_uuidMaintainWatcher, this,
			Log_Event, Severity_Middle, Error_IgnoreAll, -2, "MaintainWatcher");
#if defined(RVC_OS_WIN)
        GetFunction()->SubscribeLog(m_uuidPortableScanner, this, Log_Error, Severity_High, Error_IgnoreAll, -1, "PortableScanner");
#endif //RVC_OS_WIN
		pTransactionContext->SendAnswer(erroCode);
	}

	void OnStarted()
	{
		if(GetFunction()->HasPrivilege()) {
			CSmartPointer<IEntityFunction> pFunc = GetFunction();
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
			pFuncPrivilege->RegistEntityStateEvent(m_fsm.GetChildEntityName(), this);
		} else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("cur entity has no priviledge!");
		}
		m_fsm.AfterInit();
	}

	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		LOG_FUNCTION();

#ifdef TWINKLE_LOCAL_DEBUG

		const UINT result = UniTest(this);
		if(result != 0) {
			LogError(Severity_High, Error_Unexpect, result, CSimpleStringA::Format("line: %u", result));
		}

#endif
		SpReqAnsContext<ScannerService_StartPreview_Req,
			ScannerService_StartPreview_Ans>::Pointer ctx = 
			new SpReqAnsContext<ScannerService_StartPreview_Req,
			ScannerService_StartPreview_Ans>(pTransactionContext);
		Preview(ctx);

		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		Exit(NULL);
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		ErrorCodeEnum erroCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(erroCode);
	}

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

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

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

	void Exit(SpOnewayCallContext<ScannerService_Exit_Info>::Pointer ctx)
	{
		ErrorCodeEnum erroCode = m_fsm.OnDevExit();
	}

	void GetDevInfo(SpReqAnsContext<ScannerService_GetDevInfo_Req,
		ScannerService_GetDevInfo_Ans>::Pointer ctx)
	{
		m_fsm.GetDevInfo(ctx);
		return;
	}

	void GetOnlineCameras(SpReqAnsContext<ScannerService_GetOnlineCameras_Req,
		ScannerService_GetOnlineCameras_Ans>::Pointer ctx) 
	{
		m_fsm.GetOnlineDevices(ctx);
	}



	void SetWinPos(SpReqAnsContext<ScannerService_SetWindowPos_Req,
		ScannerService_SetWindowPos_Ans>::Pointer ctx)
	{
		static ScannerService_SetWindowPos_Req  lastReq = {-1, -1, -1, -1, -1};

		if((ctx->Req.type != lastReq.type
			|| ctx->Req.pointX != lastReq.pointX
			|| ctx->Req.pointY != lastReq.pointY
			|| ctx->Req.nWidth != lastReq.nWidth
			/*|| ctx->Req.reserved4 != lastReq.reserved4*/)) {

				lastReq.type = ctx->Req.type;
				lastReq.pointX = ctx->Req.pointX;
				lastReq.pointY = ctx->Req.pointY;
				lastReq.nWidth = ctx->Req.nWidth;
				lastReq.reserved4 = ctx->Req.reserved4;

				PendingTask* pTask = new PendingTask(&m_fsm);
				pTask->SetContext(ctx);
				GetFunction()->PostThreadPoolTask(pTask);

		} else {

			LogWarn(Severity_Low, Error_Debug, LOG_WARN_DUPLICATE_SETWINPOS
				, CSimpleStringA::Format("same request with last-one: %d,%d,%d,%d,%d"
														, ctx->Req.type, ctx->Req.pointX, ctx->Req.pointY, ctx->Req.nWidth, ctx->Req.reserved4));
			ctx->Answer(Error_Succeed);
		}
	}

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

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

	void GetDevStatus(SpReqAnsContext<ScannerService_GetDevStatus_Req,
		ScannerService_GetDevStatus_Ans>::Pointer ctx)
	{
		m_fsm.GetDevStatus(ctx);
		return;
	}

	void CrossTermCall(SpReqAnsContext<ScannerService_CrossTermCall_Req, 
		ScannerService_CrossTermCall_Ans>::Pointer ctx)
	{
		CrossTermCallEvent* pEvent = new CrossTermCallEvent();
		pEvent->m_ctx = ctx;
		m_fsm.PostEventFIFO(pEvent);
	}

	void CrossTermInvokeInfo(SpOnewayCallContext<ScannerService_CrossTermInvokeInfo_Info>::Pointer ctx)
	{
		CrossTermInvokeEvent* pEvent = new CrossTermInvokeEvent();
		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; }; 

	virtual void OnLog(
		const CAutoArray<CUUID> &SubIDs, 
		const CUUID nLogID,
		const LogTypeEnum eLogType, 
		const SeverityLevelEnum eLevel,
		const DWORD dwSysError,
		const DWORD dwUserCode,
		const DWORD dwEntityInstanceID, 
		const WORD wEntityDevelID, 
		const CAutoArray<DWORD> &Param, 
		const char *pszEntityName, 
		const char *pszModuleName,
		const char *pszMessage, const linkContext &pLinkInfo)
	{
		switch (dwUserCode)
		{
		case EVENT_USB_INSERT:
			m_fsm.OnDeviceInsert();
			break;
		case EVENT_USB_OUTPUT:
			m_fsm.OnDeviceRemoved();
			break;
		case EVENT_USB_CAMERA_NOT_ONLY:
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("EVENT_USB_CAMERA_NOT_ONLY occurs !!!");
			break;
		case EVENT_USB_CAMERA_INPUT:
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("EVENT_USB_CAMERA_INPUT occurs !!!");
			break;
		case LOG_ERROR_PORTABLESCANNER_IN_PREVIEW:
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("LOG_ERROR_PORTABLESCANNER_IN_PREVIEW: %s", pszMessage);
			{
				m_fsm.PSEntityPostCameraError(pszMessage);
			}
			break;
		}
	}

	void OnEntityStateHook(const char *pszEntityName,const char *pszTriggerEntity,
		EntityStateEnum eState,EntityStateEnum eLastState)
	{
		m_fsm.OnChildEntityStateChange(eLastState, eState);
	}
	void OnUserStateHook(const char *pszEntityName,DWORD dwState,DWORD dwLastState)
	{

	}
	void OnCeateConnection(const char *pszCallerEntity,const char *pszServiceEntity)
	{

	}
	void OnCloseConnection(const char *pszCallerEntity,const char *pszServiceEntity)
	{

	}

	void WaitingFSMForIdle() 
	{
		static const int waitTimes = 30;
		static const int waitEachTimeout = 300;
		int waitCurrTimes = 0;

		while(m_fsm.IsWorking() && (++waitCurrTimes <= waitTimes)) {
			Sleep(waitEachTimeout);
		}

		if(waitCurrTimes > waitTimes) {
			LogWarn(Severity_Low, Error_TimeOut, 0, "Waiting FSM to Idle timeout!");
		}
	}

private:
	CScannerFSM m_fsm;
	CUUID m_uuidMaintainWatcher;
	CUUID m_uuidPortableScanner;
};

HSPScannerClient::HSPScannerClient(CScannerEntity *pEntity)
	:HSPScannerService_ClientBase(pEntity)
{

}

#endif