myvtm/Module/mod_mediacontroller/mod_mediacontroller.h

#pragma once

#include "SpBase.h"
#include "SpIni.h"

#include "MediaController_server_g.h"
#include "MediaController_msg_g.h"

#include "../mod_healthmanager/HealthManager_client_g.h"
#include "../mod_healthmanager/HealthManager_def_g.h"
#include "EventCode.h"

// id:0x208
#include "../mod_assistantchannel/AssistantChannel_client_g.h"
#include "../mod_assistantchannel/chan_protocol.h"

using namespace AssistantChannel;
using namespace HealthManager;
using namespace MediaController;

class CMediaControllerEntity;

enum eCameraSate {
	eCameraClose,
	eCameraOpening,
	eCameraOpened
};

struct CCameraBrightValue
{
	int nValue;
	void Serialize(SpBuffer &Buf)
	{
		Buf & nValue;
	}
};


class ChannelMediaControllerClient : public ChannelService_ClientBase
{
public:
	ChannelMediaControllerClient(CMediaControllerEntity *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);
};

class MediaServiceSession : public MediaService_ServerSessionBase
{
public:
	MediaServiceSession(CMediaControllerEntity *pEntity) : m_pEntity(pEntity){}
	virtual void Handle_GetAudioDevices(SpReqAnsContext<MediaService_GetAudioDevices_Req, MediaService_GetAudioDevices_Ans>::Pointer ctx);
	virtual void Handle_GetVideoDevices(SpReqAnsContext<MediaService_GetVideoDevices_Req, MediaService_GetVideoDevices_Ans>::Pointer ctx);
	virtual void Handle_GetCameraInfos(SpReqAnsContext<MediaService_GetCameraInfos_Req, MediaService_GetCameraInfos_Ans>::Pointer ctx);
	virtual void Handle_ManipulateCameras(SpReqAnsContext<MediaService_ManipulateCameras_Req, MediaService_ManipulateCameras_Ans>::Pointer ctx);
	virtual void Handle_GetEnvCameraVideoCaptureInfo(SpReqAnsContext<MediaService_GetEnvCameraVideoCaptureInfo_Req, MediaService_GetEnvCameraVideoCaptureInfo_Ans>::Pointer ctx);
	virtual void Handle_GetEnvCamRawBrightnessInfo(SpReqAnsContext<MediaService_GetEnvCamRawBrightnessInfo_Req, MediaService_GetEnvCamRawBrightnessInfo_Ans>::Pointer ctx);
	virtual void Handle_SetEnvCamRawBrightness(SpReqAnsContext<MediaService_SetEnvCamRawBrightness_Req, MediaService_SetEnvCamRawBrightness_Ans>::Pointer ctx);
	virtual void Handle_TurnOnCamera(SpReqAnsContext<MediaService_TurnOnCamera_Req, MediaService_TurnOnCamera_Ans>::Pointer ctx);
	virtual void Handle_TurnOffCamera(SpReqAnsContext<MediaService_TurnOffCamera_Req, MediaService_TurnOffCamera_Ans>::Pointer ctx);
	virtual void Handle_IsCameraOnStatus(SpReqAnsContext<MediaService_IsCameraOnStatus_Req, MediaService_IsCameraOnStatus_Ans>::Pointer ctx);
	virtual void Handle_GetCameraBrightness(SpReqAnsContext<MediaService_GetCameraBrightness_Req, MediaService_GetCameraBrightness_Ans>::Pointer ctx);
	virtual void Handle_SetCameraBrightness(SpReqAnsContext<MediaService_SetCameraBrightness_Req, MediaService_SetCameraBrightness_Ans>::Pointer ctx);
private:
	CMediaControllerEntity *m_pEntity;
};


class CMediaControllerEntity : public CEntityBase, public ILogListener, public ITimerListener,public ISysVarListener
{
public:
	CMediaControllerEntity();
	virtual ~CMediaControllerEntity() {}
	virtual const char* GetEntityName() const { return "MediaController"; }
	virtual bool IsService()const { return true; }

