myvtm/Module/mod_CameraConfigManage/mod_CameraConfigManage.h

#pragma once

#include "SpBase.h"
#include "SpIni.h"
#include "libvideoecho.h"
#include "EventCode.h"
#include "Capture.h"
#include "CameraConfigManage_server_g.h"
#include "CameraConfigManage_def_g.h"
#include "CameraConfigManage_msg_g.h"

namespace CameraConfigManage {

	enum CapTypeEnum {
		CAMTYPE_UNKNOWN = 0,
		CAMTYPE_ENV,
		CAMTYPE_OPT,
		CAMTYPE_EWS,
		CAMTYPE_HSPS,
		CAMTYPE_CIRCLE,
		CAMTYPE_MAX
	};

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

	typedef struct
	{
		CSimpleStringA strEnvCamera;
		CSimpleStringA strOptCamera;
		CSimpleStringA strEwsCamera;
		//detail 
		capture_camera_t envCamera;
		capture_camera_t optCamera;
		capture_camera_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);
	private:
		CCameraConfigManageEntity *m_pEntity;
	};

	class CCameraConfigManageEntity: public CEntityBase, public ISysVarListener, 
		public ILogListener, public ITimerListener, public LibVideoEcho::CVideoEchoHostApi
	{
	public:
		CCameraConfigManageEntity(): m_capture(NULL), m_iCameraState('N'), 
			m_nActiveCamera(0), m_pSession(NULL), m_bStartCamera(FALSE), 
			m_bEchoVideo(FALSE), m_lCaptureCount(0) {}

		virtual ~CCameraConfigManageEntity() { /*nothing to implement*/ }

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

		virtual bool IsService() const{ return true; }

		virtual CServerSessionBase *OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
		{
			LOG_FUNCTION();
			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);

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

		virtual void OnTimeout(DWORD dwTimerID);

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

		virtual int GetActiveCamera();

		virtual HINSTANCE GetEntityHinstance();

		ErrorCodeEnum GetHSPCameras(CAutoArray<CSimpleStringA> &HSPCameras);

		void GetAvailableCameras(std::vector<capture_camera_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();

		void StartEchoVideo( int x, int y, int w, int h );

		void StopEchoVideo();

		// 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(capture_camera_t &correct_camera,
			bool camera1_can_open, bool camera2_can_open,
			const capture_camera_t &exclude_camera1, const capture_camera_t &exclude_camera2,
			const CAutoArray<CSimpleStringA> &hspCams);
		bool AutoCorrectCameraByOnlyOne(capture_camera_t &correct_camera,
			const capture_camera_t &exclude_camera1, const capture_camera_t &exclude_camera2,
			const CAutoArray<CSimpleStringA> &hspCams);
	private:
		capture_t *m_capture;
		std::vector<capture_camera_t> m_cameras;
		int m_iCameraState;
		int m_nActiveCamera;
		DeviceTypeEnum m_eDeviceType;
		capture_config_t m_conf;
		LibVideoEcho::videoplay_session_t *m_pSession;
		BOOL m_bStartCamera;
		BOOL m_bEchoVideo;
		//huchen add for autocorrect
		VideoConfig m_originConfig;
		VideoConfigDetail m_camerasConfig;

	private:
		LONG m_lCaptureCount;
		CAutoArray<CUUID> m_arrListener;
	};
}