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 "ExternalCameraMsg.h"

#include "../mod_selfchecker/SelfChecker_client_g.h"
#include "../mod_selfchecker/SelfChecker_def_g.h"
#include "ModuleMix.h"
#include "EventCode.h"

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

using namespace AssistantChannel;
using namespace SelfChecker;
using namespace MediaController;

class CMediaControllerEntity;

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


class SelfChekerClient:public SelfCheckerService_ClientBase
{
public:
	SelfChekerClient(CMediaControllerEntity*pEntity);
};

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_GetVideoDeviceName(SpReqAnsContext<MediaService_GetVideoDeviceName_Req, MediaService_GetVideoDeviceName_Ans>::Pointer ctx);
	virtual void Handle_StartCamera(SpOnewayCallContext<MediaService_StartCamera_Info>::Pointer ctx);
	virtual void Handle_StopCamera(SpOnewayCallContext<MediaService_StopCamera_Info>::Pointer ctx);

	virtual void Handle_StartEnvCamera(SpReqAnsContext<MediaService_StartEnvCamera_Req, MediaService_StartEnvCamera_Ans>::Pointer ctx);
	virtual void Handle_StopEnvCamera(SpOnewayCallContext<MediaService_StopEnvCamera_Info>::Pointer ctx);
	virtual void Handle_StartSpeakerRender(SpOnewayCallContext<MediaService_StartSpeakerRender_Info>::Pointer ctx);
	virtual void Handle_StopSpeakerRender(SpOnewayCallContext<MediaService_StopSpeakerRender_Info>::Pointer ctx);
	virtual void Handle_ManipulateMediaDevice(SpReqAnsContext<MediaService_ManipulateMediaDevice_Req, MediaService_ManipulateMediaDevice_Ans>::Pointer ctx);
	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);

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();
	void SetCameraSysVar(int n);
	ErrorCodeEnum GetSalesRecordAudioParam();
	ErrorCodeEnum SetEnvCameraOnSysVar(const CSimpleStringA strOnState);
	ErrorCodeEnum SetCameraSysVar(const CSimpleStringA &newVal);
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext); 
	virtual void OnTimeout(DWORD dwTimerID);
	bool SetAutoBright(ErrorCodeEnum nCode);
	void OnReceivePkt(int sub_type, const char *buffer, int size);
	ErrorCodeEnum RealSelfCheck();
	void SendCameraBright();
	ErrorCodeEnum StartCameras();
	ErrorCodeEnum StopCameras();

	ErrorCodeEnum ExternStartCamera();
	ErrorCodeEnum ExternStopCamera();
	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 SetSalesRecordAudioCaptureTransActionData(eRvcPCMTransType eType, void* pData);
	ErrorCodeEnum StopCamerasAndRecord();
	ErrorCodeEnum StartCamerasAndRecord();
	DeviceTypeEnum RvcDeviceType();
	ErrorCodeEnum GetMediaConfig();

#if defined(RVC_OS_WIN)
	ErrorCodeEnum GetAudioDevicePriorityName();
	ErrorCodeEnum SaveInnerCamera();
	ErrorCodeEnum GetHSPCameras(CAutoArray<CSimpleStringA>& HSPCameras);
	ErrorCodeEnum StopSingleCameraAndRecord();
	ErrorCodeEnum StartSingleCameraAndRecord();
	void UpdateMediaConfig();
	ErrorCodeEnum AutoCorrectAudioConfig();
#endif
	ErrorCodeEnum GetAudioDevices(int& iAudioCount, CSimpleStringA& strAudioDev, int iAudioType);
	ErrorCodeEnum GetVideoDevices(int& iVideoCount, CSimpleStringA& strVideoDev);

private:
	ErrorCodeEnum LoadRunConfig(CSimpleStringA& frontcam, CSimpleStringA& rearcam);
#if defined(RVC_OS_WIN)
	ErrorCodeEnum CheckConfigCameraName(capture_config_t* conf);
	bool IsNamedDeviceHasInserted(const char* strDeviceName);
	bool IsMatchSpecifyedAudioDevice(CSimpleStringA strAudioIn, CSimpleStringA strAudioOut);
	int UpdateAudioDeviceConfig(capture_config_t* conf);
	bool CheckAudioDeviceConfigure(capture_config_t* conf);
	int CheckAndUpdateAudioConfigures(capture_config_t* conf);
	double GetSystemCpuUsage();
