myvtm/Module/mod_interactivecontrol/mod_interactivecontrol.h

#pragma once

#include "SpBase.h"
#include "SpIni.h"
#include "../include/EventCode.h"

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

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

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

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


#define ISSUCCEEDED(hr) ((hr) == Error_Succeed)
#define FAILURED(hr) (!(ISSUCCEEDED(hr)))

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 CITCtrlEntity : public CEntityBase, public ISysVarListener, public ILogListener, public IBroadcastListener, public ITimerListener
{
public:
	CITCtrlEntity() : m_pChannelClient(NULL), m_pPlayClient(NULL), m_pSalesRecordClient(NULL), m_bConnected(FALSE), m_bSalesRecording(FALSE),
		m_bSalesRecordPriorityEws(true),m_bSalesRecordUseEws(false),m_bDeskToPadFlag(true), m_bConnectAssist(FALSE)
	{
		m_bAdvOnFlag = false;
	}
	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);

	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 AdverPlayManage(const char* pszValue, const char* pszOldValue);

	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 GetHandfreeCallOutVolume(int& nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetHandfreeCallOutVolume(int nVolume, DWORD dwTimeout);

	ErrorCodeEnum GetPickupCallOutVolume(int& nVolume, DWORD dwTimeout);

	ErrorCodeEnum SetPickupCallOutVolume(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 StartEwsCamera(CSimpleStringA &errMsg);

	ErrorCodeEnum StopEwsCamera();
	// 播放录像
	ErrorCodeEnum PlayVideo(CSimpleStringA strVideoName);
	// 播放录像
	ErrorCodeEnum StartPlaySalesRecordVideo(CSimpleStringA strVideoName, int iWndX, int iWndY, int iWndWidth, int iWndHeight);

	ErrorCodeEnum StopShowVideo(CSimpleStringA strVideoName);

	ErrorCodeEnum SaveVideo(CSimpleStringA strVideoName);

	ErrorCodeEnum StartRemoteRecord(CSimpleStringA strVideoName);

	ErrorCodeEnum StopRecord(CSimpleStringA strVideoName);

	eRecordDeviceState GetRecordDeviceState();

	CSimpleStringA EncryptString(LPCTSTR lpszText);
	//隐藏录像文件信息中的卡号信息
	CSimpleStringA EncryptVideoNameCarNumber(CSimpleStringA StrVideoName);

	ErrorCodeEnum ConnectAssistChannel();

	virtual void OnTimeout(DWORD dwTimerID);

	ErrorCodeEnum ConnectToLocalPlay(bool blogevt = true);

	ErrorCodeEnum ConnectToSalesRecord(bool blogevt = true);
	
	bool IsLocalPlayConnectSessionOK();

	bool IsSalesRecordConnectSessionOK();

	void FreeLocalPlayClient();

	void FreeSalesRecordClient();

	LocalPlayClient* GetLocalPlayClient();

	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_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;
	CAutoArray<CUUID> m_arrListener;
	CUUID m_uidLocalMediaListenser;
	int m_nSysCallType;//0:普通模式，1：p2p模式
	BOOL m_bConnectAssist;
	BOOL m_bConnectPlayer;

public:
	DeviceTypeEnum m_eDeviceType;
	BOOL m_bSalesRecording;        // add by ly@2018/10
	bool m_bSalesRecordPriorityEws;	  
	bool m_bSalesRecordUseEws;
	bool m_bDeskToPadFlag;
	bool m_bAdvOnFlag;
};

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

private:
	CITCtrlEntity *m_pEntity;
};