myvtm/Module/mod_agentip/mod_agentip.cpp

#include "stdafx.h"
#include "SpBase.h"

#include "sysvar.h"

#include "mod_assistantchannel/AssistantChannel_client_g.h"
using namespace AssistantChannel;
#include "mod_assistantchannel/chan_protocol.h"
#include "../include/EventCode.h"


class CAgentInterpreterEntity;

class CamSwitchChannelClient : public ChannelService_ClientBase
{
public:
	CamSwitchChannelClient(CAgentInterpreterEntity *pEntity);
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg,  CSmartPointer<IReleasable> pData);
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData);
};

// code:0x906

class CAgentInterpreterEntity : public CEntityBase, public ILogListener, public ITimerListener
{
public:
	CAgentInterpreterEntity() : m_iCurrentOp(ACM_CAMSWITCH_AUTO), m_bConnectAssist(false), m_pCamSwitchChannel(NULL) {}
	virtual ~CAgentInterpreterEntity() {}
	virtual const char *GetEntityName() const { return "AgentInterpreter"; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		ErrorCodeEnum Error = __OnStart(Error_Succeed);
		pTransactionContext->SendAnswer(Error);
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		ErrorCodeEnum Error = __OnClose(Error_Succeed);
		pTransactionContext->SendAnswer(Error); 
	}

	ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError)
	{
		CSmartPointer<IEntityFunction> pFunc = GetFunction();
		int i = 0;
		m_arrListener.Init(1);
		pFunc->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS,NULL,false);

		//m_iCurrentOp = ACM_CAMSWITCH_AUTO; 
		ChangeSysvar(ACM_CAMSWITCH_AUTO); // change to auto state anyway when started

		return Error_Succeed;
	}

	void OnStarted()
	{
		m_pCamSwitchChannel = new CamSwitchChannelClient(this);
		if (Error_Succeed == ConnectAssistChannel()) {
			m_bConnectAssist = true;
		}
		else {
			GetFunction()->SetTimer(1, this, 3150);
		}
	}

	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)
	{
		if (dwUserCode == LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS)
		{
			Sleep(959);
			if (m_pCamSwitchChannel != NULL){
				m_pCamSwitchChannel->GetFunction()->CloseSession();
				m_pCamSwitchChannel = NULL;
				m_bConnectAssist = false;
			}

			if (Error_Succeed == ConnectAssistChannel()) {
				m_bConnectAssist = true;
			}
			else {
				GetFunction()->SetTimer(1, this, 3150);
			}			
		}
	}

	ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError)
	{
		CSmartPointer<IEntityFunction> spFunction = GetFunction();
		for (int i = 0; i < m_arrListener.GetCount(); ++i) 
		{
			spFunction->UnsubscribeLog(m_arrListener[i]);
		}

		if (m_pCamSwitchChannel) {
			m_pCamSwitchChannel->GetFunction()->CloseSession();
			m_pCamSwitchChannel = NULL;
		}

		return Error_Succeed;
	}

	ErrorCodeEnum SwitchCamera(int op)
	{
		if (m_iCurrentOp != op) {
			ChangeSysvar(op);
			m_iCurrentOp = op;
		}
		return Error_Succeed;
	}

	void ChangeSessionState(int on)
	{
		if (!on) {
			if (m_iCurrentOp != ACM_CAMSWITCH_AUTO) {
				ChangeSysvar(ACM_CAMSWITCH_AUTO);
				m_iCurrentOp = ACM_CAMSWITCH_AUTO;
			}
		}
	}

private:
	ErrorCodeEnum ChangeSysvar(int op)
	{
		if (op == ACM_CAMSWITCH_AUTO) {
			GetFunction()->SetSysVar(SYSVAR_AGENTCAMERASWITCH, AGENTCAMERASWITCH_AUTO);
		} 
		else if (op == ACM_CAMSWITCH_ENV) {
			GetFunction()->SetSysVar(SYSVAR_AGENTCAMERASWITCH, AGENTCAMERASWITCH_ENV);
		} 
		else if (op == ACM_CAMSWITCH_OPT) {
			GetFunction()->SetSysVar(SYSVAR_AGENTCAMERASWITCH, AGENTCAMERASWITCH_OPT);
		}
		else {
			_ASSERT(0);
		}
		return Error_Succeed;
	}

	ErrorCodeEnum ConnectAssistChannel()
	{
		if (m_pCamSwitchChannel == NULL){
			m_pCamSwitchChannel = new CamSwitchChannelClient(this);
		}
		
		ErrorCodeEnum Error = m_pCamSwitchChannel->Connect();
		if (Error != Error_Succeed){
			m_pCamSwitchChannel = NULL;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AssistChannelClient connect failed!");
			return Error;
		}

		if (Error == Error_Succeed)
		{
			ChannelService_BeginRecv_Sub Sub;
			Sub.type = ACM_TYPE_CAMSWITCH;
			Error = (*m_pCamSwitchChannel)(EntityResource::getLink().upgradeLink())->BeginRecv(Sub);
			if (Error != Error_Succeed) {
				m_pCamSwitchChannel->GetFunction()->CloseSession();
				m_pCamSwitchChannel = NULL;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Register ACM_TYPE_CAMSWITCH failed!");
				return Error;
			}
		}

		if (Error == Error_Succeed)
		{
			ChannelService_BeginState_Sub Sub;
			Error = (*m_pCamSwitchChannel)(EntityResource::getLink().upgradeLink())->BeginState(Sub);
			if (Error != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("BeginState biz channel failed!");
				m_pCamSwitchChannel->GetFunction()->CloseSession();
				m_pCamSwitchChannel = NULL;
				return Error;
			}
		}
		return Error;
	}

	void OnTimeout(DWORD dwTimerID)
	{
		if (1 == dwTimerID)
		{
			if (!m_bConnectAssist) {
				if (Error_Succeed == ConnectAssistChannel()) {
					m_bConnectAssist = true;
				}
			}

			if (m_bConnectAssist) {
				GetFunction()->KillTimer(1);
			}
		}
	}

private:
	CamSwitchChannelClient *m_pCamSwitchChannel;
	int m_iCurrentOp;
	CAutoArray<CUUID> m_arrListener;
	bool m_bConnectAssist;
};

CamSwitchChannelClient::CamSwitchChannelClient( CAgentInterpreterEntity *pEntity ) : ChannelService_ClientBase(pEntity)
{

}

void CamSwitchChannelClient::OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg,  CSmartPointer<IReleasable> pData)
{
	if (Error == Error_Succeed) {
		CAgentInterpreterEntity *pEntity = static_cast<CAgentInterpreterEntity*>(m_pEntityBase);
		if (Msg.state == eChannelState_Idle) {
			pEntity->ChangeSessionState(0);
		} else if (Msg.state == eChannelState_Connected) {
			pEntity->ChangeSessionState(1);
		}
	}
}

void CamSwitchChannelClient::OnMessage( ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData )
{
	if (Error == Error_Succeed) {
		CAgentInterpreterEntity *pEntity = static_cast<CAgentInterpreterEntity*>(m_pEntityBase);
		pEntity->SwitchCamera(Msg.sub_type);
	}
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CAgentInterpreterEntity)
SP_END_ENTITY_MAP()