myvtm/Module/mod_CameraConfigManage/mod_CameraConfigManage.h

#ifndef RVC_MOD_CAMERACONFIG_MANAGER_H__
#define RVC_MOD_CAMERACONFIG_MANAGER_H__

#pragma once

#include "SpBase.h"
#include "SpIni.h"
#include "modVer.h"
#include "EventCode.h"
#include "ModuleMix.h"

#include "CameraConfigManage_server_g.h"
#include "CameraConfigManage_msg_g.h"

#if defined(_MSC_VER)
#include "Capture.h"
#include "libvideoecho.h"
#else
#include <vector>
#include <libtoolkit/config.h>
#include "capture.h"
#endif //_MSC_VER

#include "iaudiomgrinterface.h"

using namespace MediaController;

static void __audiomgrlog(void* user_data, const char* fmt, va_list arg)
{
	vDbg(fmt, arg);
}

namespace CameraConfigManage {

	typedef struct
	{
		CSimpleStringA strEnvCamera;
		CSimpleStringA strOptCamera;
		CSimpleStringA strEwsCamera;

	} VideoConfig;

	typedef struct
	{
		CSimpleStringA strEnvCamera;
		CSimpleStringA strOptCamera;
		CSimpleStringA strEwsCamera;
		//detail 
		camera_names_t envCamera;
		camera_names_t optCamera;
		camera_names_t ewsCamera;

	} VideoConfigDetail;

	// 修改实体配置文件
	typedef struct
	{
		char EditType;			    // "A"增加；"U"修改；“D" 删除
		char EntityName[32];	// 配置文件名
		char Section[32];		    // 配置节
		char Key[32];			    // 配置项
		char Value[256];		    // 值
	} CEditConfigReq;

	class CCameraConfigManageEntity;

	class CameraConfigManageServiceSession : public CameraConfigManageService_ServerSessionBase
	{
	public:
		explicit CameraConfigManageServiceSession(CCameraConfigManageEntity *pEntity) : m_pEntity(pEntity){}
		void Handle_BeginCameraConfigManage(
			SpOnewayCallContext<CameraConfigManageService_BeginCameraConfigManage_Info>::Pointer ctx);
		void Handle_EndCameraConfigManage(
			SpOnewayCallContext<CameraConfigManageService_EndCameraConfigManage_Info>::Pointer ctx);
		void Handle_GetCameraList(
			SpReqAnsContext<CameraConfigManageService_GetCameraList_Req, 
			CameraConfigManageService_GetCameraList_Ans>::Pointer ctx);
		void Handle_EchoSomeCamera(
			SpReqAnsContext<CameraConfigManageService_EchoSomeCamera_Req, 
			CameraConfigManageService_EchoSomeCamera_Ans>::Pointer ctx);
		void Handle_SaveCameraConfig(
			SpReqAnsContext<CameraConfigManageService_SaveCameraConfig_Req, 
			CameraConfigManageService_SaveCameraConfig_Ans>::Pointer ctx);
		void Handle_StopEchoSomeCamera(
			SpReqAnsContext<CameraConfigManageService_StopEchoSomeCamera_Req, 
			CameraConfigManageService_StopEchoSomeCamera_Ans>::Pointer ctx);
		void Handle_QueryCallState(
			SpReqAnsContext<CameraConfigManageService_QueryCallState_Req, 
			CameraConfigManageService_QueryCallState_Ans>::Pointer ctx);
		void Handle_QueryUIState(
			SpReqAnsContext<CameraConfigManageService_QueryUIState_Req, 
			CameraConfigManageService_QueryUIState_Ans>::Pointer ctx);
		void Handle_AutoCorrectCameraConfig(
			SpReqAnsContext<CameraConfigManageService_AutoCorrectCameraConfig_Req, 
			CameraConfigManageService_AutoCorrectCameraConfig_Ans>::Pointer ctx);

		void Handle_GetMediaAvailableList(SpReqAnsContext<CameraConfigManageService_GetMediaAvailableList_Req, CameraConfigManageService_GetMediaAvailableList_Ans>::Pointer ctx);
		void Handle_SetMediaDevice(SpReqAnsContext<CameraConfigManageService_SetMediaDevice_Req, CameraConfigManageService_SetMediaDevice_Ans>::Pointer ctx);
		void Handle_TestAvailableMedieDev(SpReqAnsContext<CameraConfigManageService_TestAvailableMedieDev_Req, CameraConfigManageService_TestAvailableMedieDev_Ans>::Pointer ctx);


	private:
		CCameraConfigManageEntity *m_pEntity;
	};

