myvtm/Module/mod_interactivecontrol/mod_interactivecontrol.h

#pragma once

#include "SpIni.h"
#include "EventCode.h"
#include "Event.h"

#include "InteractiveControl_msg_g.h"
#include "InteractiveControl_server_g.h"
using namespace InteractiveControl;

#include "../mod_localmediaplay/LocalMediaPlay_msg_g.h"
#include "../mod_localmediaplay/LocalMediaPlay_client_g.h"
using namespace LocalMediaPlay;

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

#include "../mod_SalesRecorder/SalesRecorder_client_g.h"
#include "../mod_SalesRecorder/SalesRecorder_def_g.h"
using namespace SalesRecorder;

#include "../mod_sipphone/SIPPhone_client_g.h"
using namespace SIPPhone;

#include "../mod_mediacontroller/MediaController_client_g.h"
#include "../mod_mediacontroller/MediaController_msg_g.h"
using namespace MediaController;

#include "../mod_recorder/Recorder_client_g.h"
using namespace Recorder;

#include "../mod_counterconnector/CounterConnector_client_g.h"
using namespace CounterConnector;

enum eRecordDeviceState{
	eNormal,					
	eMicStarting,
	eEnvCamStarting,
	eOptCamStarting,
	eEwsCamStarting,
	eMicBreakDown,
	eEnvCamError,
	eOptCamError,
	eEwsCamError,
	eAllError
};

class CITCtrlEntity;

class ChannelClient : public ChannelService_ClientBase
{
public:
	ChannelClient(CITCtrlEntity *pEntity);

	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData);
	virtual void OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg, CSmartPointer<IReleasable> pData);
};

class LocalPlayClient : public PlayService_ClientBase
{
public:
	LocalPlayClient(CITCtrlEntity *pEntity);
};

class SalesRecordClient : public SalesRecorderSerVice_ClientBase
{
public:
	SalesRecordClient(CITCtrlEntity* pEntity);
};


class SipPhoneClient : public PhoneService_ClientBase
{
public:
	SipPhoneClient(CITCtrlEntity* pEntity);
};


class MediaControlClient : public MediaService_ClientBase 
{
public:
	MediaControlClient(CITCtrlEntity* pEntity);
};


class RecordClient : public RecorderSerVice_ClientBase
{
public:
	RecordClient(CITCtrlEntity* pEntity);
};


class ConnectClient : public ConnectService_ClientBase
{
public:
	ConnectClient(CITCtrlEntity* pEntity);
};


class CITCtrlEntity : public CEntityBase, public ISysVarListener, public ILogListener, public IBroadcastListener, public ITimerListener
{
public:
	CITCtrlEntity() : m_pChannelClient(NULL), m_pPlayClient(NULL), m_pSalesRecordClient(NULL), m_pSipPhoneClient(NULL), m_pMediaCtlClient(NULL), 
	m_pRecordClient(NULL), m_bConnected(false), m_bSalesRecording(false),m_bNoticePlaying(false), m_bConnectAssist(false){
		m_bAdvOnFlag = true;
		m_iRecordMode = 1;
		m_bRecording = false;
		m_pConnectClient = NULL;
		m_iRemoteRecordType = 0;
	}

	virtual ~CITCtrlEntity() {}
	virtual const char *GetEntityName() const { return "InteractiveControl"; }
	virtual bool IsService()const{return true;}

	void OnAudioPlayRet(const char *pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, LocalMediaPlay::AudioPlayRet &evt);