	virtual void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName);
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext);
	virtual void OnStarted();
	DeviceTypeEnum RvcGetDeviceType();
	ErrorCodeEnum GetSalesRecordAudioParam();
	ErrorCodeEnum SetCameraSysVar(const CSimpleStringA &newVal);
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext); 
	virtual void OnTimeout(DWORD dwTimerID);
	bool SetAutoBright(ErrorCodeEnum nCode);
	bool SetConfigBright(ErrorCodeEnum nCode);
	void OnReceivePkt(int sub_type, const char *buffer, int size);
	ErrorCodeEnum RealSelfCheck();
	void SendCameraBright(DeviceTypeEnum eType);
	ErrorCodeEnum StartAllCameras(bool bstartaudio = true);
	ErrorCodeEnum StopAllCameras();
	ErrorCodeEnum RvcCheckCameraInfo(int iCamNumber);
	void DelayCloseCameras();

	ErrorCodeEnum HandleSalesRecordPCMAudio(bool bRemoteRecord, const char* pszMessage, audio_frame* pFrame = NULL);
	void HandleRemoteRecord(const char* pszMessage);
	ErrorCodeEnum StartSpeakerAudioRender(int iQueue, audio_frame* pFrame, const char* strName);
	ErrorCodeEnum StopSpeakerAudioRender();
	ErrorCodeEnum StopCamerasAndRecord();
	ErrorCodeEnum StartCamerasAndRecord();
	DeviceTypeEnum RvcDeviceType();
	ErrorCodeEnum GetMediaConfig();
	ErrorCodeEnum GetAudioDevices(int& iAudioCount, CSimpleStringA& strAudioDev, int iAudioType);
	ErrorCodeEnum GetVideoDevices(int& iVideoCount, CSimpleStringA& strVideoDev);
	ErrorCodeEnum RvcGetAudioDevice();
	ErrorCodeEnum CheckConfigCameraName(capture_config_t* conf, DeviceTypeEnum eType);
	ErrorCodeEnum AutoGetVideoDeviceName(capture_config_t* conf);
	void CheckAutoVideoConfig(capture_config_t* conf);
	void OnCameraStarted();
	void OnCameraStopped();

	ErrorCodeEnum GetSalesAudioConfig(rvc_audio_capture_config_t *conf, bool bRemoteRecord);
	ErrorCodeEnum LoadConfig(capture_config_t* conf);
	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);	
	virtual void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext);
	int GetActiveCamera();
	ErrorCodeEnum ChangeSysvar(ErrorCodeEnum op);
	ErrorCodeEnum StartSalesRecordAudioCapture(bool bRemoteRecord = false);
	ErrorCodeEnum StopSalesRecordAudioCapture();
	ErrorCodeEnum StartCamera(bool bstartaudio = true);
	ErrorCodeEnum ReStartCamera(int nCamera);
	virtual CServerSessionBase* OnNewSession(const char* pszRemoteEntityName, const char* pszClass);
	void OnTimeCameraStatusCheck();
	ErrorCodeEnum ConnectAssistChannel();
	void LogTransactionRecordCtrEvt(int iEvtType);
	ErrorCodeEnum GetEnvCamRawBrightnessInfo(int* iMin, int* iMax);
	ErrorCodeEnum SetEnvCamRawBrightness(int iBrightness);
	ErrorCodeEnum GetEnvCameraVideoCaptureInfo(CSimpleStringA& strnotice, CSimpleStringA& strcmd);
	void OnTimeHandfreeMicroStatusCheck();

#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	void OnBrocastEnvCameraCapInfo(int icaptime, int irealframes, float frealfps, float fstable);
	ErrorCodeEnum GetEnvCamCaptureProcess();
	ErrorCodeEnum StartSaveEnvCamPhoto(const char* pname, const int interval);
	ErrorCodeEnum StopSaveEnvCamPhoto();
	void HandleStartCameraCapture(const char* pszMessage);
	void HandleStopCameraCapture();
	void SetPostCapInfoFlag(bool bpostcapinfo);
	bool GetPostCapInfoFlag();
#endif
#endif

	void SetCameraState(ErrorCodeEnum errorcode);
	void GetCameraBrightness(SpReqAnsContext<MediaService_GetCameraBrightness_Req, MediaService_GetCameraBrightness_Ans>::Pointer ctx);
	void SetCameraBrightness(SpReqAnsContext<MediaService_SetCameraBrightness_Req, MediaService_SetCameraBrightness_Ans>::Pointer ctx);
	ErrorCodeEnum PostCameraBrightnessInfos(int iBrightness);
	bool IsOnlineState();
	bool HandleVirtucalCamMsg(const char* strMsg);

public:
	DeviceTypeEnum m_eDeviceType;
	eCameraSate m_eCameraState;
	capture_config_t conf;
	rvc_audio_capture_config_t m_sales_audio_conf;
	ErrorCodeEnum m_nCameraErrorCode; 
	capture_t* m_capture;
	rvc_sales_audio_capture_t* m_salesaudio_capture;
	bool m_bHasStartSpeakerRender;
	bool m_bOnBusiness;
	bool m_bJsOccupyCamera;

private:
#ifdef RVC_OS_WIN
	IAudioRender* m_pAudioRenderObj;
	bool m_bSpeakerCap;
	HANDLE m_hVirtualCamStateThread;
#else
	pthread_mutex_t m_env_mutex;
	pthread_mutex_t m_opt_mutex;
	pthread_mutex_t m_envopt_mutex;
	IAudioMgr* m_pAudioCap;
	pthread_t m_iCamStateThreadId;
#endif

	LONG m_lCaptureEnvCount;
	LONG m_lCaptureOptCount;
	LONG m_lCaptureEnvOptCount;
	CAutoArray<CUUID> m_arrListener;
	ChannelMediaControllerClient* m_pMediaControllerChannel;
	HealthManagerService_ClientBase* m_pHMClient;					
	bool m_bIsRemoteRecord;					
	bool m_bConnectedAssist;
	int m_iCamTimeout;
	int m_iDelayTime;
	int m_interValTime;
	bool m_bCameraOffTimerOn;
	int m_iAudioTimeout;
	bool m_bVirtualCamOpened;
	int m_iVirtualCamLogLevel;

	CSimpleStringA m_strHttpServerAddr;
	CSimpleStringA m_strHttpServerAPI;
	int m_iHttpTimeOut;
	CSimpleStringA m_strAppVersion;
	CSimpleStringA m_strTerminalId;
	bool m_bsynchronized;

#ifdef DEVOPS_ON_PRD
#else
#ifdef RVC_OS_WIN
#else
	CSimpleStringA m_PhotoSaveDir;
	bool m_bPostCapInfo;
#endif
#endif
};