#else
	ErrorCodeEnum CheckConfigCameraName(capture_config_t* conf, DeviceTypeEnum eType);
	ErrorCodeEnum AutoGetVideoDeviceName(capture_config_t* conf);
	ErrorCodeEnum RvcGetAudioDevice();
	void CheckAutoVideoConfig(capture_config_t* conf);
#endif //RVC_OS_WIN
	void OnCameraStarted();
	void OnCameraStopped();

	ErrorCodeEnum GetSalesAudioConfig(rvc_audio_capture_config_t *conf, bool bRemoteRecord);
	ErrorCodeEnum LoadConfig(capture_config_t* conf);
	void OnExternalCameraSwitchFailed(const char* pszFailedMsg);
	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, eRvcPCMTransType eType = eUnKnown, void* pData = NULL);
	ErrorCodeEnum StopSalesRecordAudioCapture();
	ErrorCodeEnum StartCamera();
	void StartCameraAndSetSysVar();
	ErrorCodeEnum ReStartCamera(int nCamera);
	virtual CServerSessionBase* OnNewSession(const char* pszRemoteEntityName, const char* pszClass);
	void OnTimeCameraStatusCheck();
	ErrorCodeEnum ConnectAssistChannel();

public:
	bool m_bSendCameraError;
	int m_iEnvEmptyTimes;
	int m_iOptEmptyTimes;
	int m_nEnvCameraRestartNum;
	int m_nOptCameraRestartNum;
	DeviceTypeEnum m_eDeviceType;
	BOOL m_bStartCamera;
	BOOL m_bExternControlCam;
	capture_config_t conf;
	rvc_audio_capture_config_s m_sales_audio_conf;			
	ErrorCodeEnum m_nCameraErrorCode;
	int m_nCurActiveCamera;
	CSimpleStringA strFrontCam;
	CSimpleStringA strRearCam;
	CSimpleStringA strEnvCam;
	CSimpleStringA strUSBCam;
	int m_nCameraCount;  
	int m_nSysCallType;
	capture_t* m_capture;
	rvc_sales_audio_capture_t* m_salesaudio_capture;
	BOOL m_bCustomerwareBegin;
	bool m_bHasStartSpeakerRender;

#if defined(RVC_OS_WIN)
	CSimpleStringA m_strAudioPriority;
	int m_VideoCapType;
	bool m_bSpeakerCap;
#endif //RVC_OS_WIN

private:
	LONG m_lCaptureEnvCount;
	LONG m_lCaptureOptCount;
	LONG m_lCaptureEnvOptCount;
	CAutoArray<CUUID> m_arrListener;
	ChannelMediaControllerClient* m_pMediaControllerChannel;
	SelfChekerClient* m_pSelfcheckClient;	
	bool m_bRecordPCM;						
	bool m_bIsRemoteRecord;					
	BOOL m_bConnectedAssist;
	int m_iCamTimeout;
#ifdef RVC_OS_WIN
	IAudioRender* m_pAudioRenderObj;
	bool m_bNeedPost;
	bool m_bDeskToPadFlag;
	unsigned int m_uLastOpenTime;
	__int64  m_xIdlePre, m_xKernelPre, m_xUserPre;
	CSimpleStringA m_strEnvCam;
	CSimpleStringA m_strOptCam;
	CSimpleStringA m_strHandfreeIn;
	CSimpleStringA m_strHandfreeOut;
	int m_iAudioInCount;
	int m_iAudioOutCount;
	CSimpleStringA m_strAudioIn;
	CSimpleStringA m_strAudioOut;
#else
	int m_nSalesAudioSmpPsec;
	pthread_mutex_t m_env_mutex;
	pthread_mutex_t m_opt_mutex;
	pthread_mutex_t m_envopt_mutex;
	IAudioMgr* m_pAudioCap;
#endif
	int m_iCamOnMode;
	int m_iDelayTime;
};