	class CCameraConfigManageEntity: public CEntityBase, public ISysVarListener, 
		public ILogListener, public ITimerListener
#if defined(RVC_OS_WIN)
		, public LibVideoEcho::CVideoEchoHostApi
#endif //RVC_OS_WIN
	{
	public:
		CCameraConfigManageEntity(): m_capture(NULL), m_iCameraState('N'), 
			m_nActiveCamera(0)
#if defined(RVC_OS_WIN)
            , m_pSession(NULL)
#endif //RVC_OS_WIN
			, m_bStartCamera(FALSE), 
			m_bEchoVideo(FALSE), m_lCaptureCount(0),mlibAudioMgr(NULL)
		{
			audiomgr_callback_t t_callback = { 0 };
			t_callback.debug = &__audiomgrlog;
			mlibAudioMgr = CreateAudioMgrObj(&t_callback);
		}

		virtual ~CCameraConfigManageEntity() { 
			LOG_FUNCTION();
            if (NULL != mlibAudioMgr) {
				mlibAudioMgr->audio_mgr_terminate();
                DestroyIAudioMgrObj(mlibAudioMgr);
            }
		}

		virtual const char *GetEntityName() const { return "CameraConfigManage"; }

        const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

		virtual bool IsService() const{ return true; }

		virtual CServerSessionBase *OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
		{
			LOG_TRACE("%s connected class = %s!", pszRemoteEntityName, pszClass);
			return new CameraConfigManageServiceSession(this);
		}

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

		virtual void OnStarted();

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

		void OnExam(CSmartPointer<ITransactionContext> pTransactionContext) 
		{
           // SpReqAnsContext<CameraConfigManageService_GetCameraList_Req, CameraConfigManageService_GetCameraList_Ans>::Pointer ctx;
            //ctx.Attach(new SpReqAnsContext<CameraConfigManageService_GetCameraList_Req, CameraConfigManageService_GetCameraList_Ans>(pTransactionContext));
			pTransactionContext->SendAnswer(Error_NotImpl);
		}

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

		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 OnTimeout(DWORD dwTimerID);

        void GetMediaAvailableList(SpReqAnsContext<CameraConfigManageService_GetMediaAvailableList_Req, CameraConfigManageService_GetMediaAvailableList_Ans>::Pointer ctx);
        void SetMediaDevice(SpReqAnsContext<CameraConfigManageService_SetMediaDevice_Req, CameraConfigManageService_SetMediaDevice_Ans>::Pointer ctx);
        void TestAvailableMedieDev(SpReqAnsContext<CameraConfigManageService_TestAvailableMedieDev_Req, CameraConfigManageService_TestAvailableMedieDev_Ans>::Pointer ctx);

		virtual void Debug(const char *fmt, ...);

		virtual int GetActiveCamera();

		virtual HINSTANCE GetEntityHinstance();

		ErrorCodeEnum GetHSPCameras(CAutoArray<CSimpleStringA> &HSPCameras);

		void GetAvailableCameras(std::vector<camera_names_t> &cams);

		ErrorCodeEnum LoadConfig(capture_config_t *conf);

		ErrorCodeEnum LoadConfig(VideoConfig *conf);

		// 编辑配置文件 add by ly@2019/03/18
		ErrorCodeEnum HandleEditConfigReq(const CAutoArray<CEditConfigReq> &reqs);

		void SetCameraName(CSimpleStringA camName);

		CSimpleStringA GetCameraName();

		BOOL IsCameraStart();

		ErrorCodeEnum StartCamera();

		void StopCamera();

#if defined(RVC_OS_WIN)
        void StartEchoVideo(int x, int y, int w, int h);
        void StopEchoVideo();
#endif //RVC_OS_WIN

		// direct show name -> device instance path
		bool ConvertEwsCameraName(CSimpleStringA& strRetrievedName, const CSimpleStringA& strDirectShowName);

		// get dev type
		DeviceTypeEnum GetDeviceType() const { return m_eDeviceType; }

		bool AutoCorrectCameraConfig(VideoConfig *config);

	private: 

		void SyncVideoConfig();

		void RefreshCameras();

		bool AutoCorrectCameraByOnlyFriendlyName(camera_names_t &correct_camera,
			bool camera1_can_open, bool camera2_can_open,
			const camera_names_t &exclude_camera1, const camera_names_t &exclude_camera2,
			const CAutoArray<CSimpleStringA> &hspCams);

		bool AutoCorrectCameraByOnlyOne(camera_names_t &correct_camera,
			const camera_names_t &exclude_camera1, const camera_names_t &exclude_camera2,
			const CAutoArray<CSimpleStringA> &hspCams);

	private:

		capture_t *m_capture;
		std::vector<camera_names_t> m_cameras;
		int m_iCameraState;
		int m_nActiveCamera;
		DeviceTypeEnum m_eDeviceType;
		BOOL m_bStartCamera;
		BOOL m_bEchoVideo;
		//huchen add for autocorrect
		VideoConfig m_originConfig;
		VideoConfigDetail m_camerasConfig;

		capture_config_t m_conf;

#if defined(RVC_OS_WIN)
        LibVideoEcho::videoplay_session_t* m_pSession;
#endif //RVC_OS_WIN

	private:

		LONG m_lCaptureCount;
		CAutoArray<CUUID> m_arrListener;
		IAudioMgr* mlibAudioMgr;
	};
}

#endif //RVC_MOD_CAMERACONFIG_MANAGER_H__