	void OnEnvCameraCapInfo(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, MediaController::EnvCameraCapInfo& evt);

	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/);

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

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext);

	virtual void OnStarted();

	DeviceTypeEnum RvcGetDeviceType();

	ErrorCodeEnum __OnStart(ErrorCodeEnum preOperationError);

	ErrorCodeEnum __OnClose(ErrorCodeEnum preOperationError);

	void BcastCustomerState(const char *pszValue,const char *pszOldValue,const char *pszEntityName);

	void BcastSessionid(const char *sessionid,const char *pszEntityName);

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

	void SyncMenuTree(int tree, int path);

	ErrorCodeEnum SendAgentText(CSimpleStringW strText);

	void SetMenuTree(CSimpleStringW strMenuTree);

	void SetMenuTreePath(CSimpleStringW strMenuPath);

	ErrorCodeEnum SendFrontSyncData(int id, CSimpleStringW strContent);

	ErrorCodeEnum SendH5SyncData(CSimpleStringW strContent);

	void SetConnected(bool bConnected);

	void OnReceivePacket(int type,int sub_type, const char *data, int size);

	void SendAnswer(int sub_type, ErrorCodeEnum Error);

	void SendAnswertoMobile(CSimpleStringW packet);

	ErrorCodeEnum StartPlayVideo(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, DWORD dwTimeout);

	ErrorCodeEnum StartPlayAudio(CSimpleStringW AudioNames, DWORD dwTimeout);

	ErrorCodeEnum StartPlayImage(int nCfgInx, int nWndX, int nWndY, int nWndWidth, int nWndHeight, DWORD dwTimeout);

	ErrorCodeEnum StopPlayVideo(int nCfgInx, DWORD dwTimeout);

	ErrorCodeEnum StopPlayAudio(DWORD dwTimeout);

	ErrorCodeEnum StopPlayImage(int nCfgInx, DWORD dwTimeout);

	ErrorCodeEnum GetLocalVideoVolume(int nCfgInx, int &nVolume, DWORD dwTimeout);

	ErrorCodeEnum GetLocalAudioVolume(int& nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetLocalVideoVolume(int nCfgInx, int nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetLocalAudioVolume(int nVolume, DWORD dwTimeout);

	ErrorCodeEnum SendBusinessDesktopCmd(CSimpleStringA xapName, CSimpleStringA command);

	ErrorCodeEnum GetHandfreeVolume(int iType, int& nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetHandfreeVolume(int iType, int nVolume, DWORD dwTimeout);

	ErrorCodeEnum GetPickupVolume(int iType, int& nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetPickupVolume(int iType, int nVolume, DWORD dwTimeout);

	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);

	ErrorCodeEnum SaveVideo(CSimpleStringA strVideoName);

	ErrorCodeEnum DeleteVideo(CSimpleStringA strVideoName);

	ErrorCodeEnum StartRemoteRecord(CSimpleStringA strVideoName);

	ErrorCodeEnum StopRecord(CSimpleStringA strVideoName);

	ErrorCodeEnum AppendWaterMark(CSimpleStringW strVideoName, CSimpleStringW strWaterMark);

	eRecordDeviceState GetRecordDeviceState();

	void AdverPlayManage(const char* pszValue, const char* pszOldValue);

	ErrorCodeEnum LoadEntityConfig();

	bool IsSupportTransRecordDeviceType();

	int GetRecordMode() { return m_iRecordMode; }
	
	ErrorCodeEnum StartTransactionRecord(CSimpleStringA strVideoName);

	ErrorCodeEnum StopTransactionRecord(CSimpleStringA strVideoName);

	ErrorCodeEnum HangupCall();

	ErrorCodeEnum GetAudioDeviceInfo(int& iDeviceCount, CSimpleStringA& strAudioDev, int iAudioType, DWORD dwTimeout);

	ErrorCodeEnum GetVideoDeviceInfo(int& iDeviceCount, CSimpleStringA& strVideoDev, DWORD dwTimeout);

	ErrorCodeEnum GetMediaDeviceInfo(CSimpleStringA& strHandfreeIn, CSimpleStringA& strHandfreeOut, CSimpleStringA& strPickUpIn, CSimpleStringA& strPickUpOut, 
		CSimpleStringA& strEnvCamera, CSimpleStringA& strEnvUsbPort, CSimpleStringA& strEnvReserved,
		CSimpleStringA& strOptCamera, CSimpleStringA& strOptUsbPort, CSimpleStringA& strOptReserved, DWORD dwTimeout);

	ErrorCodeEnum GetPickUpStatus(int& iStatus, DWORD dwTimeout);

	int GetRemoteRecordType() { return m_iRemoteRecordType; }

	ErrorCodeEnum SetRemoteRecordCamera(int iCamera);

	ErrorCodeEnum StartCameraCaptrue();

	ErrorCodeEnum StopCameraCaptrue();

private:
	ErrorCodeEnum ConnectAssistChannel();

	virtual void OnTimeout(DWORD dwTimerID);

	bool IsPlayerEntityAvailable();

	ErrorCodeEnum ConnectToLocalPlayer(bool blogevt = false);

	bool IsPlayerConnectSessionOK();

	void FreePlayClient();

	bool IsSalesRecordEntityAvailable();

	ErrorCodeEnum ConnectToSalesRecord(bool blogevt = false);

	bool IsSalesRecordConnectSessionOK();

	void FreeSalesRecordClient();

	bool IsSipPhoneEntityAvailable();

	ErrorCodeEnum ConnectToSipPhone(bool blogevt = false);

	bool IsSipPhoneConnectSessionOK();

	void FreeSipPhoneClient();

	bool IsMediaCtrEntityAvailable();

	ErrorCodeEnum ConnectMediaCtr(bool blogevt = false);

	bool IsMediaCtrConnectSessionOK();

	void FreeMediaCtrClient();

	void OnSalesRecordingFailed(const char* pszFailedMsg);

	bool IsRecordEntityAvailable();

	ErrorCodeEnum ConnectToRecord(bool blogevt = false);

	bool IsRecordConnectSessionOK();

	void FreeRecordClient();

	bool IsCounterConnectorEntityAvailable();

	ErrorCodeEnum ConnectCounterConnector(bool blogevt = false);

	bool IsCounterConnectSessionOK();

	void FreeCounterClient();

	SP_BEGIN_MSG_DISPATCH_MAP(CITCtrlEntity)
		SP_BEGIN_ENTITY_MSG("LocalMediaPlay")
#ifdef RVC_OS_WIN
		SP_MSG_HANDLE_NS(LocalMediaPlay, AudioPlayRet, OnAudioPlayRet)
#else
		case eMsg_AudioPlayRet:\
		if (eMsgSig_AudioPlayRet == dwMessageSignature) {
			\
				LocalMediaPlay::AudioPlayRet t; \
				ErrorCodeEnum Error = SpBuffer2Object(Buffer, t); \
				if (Error == Error_Succeed)\
					OnAudioPlayRet(pszEntityName, dwMessageId, dwMessageSignature, t); \
		}
		else {
			\
				LOG_TRACE("%s signature mismatched!", "AudioPlayRet"); \
		}\
			break;
#endif
		SP_END_ENTITY_MSG()
		SP_BEGIN_ENTITY_MSG("MediaController")
#ifdef RVC_OS_WIN
			SP_MSG_HANDLE_NS(MediaController, EnvCameraCapInfo, OnEnvCameraCapInfo)
#else
		case eMsg_EnvCameraCapInfo:\
			if (eMsgSig_EnvCameraCapInfo == dwMessageSignature) {
				\
					MediaController::EnvCameraCapInfo t; \
					ErrorCodeEnum Error = SpBuffer2Object(Buffer, t); \
					if (Error == Error_Succeed)\
						OnEnvCameraCapInfo(pszEntityName, dwMessageId, dwMessageSignature, t); \
			}
			else {
				\
					LOG_TRACE("%s signature mismatched!", "EnvCameraCapInfo"); \
			}\
				break;
#endif
		SP_END_ENTITY_MSG()
	SP_END_MSG_DISPATCH_MAP()

private:
	CSimpleStringA m_SessionID;
	bool m_bConnected;
	CSimpleStringW m_strMenuTree;
	CSimpleStringW m_strMenuPath;
	ChannelClient* m_pChannelClient;
	LocalPlayClient* m_pPlayClient; 
	SalesRecordClient* m_pSalesRecordClient;
	SipPhoneClient* m_pSipPhoneClient;
	MediaControlClient* m_pMediaCtlClient;
	RecordClient* m_pRecordClient;
	ConnectClient* m_pConnectClient;
	CAutoArray<CUUID> m_arrListener;
	CUUID m_uidLocalMediaListenser;
	CUUID m_uidMediaControllerListenser;
	bool m_bConnectAssist;
	int m_iRecordMode;
	int m_iRemoteRecordType;

public:
	DeviceTypeEnum m_eDeviceType;
	bool m_bSalesRecording;
	bool m_bAdvOnFlag;
	bool m_bNoticePlaying;
	bool m_bRecording;
};

class UIServiceSession : public UIService_ServerSessionBase
{
public:
	UIServiceSession(CITCtrlEntity *pEntity) : m_pEntity(pEntity) {}

	virtual void Handle_SetUIState(SpOnewayCallContext<UIService_SetUIState_Info>::Pointer ctx);

	virtual void Handle_SendAgentText(SpReqAnsContext<UIService_SendAgentText_Req, UIService_SendAgentText_Ans>::Pointer ctx);

	virtual void Handle_SetMenuTree(SpOnewayCallContext<UIService_SetMenuTree_Info>::Pointer ctx);

	virtual void Handle_SetMenuPath(SpOnewayCallContext<UIService_SetMenuPath_Info>::Pointer ctx);

	virtual void Handle_SendFrontSyncData(SpOnewayCallContext<UIService_SendFrontSyncData_Info>::Pointer ctx);

	virtual void Handle_SendH5SyncData(SpOnewayCallContext<UIService_SendH5SyncData_Info>::Pointer ctx);

	virtual void Handle_StartRecordVideo(SpReqAnsContext<UIService_StartRecordVideo_Req, UIService_StartRecordVideo_Ans>::Pointer ctx);

	virtual void Handle_StopRecordVideo(SpReqAnsContext<UIService_StopRecordVideo_Req, UIService_StopRecordVideo_Ans>::Pointer ctx);

	virtual void Handle_ShowVideo(SpReqAnsContext<UIService_ShowVideo_Req, UIService_ShowVideo_Ans>::Pointer ctx);

	virtual void Handle_SaveVideo(SpReqAnsContext<UIService_SaveVideo_Req, UIService_SaveVideo_Ans>::Pointer ctx);

	virtual void Handle_DeleteVideo(SpReqAnsContext<UIService_DeleteVideo_Req, UIService_DeleteVideo_Ans>::Pointer ctx);

	virtual void Handle_StartPhotograph(SpOnewayCallContext<UIService_StartPhotograph_Info>::Pointer ctx);

	virtual void Handle_StopPhotograph(SpOnewayCallContext<UIService_StopPhotograph_Info>::Pointer ctx);

	virtual void Handle_StartPlayVideo(SpReqAnsContext<UIService_StartPlayVideo_Req, UIService_StartPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StartPlayAudio(SpReqAnsContext<UIService_StartPlayAudio_Req, UIService_StartPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StartPlayImage(SpReqAnsContext<UIService_StartPlayImage_Req, UIService_StartPlayImage_Ans>::Pointer ctx);

	virtual void Handle_StopPlayVideo(SpReqAnsContext<UIService_StopPlayVideo_Req, UIService_StopPlayVideo_Ans>::Pointer ctx);

	virtual void Handle_StopPlayAudio(SpReqAnsContext<UIService_StopPlayAudio_Req, UIService_StopPlayAudio_Ans>::Pointer ctx);

	virtual void Handle_StopPlayImage(SpReqAnsContext<UIService_StopPlayImage_Req, UIService_StopPlayImage_Ans>::Pointer ctx);

	virtual void Handle_SendOperateState(SpOnewayCallContext<UIService_SendOperateState_Info>::Pointer ctx);
	
	virtual void Handle_HideOnlineVideo(SpOnewayCallContext<UIService_HideOnlineVideo_Info>::Pointer ctx);
	
	virtual void Handle_ShowOnlineVideo(SpOnewayCallContext<UIService_ShowOnlineVideo_Info>::Pointer ctx);
	
	virtual void Handle_AnswerPacket(SpReqAnsContext<UIService_AnswerPacket_Req, UIService_AnswerPacket_Ans>::Pointer ctx);

	virtual void Handle_GetLocalVideoVolume(SpReqAnsContext<UIService_GetLocalVideoVolume_Req, UIService_GetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalVideoVolume(SpReqAnsContext<UIService_SetLocalVideoVolume_Req, UIService_SetLocalVideoVolume_Ans>::Pointer ctx);

	virtual void Handle_GetLocalAudioVolume(SpReqAnsContext<UIService_GetLocalAudioVolume_Req, UIService_GetLocalAudioVolume_Ans>::Pointer ctx);

	virtual void Handle_SetLocalAudioVolume(SpReqAnsContext<UIService_SetLocalAudioVolume_Req, UIService_SetLocalAudioVolume_Ans>::Pointer ctx);
	
	virtual void Handle_SendBusinessDesktopCmd(SpReqAnsContext<UIService_SendBusinessDesktopCmd_Req, UIService_SendBusinessDesktopCmd_Ans>::Pointer ctx);
	
	virtual void Handle_HideLocalVideo(SpOnewayCallContext<UIService_HideLocalVideo_Info>::Pointer ctx);
	
	virtual void Handle_ShowLocalVideo(SpOnewayCallContext<UIService_ShowLocalVideo_Info>::Pointer ctx);
	
	virtual void Handle_HidePersonArea(SpOnewayCallContext<UIService_HidePersonArea_Info>::Pointer ctx);
	
	virtual void Handle_ShowPersonArea(SpOnewayCallContext<UIService_ShowPersonArea_Info>::Pointer ctx);

	virtual void Handle_VideoAppendWaterMark(SpReqAnsContext<UIService_VideoAppendWaterMark_Req, UIService_VideoAppendWaterMark_Ans>::Pointer ctx);

	virtual void Handle_StartRemoteRecord(SpReqAnsContext<UIService_StartRemoteRecord_Req, UIService_StartRemoteRecord_Ans>::Pointer ctx);
	
	virtual void Handle_StopRemoteRecord(SpReqAnsContext<UIService_StopRemoteRecord_Req, UIService_StopRemoteRecord_Ans>::Pointer ctx);

	virtual void Handle_StartSalesRecord(SpReqAnsContext<UIService_StartSalesRecord_Req, UIService_StartSalesRecord_Ans>::Pointer ctx);

	virtual void Handle_StartRecordPreview(SpReqAnsContext<UIService_StartRecordPreview_Req, UIService_StartRecordPreview_Ans>::Pointer ctx);
	
	virtual void Handle_AjustVideoPreviewSize(SpReqAnsContext<UIService_AjustVideoPreviewSize_Req, UIService_AjustVideoPreviewSize_Ans>::Pointer ctx);
	
	virtual void Handle_StartSalesVideoRecord(SpReqAnsContext<UIService_StartSalesVideoRecord_Req, UIService_StartSalesVideoRecord_Ans>::Pointer ctx);
	
	virtual void Handle_StopShowVideo(SpReqAnsContext<UIService_StopShowVideo_Req, UIService_StopShowVideo_Ans>::Pointer ctx);
	
	virtual void Handle_StartPlaySalesRecord(SpReqAnsContext<UIService_StartPlaySalesRecord_Req, UIService_StartPlaySalesRecord_Ans>::Pointer ctx);
	
	virtual void Handle_GetHandfreeOutVolume(SpReqAnsContext<UIService_GetHandfreeOutVolume_Req, UIService_GetHandfreeOutVolume_Ans>::Pointer ctx);
	
	virtual void Handle_SetHandfreeOutVolume(SpReqAnsContext<UIService_SetHandfreeOutVolume_Req, UIService_SetHandfreeOutVolume_Ans>::Pointer ctx);
	
	virtual void Handle_GetPickupOutVolume(SpReqAnsContext<UIService_GetPickupOutVolume_Req, UIService_GetPickupOutVolume_Ans>::Pointer ctx);
	
	virtual void Handle_SetPickupOutVolume(SpReqAnsContext<UIService_SetPickupOutVolume_Req, UIService_SetPickupOutVolume_Ans>::Pointer ctx);
	
	virtual void Handle_StartPlayNotice(SpReqAnsContext<UIService_StartPlayNotice_Req, UIService_StartPlayNotice_Ans>::Pointer ctx);

	virtual void Handle_StopPlayNotice(SpReqAnsContext<UIService_StopPlayNotice_Req, UIService_StopPlayNotice_Ans>::Pointer ctx);
	
	virtual void Handle_GetRecordMode(SpReqAnsContext<UIService_GetRecordMode_Req, UIService_GetRecordMode_Ans>::Pointer ctx);

	virtual void Handle_StartTransactionRecord(SpReqAnsContext<UIService_StartTransactionRecord_Req, UIService_StartTransactionRecord_Ans>::Pointer ctx);

	virtual void Handle_StopTransactionRecord(SpReqAnsContext<UIService_StopTransactionRecord_Req, UIService_StopTransactionRecord_Ans>::Pointer ctx);

	virtual void Handle_GetCallState(SpReqAnsContext<UIService_GetCallState_Req, UIService_GetCallState_Ans>::Pointer ctx);

	virtual void Handle_HangupCall(SpOnewayCallContext<UIService_HangupCall_Info>::Pointer ctx);

	virtual void Handle_GetTransactionRecordState(SpReqAnsContext<UIService_GetTransactionRecordState_Req, UIService_GetTransactionRecordState_Ans>::Pointer ctx);

	virtual void Handle_GetHandfreeInVolume(SpReqAnsContext<UIService_GetHandfreeInVolume_Req, UIService_GetHandfreeInVolume_Ans>::Pointer ctx);

	virtual void Handle_SetHandfreeInVolume(SpReqAnsContext<UIService_SetHandfreeInVolume_Req, UIService_SetHandfreeInVolume_Ans>::Pointer ctx);

	virtual void Handle_GetPickupInVolume(SpReqAnsContext<UIService_GetPickupInVolume_Req, UIService_GetPickupInVolume_Ans>::Pointer ctx);

	virtual void Handle_SetPickupInVolume(SpReqAnsContext<UIService_SetPickupInVolume_Req, UIService_SetPickupInVolume_Ans>::Pointer ctx);

	virtual void Handle_GetAudioInDevices(SpReqAnsContext<UIService_GetAudioInDevices_Req, UIService_GetAudioInDevices_Ans>::Pointer ctx);

	virtual void Handle_GetAudioOutDevices(SpReqAnsContext<UIService_GetAudioOutDevices_Req, UIService_GetAudioOutDevices_Ans>::Pointer ctx);

	virtual void Handle_GetCameraInfo(SpReqAnsContext<UIService_GetCameraInfo_Req, UIService_GetCameraInfo_Ans>::Pointer ctx);

	virtual void Handle_GetMediaDeviceInfo(SpReqAnsContext<UIService_GetMediaDeviceInfo_Req, UIService_GetMediaDeviceInfo_Ans>::Pointer ctx);

	virtual void Handle_GetPickUpStatus(SpReqAnsContext<UIService_GetPickUpStatus_Req, UIService_GetPickUpStatus_Ans>::Pointer ctx);

	virtual void Handle_GetCameraState(SpReqAnsContext<UIService_GetCameraState_Req, UIService_GetCameraState_Ans>::Pointer ctx);

	virtual void Handle_SetRemoteRecordCamera(SpReqAnsContext<UIService_SetRemoteRecordCamera_Req, UIService_SetRemoteRecordCamera_Ans>::Pointer ctx);

	virtual void Handle_StartCameraCapture(SpReqAnsContext<UIService_StartCameraCapture_Req, UIService_StartCameraCapture_Ans>::Pointer ctx);

	virtual void Handle_StopCameraCapture(SpReqAnsContext<UIService_StopCameraCapture_Req, UIService_StopCameraCapture_Ans>::Pointer ctx);

private:
	CITCtrlEntity *m_pEntity;
};