myvtm/Module/mod_mediacontroller/mod_mediacontroller.cpp

#include "stdafx.h"
#include "y2k_time.h"
#include "capture.h"
#include "Event.h"
#include "../../Other/libaudiorender/iaudiorenderinterface.h"
#include "mod_mediacontroller.h"

#include "../mod_snapshot/Event.h"

#define AUTOMATCH_CAMERA_ENV	"ENV_"
#define AUTOMATCH_CAMERA_OPT	"OPT_"


static void __audiomgrlog(void* user_data, const char* fmt, va_list arg)
{
	//vDbg(fmt, arg);
	int n = _vscprintf(fmt, arg);
	if (n >= MAX_PATH) {
		char* buf = (char*)malloc((size_t)(n + 1));
		vsnprintf(buf, n + 1, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", buf);
		free(buf);
	}
	else{
		char strlog[MAX_PATH] = {0};
		vsnprintf(strlog, MAX_PATH, fmt, arg);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s", strlog);
	}
}


void CMediaControllerEntity::OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName)
{
	if (_stricmp(pszKey, SYSVAR_CALLTYPE) == 0) 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sys call type from: %c to %c", pszOldValue[0], pszValue[0]);
		if(pszValue[0] == CALLTYPE_NORMAL)
		{
			m_nSysCallType = 0;
		} 
		else if(pszValue[0] == CALLTYPE_MOBILE)
		{
			m_nSysCallType = 1;
		}
		else 
		{
			m_nSysCallType = -1;
		}
	}
}


void CMediaControllerEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	m_eDeviceType = eStand2sType;
	g_eDeviceType = eStand2sType;
	
	LOG_FUNCTION();

	//is Pad Version
	m_eDeviceType = RvcGetDeviceType();
	g_eDeviceType = m_eDeviceType;

	CSmartPointer<IEntityFunction> Func = GetFunction();
	CSimpleStringA strValue;
	Func->RegistSysVarEvent(SYSVAR_CALLTYPE, this);
	Func->GetSysVar(SYSVAR_CALLTYPE, strValue);
	if (strValue[0] == CALLTYPE_NORMAL) {
		m_nSysCallType = 0;
	} 
	else if (strValue[0] == CALLTYPE_MOBILE) {
		m_nSysCallType = 1;
	} 
	else {
		assert(0);
	}
	
#ifdef RVC_OS_LINUX
	{
		audiomgr_callback_t t_callback = { 0 };
		t_callback.debug = &__audiomgrlog;
		m_pAudioCap = CreateAudioMgrObj(&t_callback);
		if (0 == m_pAudioCap->audio_mgr_initialize()) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Audio Manager Initialize success!");
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Audio Manager Initialize failed!");
			return;
		}
	}
#endif

	if (GetFunction()->RegistSysVarEvent("SessionID", this) != Error_Succeed){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("register sysvar %s failed!", "SessionID");
	}

	int i = 0;
	if ((ePadtype == m_eDeviceType)||(eMobilePadType == m_eDeviceType)||(eDesk2SType == m_eDeviceType)||(eDesk1SType == m_eDeviceType)||(eDesk2SIntegratedType == m_eDeviceType))
	{
		m_arrListener.Init(19);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_ENV);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_OPT);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_ENVOPT);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, EVENT_MOD_CUSTOMERAWARE_BEGIN, NULL, false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, EVENT_MOD_CUSTOMERAWARE_END, NULL, false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_USB_CAMER_INPUT,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_USB_CAMER_OUTPUT,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, EVENT_USB_CAMERA_NOT_ONLY,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_RECORDFAILED,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_RECORDFAILED,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, LOG_EVT_BEGIN_CAMERA_CONFIG,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, LOG_EVT_END_CAMERA_CONFIG,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTREMOTERECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPREMOTERECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPRECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORDPREVIEW,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_SALESRECORDER_STARTED_SUCCESS, NULL, false);
	}
	else
	{
		m_arrListener.Init(14);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_ENV);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_OPT);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, MOD_EVENT_SNAPSHOT_START_CAPTURE_ENVOPT);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, EVENT_MOD_CUSTOMERAWARE_BEGIN, NULL, false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_Middle, Error_IgnoreAll, EVENT_MOD_CUSTOMERAWARE_END, NULL, false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_RECORDFAILED,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_RECORDFAILED,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTREMOTERECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPREMOTERECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STOPRECORD,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_UI_STARTRECORDPREVIEW,NULL,false);
		GetFunction()->SubscribeLog(m_arrListener[i++], this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_MOD_SALESRECORDER_STARTED_SUCCESS, NULL, false);
	}

	pTransactionContext->SendAnswer(Error_Succeed);
}


void CMediaControllerEntity::OnStarted()
{
	LOG_FUNCTION();

	m_bStartCamera = FALSE;
	m_bExternControlCam = FALSE;
	m_nSysCallType =0;

	ErrorCodeEnum Error = Error_Succeed;
	//MessageBoxA(0,0,0,0);
	m_pMediaControllerChannel = new ChannelMediaControllerClient(this);
	if (Error_Succeed == ConnectAssistChannel()) {
		m_bConnectedAssist = TRUE;
	}

	m_pSelfcheckClient = new SelfChekerClient(this);
	Error = m_pSelfcheckClient->Connect();
	if (Error != Error_Succeed){
		m_pSelfcheckClient->SafeDelete();                                 
		m_pSelfcheckClient = NULL;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SelfcheckClient connect fail!");
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SelfcheckClient connect success!");
	}

#ifdef RVC_OS_WIN
	m_pAudioRenderObj = CreateIAudioRenderObj();
	if (NULL != m_pAudioRenderObj) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio render success, and addr is 0x%08x.", m_pAudioRenderObj);
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create audio render failed.");
	}
#else

#endif // RVC_OS_WIN

	if (Error_Succeed == GetSalesRecordAudioParam()) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get sales record audio param success, and sales audio capture sample rate is %d, record local PCM flag is %s.", m_nSalesAudioSmpPsec, m_bRecordPCM ? "true" : "false");
	}

	memset(&conf, 0, sizeof(capture_config_t));
	memset(&m_sales_audio_conf, 0, sizeof(rvc_audio_capture_config_t));

	Error = (ErrorCodeEnum)capture_lib_init();
	if (Error == Error_Succeed)
	{
#ifdef RVC_OS_LINUX
		RvcGetAudioDevice();
#endif
		Error = LoadConfig(&conf);
		if (Error != Error_Succeed)
		{
			if ((Error == Error_OptCamera) || (Error == Error_EnvCamera))
			{
				if (Error == Error_EnvCamera)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Load  EnvCamera Config failed!");
					SetCameraSysVar(CAMERA_ENV_ERROR);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_ENV_ERROR");
					m_nCameraErrorCode = Error_EnvCamera;
					GetFunction()->SetUserDefineState(USER_MEDIA_ENVERRROR);
				}
				else if (Error == Error_OptCamera)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Load  OptCamera Config failed!");
					SetCameraSysVar(CAMERA_OPT_ERROR);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_OPT_ERROR");
					m_nCameraErrorCode = Error_OptCamera;
					GetFunction()->SetUserDefineState(USER_MEDIA_OPTERROR);
				}
			}
			else
			{
				if (Error == Error_AllCamera)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Load all camera Config failed!");
					SetCameraSysVar(CAMERA_BOTH_ERROR);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_BOTH_ERROR");
					m_nCameraErrorCode = Error_AllCamera;
					GetFunction()->SetUserDefineState(USER_MEDIA_ALLERROR);
				}
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Load Config failed!");
			}
		}

		if ((ePadtype == m_eDeviceType) || (eMobilePadType == m_eDeviceType) || (eDesk2SType == m_eDeviceType))
		{
			CAutoArray<CSimpleStringA> hspCams;
			auto rc = GetHSPCameras(hspCams);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[GetHSPCameras]: (0x%x,%d)", rc, hspCams.GetCount());
			if (eDesk2SType == m_eDeviceType)
			{
				strFrontCam = conf.strVideoEnv;
				strRearCam = "$";
				// 将内置摄像头写入到运行时配置
				SaveInnerCamera();
			}
			else
			{
				ErrorCodeEnum ErrCod = LoadRunConfig(strFrontCam, strRearCam);
				if (ErrCod == Error_Succeed) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] Error=0x%x while LoadRunConfig.", ErrCod);
					if (strFrontCam.GetLength() <= 1 || strFrontCam != conf.strVideoEnv) {
						strFrontCam = conf.strVideoEnv;
						if (conf.strVideoOpt.GetLength() <= 1) {
							m_nCameraCount = videocap_optdev_fetch(strFrontCam, strEwsCam, hspCams, strRearCam);
						}
						else { // 如果root.ini中已配置
							strRearCam = conf.strVideoOpt;
						}

						// 将内置摄像头写入到运行时配置
						SaveInnerCamera();
					}
				}
				else {
					strFrontCam = conf.strVideoEnv;
					if (conf.strVideoOpt.GetLength() <= 1) {
						m_nCameraCount = videocap_optdev_fetch(strFrontCam, strEwsCam, hspCams, strRearCam);
					}
					else { // 如果root.ini中已配置
						strRearCam = conf.strVideoOpt;
					}

					// 将内置摄像头写入到运行时配置
					SaveInnerCamera();
				}
			}

			// 尝试获取外接摄像头
			m_nCameraCount = videocap_outerdev_fetch(strFrontCam, strRearCam, strEwsCam, hspCams, strUSBCam);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] strUSBCam=%s", (LPCTSTR)strUSBCam);
			strEnvCam = conf.strVideoEnv;
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("capture_lib_init failed!");
	}
	//PAD版获取客户感知状态
	CSimpleStringA strCustomerAware;
	if (Error != Error_AllCamera)
	{
		CSmartPointer<IEntityFunction> Func = GetFunction();
		if (Func->RegistSysVarEvent("CustomerHandle", this) != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("register sys var %s failed!", "CustomerHandle");
		}
		else
		{
			Func->GetSysVar("CustomerHandle", strCustomerAware);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CustomerHandle = %s", (LPCTSTR)strCustomerAware);
		}
	}
	//启动摄像头
	if ((Error != Error_AllCamera) && (strCustomerAware.GetLength() > 0) && (strCustomerAware[0] != 'N'))
	{
		Error = StartCamera();
		if (Error == Error_Succeed)
		{
			m_bStartCamera = TRUE;
			CSimpleStringA strSessionId;
			CSmartPointer<IEntityFunction> Func = GetFunction();
			Func->GetSysVar("SessionID", strSessionId);
			LogEvent(Severity_Middle, EVENT_MOD_BEGIN_RECORD, strSessionId);

			SetCameraSysVar(CAMERA_NO_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_NO_ERROR");
			m_nCameraErrorCode = Error_Succeed;
			GetFunction()->SetUserDefineState(USER_MEDIA_IDLE);
		}
		else
		{
			if ((Error == Error_EnvCamera) || (Error == Error_OptCamera))
			{
				CSimpleStringA strSessionId;
				CSmartPointer<IEntityFunction> Func = GetFunction();
				Func->GetSysVar("SessionID", strSessionId);
				LogEvent(Severity_Middle, EVENT_MOD_BEGIN_RECORD, strSessionId);

				m_bStartCamera = TRUE;
				if (Error == Error_EnvCamera)
				{
					SetCameraSysVar(CAMERA_ENV_ERROR);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_ENV_ERROR");
					m_nCameraErrorCode = Error_EnvCamera;
					GetFunction()->SetUserDefineState(USER_MEDIA_ENVERRROR);
					Error = Error_Succeed;
				}
				else if (Error == Error_OptCamera)
				{
					SetCameraSysVar(CAMERA_OPT_ERROR);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("StartCamera = Error_OptCamera");
					m_nCameraErrorCode = Error_OptCamera;
					GetFunction()->SetUserDefineState(USER_MEDIA_OPTERROR);
					Error = Error_Succeed;
				}
			}
			else if (Error == Error_AllCamera)
			{
				SetCameraSysVar(CAMERA_BOTH_ERROR);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_BOTH_ERROR");
				m_nCameraErrorCode = Error_AllCamera;
				m_bStartCamera = FALSE;
				GetFunction()->SetUserDefineState(USER_MEDIA_ALLERROR);
			}
			else
			{
				SetCameraSysVar(Error);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Other Error");
				m_nCameraErrorCode = Error;
				m_bStartCamera = FALSE;
				RealSelfCheck();
			}
		}
	}
}


#ifdef RVC_OS_LINUX
ErrorCodeEnum CMediaControllerEntity::RvcGetAudioDevice()
{
	ErrorCodeEnum Error = Error_Param;
	if (NULL != m_pAudioCap){
		int icountmic = m_pAudioCap->audio_get_device_count(true);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio input device(%d):", icountmic);
		int i = 0;
		for (; i < icountmic; i++) {
			char strname[MAX_PATH] = { 0 };
			m_pAudioCap->audio_get_device_name(strname, MAX_PATH, true, i);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, strname);
		}
		int icountspeaker = m_pAudioCap->audio_get_device_count(false);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("audio output device(%d):", icountspeaker);
		for (i = 0; i < icountspeaker; i++) {
			char strname[MAX_PATH] = { 0 };
			m_pAudioCap->audio_get_device_name(strname, MAX_PATH, false, i);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d = %s", i, strname);
		}
		Error = Error_Succeed;
	}
	return Error;
}
#endif


DeviceTypeEnum CMediaControllerEntity::RvcGetDeviceType()
{
	DeviceTypeEnum eType = eStand2sType;
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSystemStaticInfo stStaticinfo;
	spFunction->GetSystemStaticInfo(stStaticinfo);
	if (stricmp(stStaticinfo.strMachineType, "RVC.PAD") == 0) {
		if (stricmp(stStaticinfo.strSite, "CMB.FLB") == 0) {
			eType = eMobilePadType;
		}
		else {
			eType = ePadtype;
		}
	}
	else if (stricmp(stStaticinfo.strMachineType, "RVC.Desk2S") == 0) {
		eType = eDesk2SType;
		WORD nMajor = stStaticinfo.MachineVersion.GetMajor();
		WORD nMinor = stStaticinfo.MachineVersion.GetMinor();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("MachineVersion is %d.%d", nMajor, nMinor);
		if (2 == nMajor) {
			eType = eDesk2SIntegratedType;
		}
	}
	else if (stricmp(stStaticinfo.strMachineType, "RPM.Stand1S") == 0) {
		eType = eRpm1sType;
	}
	else if (stricmp(stStaticinfo.strMachineType, "RVC.Desk1S") == 0) {
		eType = eDesk1SType;
	}
	else {
		eType = eStand2sType;
	}

	if (eType >= 0 && eType < sizeof(Device_Type_Table) / sizeof(char*)) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("device type is %s.", Device_Type_Table[eType]);
	}

	return eType;
}


void CMediaControllerEntity::SetCameraSysVar(int n)
{
	if (n==0)
	{
		SetCameraSysVar(CAMERA_OPT_ERROR);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_OPT_ERROR");
	} 
	else if (n==1){
		SetCameraSysVar(CAMERA_ENV_ERROR);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_ENV_ERROR");
	} 
	else if (n==-1){
		SetCameraSysVar(CAMERA_BOTH_ERROR);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_BOTH_ERROR");
	} 
	else if (n==3){
		SetCameraSysVar(CAMERA_NO_ERROR);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_NO_ERROR");
	}
}


ErrorCodeEnum CMediaControllerEntity::GetSalesRecordAudioParam()
{
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	ErrorCodeEnum Error = GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
	if (Error == Error_Succeed){
		table.AddEntryInt("SalesRecorder", "AudioSampleRate", m_nSalesAudioSmpPsec, 8);
		table.AddEntryBoolean("SalesRecorder", "IsRecordPCM", m_bRecordPCM, false);
		Error= table.Load(spConfig);
	}
	
	if (m_nSalesAudioSmpPsec != 8 && m_nSalesAudioSmpPsec != 16){
		m_nSalesAudioSmpPsec = 8;
	}

	m_nSalesAudioSmpPsec *= 1000;
#ifdef RVC_OS_WIN
#else
	m_nSalesAudioSmpPsec = 44100;
#endif
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::SetEnvCameraOnSysVar(const CSimpleStringA strOnState)
{
	ErrorCodeEnum Error = Error_Succeed;
	CSmartPointer<IEntityFunction> spFunction = this->GetFunction();

	Error = spFunction->SetSysVar(SYSVAR_ENVCAMERAON, strOnState.GetData());

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::SetCameraSysVar(const CSimpleStringA &newVal)
{
	CSmartPointer<IEntityFunction> spFunction = this->GetFunction();

	CSimpleStringA val = newVal;
	if('B' == val[0]){
		LogWarn(Severity_Middle, Error_Debug, ERROR_MOD_MEDIACONTROLLER_CONFIG_ALLERROR, "all config cameras error");
	}

	if (eStand2sType == m_eDeviceType){
		return spFunction->SetSysVar(SYSVAR_CAMERASTATE, (LPCTSTR)newVal);
	}

	switch (val[0])
	{
	case 'E':
		{
			if (!strstr((LPCTSTR)strFrontCam,";"))
			{
				val = val.Append((LPCTSTR)strFrontCam);
			}
			else
			{
				val = val.Append((LPCTSTR)strFrontCam.SubString(0,strFrontCam.IndexOf(";")));
			}
		}
		break;
	case 'O':
		if (!strstr((LPCTSTR)strRearCam,";"))
		{
			val = val.Append((LPCTSTR)strRearCam);
		}
		else
		{
			val = val.Append((LPCTSTR)strRearCam.SubString(0,strRearCam.IndexOf(";")));
		}
		break;
	case 'B':
		val = val.Append("内置前、后");
		break;
	case 'N':
	case 'I':
	default:
		break;
	}
		
	return spFunction->SetSysVar(SYSVAR_CAMERASTATE, (LPCTSTR)val);
}


void CMediaControllerEntity::OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	LOG_FUNCTION();
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	for (int i = 0; i < m_arrListener.GetCount(); ++i) 
	{
		spFunction->UnsubscribeLog(m_arrListener[i]);
	}
	spFunction->UnregistSysVarEvent(SYSVAR_CALLTYPE);

	if (m_capture) {
		capture_stop(m_capture);
		capture_destroy(m_capture);
		m_capture = NULL;
	}

	if (m_salesaudio_capture){
		salesrecord_audio_capture_stop(m_salesaudio_capture);
		salesaudio_capture_destroy(m_salesaudio_capture);
		m_salesaudio_capture = NULL;
	}

#ifdef RVC_OS_WIN
	if (NULL != m_pAudioRenderObj) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("destroy audio render obj,and it's addr is 0x%08x.", m_pAudioRenderObj);
		DestroyIAudioRenderObj(m_pAudioRenderObj);
	}
#else
	if (NULL != m_pAudioCap){
		m_pAudioCap->audio_mgr_terminate();
		DestroyIAudioMgrObj(m_pAudioCap);
		m_pAudioCap = NULL;
	}

#endif // RVC_OS_WIN

	capture_lib_term();

	pTransactionContext->SendAnswer(Error_Succeed); 
}

void CMediaControllerEntity::OnTimeCameraStatusCheck()
{
	int env_n, opt_n;
	DWORD nLastEnvTime, nLastOptTime;
	bool bEnvTimeout = false;
	bool bOptTimeout = false;
	if (!m_capture){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_capture =Null");
		return;
	}

	if (!m_bStartCamera){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_bStartCamera =false");
		return;
	}

	BOOL bIsPadType = FALSE;
	if ((ePadtype == m_eDeviceType) || (eMobilePadType == m_eDeviceType) || (eDesk2SType == m_eDeviceType) || (eDesk1SType == m_eDeviceType) || (eDesk2SIntegratedType == m_eDeviceType))
	{
		bIsPadType = TRUE;
	}
	capture_detect_camera_bug(m_capture, &env_n, &opt_n, bIsPadType);
	capture_get_last_frametime(m_capture, &nLastEnvTime, &nLastOptTime, bIsPadType);

	if (env_n == 0) {
		if (m_iEnvEmptyTimes < CAMERA_BUG_THRESHOLD){
			m_iEnvEmptyTimes++; 
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get env camera picture fail,Times=%d",m_iEnvEmptyTimes);
		}	
	} 
	else if (env_n == -1){
		m_iEnvEmptyTimes = CAMERA_BUG_THRESHOLD;
	}
	else {
		if (m_iEnvEmptyTimes == CAMERA_BUG_THRESHOLD){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("env camera get right!");
		}
		m_iEnvEmptyTimes = 0;
	}
	//env图像是否超时
	if (nLastEnvTime > 0)
	{
		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("now=%d,nLastEnvTime=%d",y2k_time_now(),nLastEnvTime);
		if (((y2k_time_now() - nLastEnvTime) > CAMERA_TIMEOUT) && !bEnvTimeout)
		{
			bEnvTimeout = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bEnvTimeout");
		}
		else if (((y2k_time_now() - nLastEnvTime) < CAMERA_TIMEOUT) && bEnvTimeout)
		{
			bEnvTimeout = false;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change env camera from bEnvTimeout to OK");
		}
	}
	//env是否30S没有图像或者图像20秒没有更新
	if (((m_iEnvEmptyTimes == CAMERA_BUG_THRESHOLD) || bEnvTimeout) && (m_nCameraErrorCode != Error_EnvCamera) && (m_nCameraErrorCode != Error_AllCamera))
	{
		char strMessage[MAX_PATH * 2] = { 0 };
		get_camera_exception_message(strMessage, MAX_PATH * 2, conf.strVideoEnv, "Env camera bug detected!");
		LogWarn(Severity_Middle, Error_Hardware, ERROR_MOD_MEDIACONTROLLER_ENVCAMERA_BUG, strMessage);
		if ((ePadtype == m_eDeviceType) || (eMobilePadType == m_eDeviceType) || (eDesk2SType == m_eDeviceType) || (eDesk1SType == m_eDeviceType) || (eDesk2SIntegratedType == m_eDeviceType))
		{
			m_nCameraErrorCode = Error_AllCamera;
			ChangeSysvar(Error_EnvCamera);
			if (!m_bIsRemoteRecord) {
				RealSelfCheck();
			}
			return;
		}
		else{
			if (m_nCameraErrorCode == Error_Succeed){
				m_nCameraErrorCode = Error_EnvCamera;
				ChangeSysvar(m_nCameraErrorCode);
			}
			else if (m_nCameraErrorCode == Error_OptCamera){
				m_nCameraErrorCode = Error_AllCamera;
				ChangeSysvar(m_nCameraErrorCode);
				if (!m_bIsRemoteRecord) {
					RealSelfCheck();
				}

				return;
			}
		}
	}
	else if((m_iEnvEmptyTimes != CAMERA_BUG_THRESHOLD)&&!bEnvTimeout&&((m_nCameraErrorCode == Error_EnvCamera)||(m_nCameraErrorCode == Error_AllCamera)))
	{
		if ((ePadtype == m_eDeviceType)||(eMobilePadType == m_eDeviceType)||(eDesk2SType == m_eDeviceType)||(eDesk1SType == m_eDeviceType)||(eDesk2SIntegratedType == m_eDeviceType))
		{
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
		}
		else{
			if (m_nCameraErrorCode == Error_EnvCamera){
				m_nCameraErrorCode = Error_Succeed;
				ChangeSysvar(m_nCameraErrorCode);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to No_Error");
			}
			else if (m_nCameraErrorCode == Error_AllCamera){
				m_nCameraErrorCode = Error_OptCamera;
				ChangeSysvar(m_nCameraErrorCode);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to Opt_Error");
			}
		}
	}

	//opt是否没有图像
	if (eStand2sType == m_eDeviceType)
	{
		if (opt_n == 0) 
		{
			if (m_iOptEmptyTimes < CAMERA_BUG_THRESHOLD)
			{
				m_iOptEmptyTimes++; 
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get opt camera picture fail, Times=%d",m_iOptEmptyTimes);
			}
		}
		else if (opt_n == -1)
		{
			m_iOptEmptyTimes = CAMERA_BUG_THRESHOLD;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get opt camera picture fail");
		}
		else 
		{
			if (m_iOptEmptyTimes == CAMERA_BUG_THRESHOLD)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("opt camera get right!");
			}
			m_iOptEmptyTimes = 0;
		}
	}

	//opt图像是否超时
	if ((nLastOptTime > 0) && (eStand2sType == m_eDeviceType))
	{
		if (((y2k_time_now() - nLastOptTime) > CAMERA_TIMEOUT) && !bOptTimeout)
		{
			bOptTimeout = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bOptTimeout");
		}
		else if (((y2k_time_now() - nLastOptTime) < CAMERA_TIMEOUT) && bOptTimeout)
		{
			bOptTimeout = false;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("change opt camera from bOptTimeout to OK");
		}
	}
	//opt是否100S没有图像或者图像20秒没有更新
	if(((m_iOptEmptyTimes == CAMERA_BUG_THRESHOLD)||bOptTimeout)&&(m_nCameraErrorCode!=Error_OptCamera)&&(m_nCameraErrorCode!=Error_AllCamera)&&(eStand2sType == m_eDeviceType))
	{
		char strMessage[MAX_PATH*2] = {0};
		get_camera_exception_message(strMessage, MAX_PATH*2, conf.strVideoOpt, "Opt camera bug detected!");
		char strInfo[MAX_PATH*2] = {0};
		snprintf(strInfo, MAX_PATH*2, "%s and current time = %u, opt last capture time = %u, video queue LastOptTime = %u.",strMessage, y2k_time_now(), m_capture->opt_video->ulastcaptime, nLastOptTime);
		LogWarn(Severity_Middle, Error_Hardware, ERROR_MOD_MEDIACONTROLLER_OPECAMERA_BUG, strInfo);
		if (m_nCameraErrorCode == Error_Succeed)
		{
			m_nCameraErrorCode = Error_OptCamera;
			ChangeSysvar(m_nCameraErrorCode);
		}
		else if (m_nCameraErrorCode == Error_EnvCamera)
		{
			m_nCameraErrorCode = Error_AllCamera;
			ChangeSysvar(m_nCameraErrorCode);
			if (!m_bIsRemoteRecord) {
				RealSelfCheck();
			}
			return;
		}
	}
	else if((m_iOptEmptyTimes != CAMERA_BUG_THRESHOLD)&&!bOptTimeout&&((m_nCameraErrorCode == Error_OptCamera)||(m_nCameraErrorCode == Error_AllCamera))&&(eStand2sType == m_eDeviceType))
	{
		if (m_nCameraErrorCode == Error_OptCamera)
		{
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to No_Error");
		}
		else if (m_nCameraErrorCode == Error_AllCamera)
		{
			m_nCameraErrorCode = Error_EnvCamera;
			ChangeSysvar(m_nCameraErrorCode);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("changeSysvar to Env_Error");
		}
	}

	//重启摄像头
	if((m_nCameraErrorCode == Error_EnvCamera)&&(m_nEnvCameraRestartNum<CAMERA_RESTARTNUM))
	{
		if (ReStartCamera(ENVCAMERA) != Error_Succeed)
		{
			m_nEnvCameraRestartNum++;
		}
		else
		{
			m_nEnvCameraRestartNum = 0;
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
			m_iEnvEmptyTimes = 0;
			bEnvTimeout = false;
			//重置上次取图像时间，防止出现重启摄像头5s内取不到图像不断重启摄像头问题
			nLastEnvTime = y2k_time_now();
		}
	}
	else if((m_nCameraErrorCode == Error_OptCamera)&&(m_nOptCameraRestartNum<CAMERA_RESTARTNUM)&&(eStand2sType == m_eDeviceType))
	{
		if (ReStartCamera(OPTCAMERA) != Error_Succeed)
			m_nOptCameraRestartNum++;
		else
		{
			m_nOptCameraRestartNum = 0;
			m_nCameraErrorCode = Error_Succeed;
			ChangeSysvar(m_nCameraErrorCode);
			m_iOptEmptyTimes = 0;
			bOptTimeout = false;
			//重置上次取图像时间，防止出现重启摄像头5s内取不到图像不断重启摄像头问题
			nLastOptTime = y2k_time_now();
		}
	}
	else if (m_nCameraErrorCode == Error_AllCamera)
	{
		if (m_nEnvCameraRestartNum<CAMERA_RESTARTNUM)
		{
			if (ReStartCamera(ENVCAMERA) != Error_Succeed)
				m_nEnvCameraRestartNum++;
			else
			{
				m_nEnvCameraRestartNum = 0;
				m_nCameraErrorCode = Error_OptCamera;
				ChangeSysvar(m_nCameraErrorCode);
				m_iEnvEmptyTimes = 0;
				bEnvTimeout = false;
			}
		}

		if((m_nOptCameraRestartNum<CAMERA_RESTARTNUM)&&(eStand2sType == m_eDeviceType))
		{
			if (ReStartCamera(OPTCAMERA) != Error_Succeed)
				m_nOptCameraRestartNum++;
			else
			{
				m_nOptCameraRestartNum = 0;
				m_iOptEmptyTimes = 0;
				bOptTimeout = false;
				if (m_nCameraErrorCode == Error_AllCamera)
				{
					m_nCameraErrorCode = Error_EnvCamera;
					ChangeSysvar(m_nCameraErrorCode);
				} 
				else
				{
					m_nCameraErrorCode = Error_Succeed;
					ChangeSysvar(m_nCameraErrorCode);
				}
			}
		}
	}
}

void CMediaControllerEntity::OnTimeout(DWORD dwTimerID)
{
	if (dwTimerID == 1) {
		OnTimeCameraStatusCheck();
	}
	else if (2 == dwTimerID) {
		if (FALSE == m_bConnectedAssist) {
			if (Error_Succeed == ConnectAssistChannel()) {
				m_bConnectedAssist = TRUE;
			}
		}

		if (TRUE == m_bConnectedAssist) {
			GetFunction()->KillTimer(2);
		}
	}
}


bool CMediaControllerEntity::SetAutoBright(ErrorCodeEnum nCode)
{
	return capture_set_autobrightness(m_capture,nCode);
}

//camera gain adjust
void CMediaControllerEntity::OnReceivePkt(int sub_type, const char *buffer, int size)
{
	if (sub_type == ACM_SET_CAMERABRIGHT)
	{
		if (m_bStartCamera)
		{
			if (eStand2sType == m_eDeviceType)
			{
				//vamera bright adj
				CCameraBrightValue num;
				SpBuffer buf;
				buf.OpenRead(buffer,size);
				num.Serialize(buf);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv ACM_SET_CAMERABRIGHT = %d",num.nValue);
				if (capture_adj_brightness(m_capture,num.nValue,m_nCameraErrorCode) == true)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ACM_SET_CAMERABRIGHT success!");
					SendCameraBright();
				} 
				else
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ACM_SET_CAMERABRIGHT fail!");
				}	
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("pad type cannot adj brightness");
			}		
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("the camera not start!");
		}	
	}
}


ErrorCodeEnum CMediaControllerEntity::RealSelfCheck()
{
	ErrorCodeEnum Error = Error_Succeed;
	if (m_pSelfcheckClient)
	{
		SelfCheckerService_RealCheck_Req req;
		req.name = GetEntityName();
		SelfCheckerService_RealCheck_Ans ans;
		DWORD Timeout = 500;
		Error = m_pSelfcheckClient->RealCheck(req,ans,Timeout);
		if (Error!=Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RealSelfcheck fail!");
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("RealSelfcheck");
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_REAL_SELF_CHECK, "media controller entity auto restart.");
		}
	}
	return Error;
}


void CMediaControllerEntity::SendCameraBright()
{
	if (m_nSysCallType == 0)
	{
		ChannelService_Send_Info Info;
		Info.compress = false;
		Info.encrypt = false;
		Info.type = ACM_TYPE_DEVICE;
		Info.id = 0;
		Info.sub_type = ACM_CAMERA_BRIGHT;
		Info.data.Alloc(sizeof(int));
		SpBuffer buf;
		buf.OpenWrite();
		int nValue = 0;
		bool rslt = true;
		nValue = capture_get_brightness(m_capture,m_nCameraErrorCode); 
		if (nValue >= 0)
		{
			buf & nValue;
			Info.data = buf.ToBlob();
			m_pMediaControllerChannel->Send(Info);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send cur camera bright value = %d",nValue);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send cur camera bright value Fail!");
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cur call type cannot send pkt");
	}
}


ErrorCodeEnum CMediaControllerEntity::StartEnvCamera()
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = Error_Succeed;
	if (FALSE == m_bStartCamera){
		Error = StartCamera();
		if (Error_Succeed == Error){
			SetCameraSysVar(CAMERA_NO_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_NO_ERROR");
			m_bStartCamera = TRUE;
		}
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("camera already start.");
	}

	return Error;
}

ErrorCodeEnum CMediaControllerEntity::StopEnvCamera()
{
	LOG_FUNCTION();
	if (m_capture){
		GetFunction()->KillTimer(1);
		capture_stop(m_capture);
		capture_destroy(m_capture);
		m_capture = NULL;
	}
	m_bStartCamera = FALSE;

	return Error_Succeed;
}


ErrorCodeEnum CMediaControllerEntity::LoadRunConfig(CSimpleStringA& frontcam, CSimpleStringA& rearcam)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed) {
		SpIniMappingTable table;
		table.AddEntryString("Video", "FrontCamera", frontcam, "$");
		table.AddEntryString("Video", "RearCamera", rearcam, "$");			
		Error = table.Load(spConfig);
		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to load run config.");
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to open run config.");
	}

	return Error;
}

	
ErrorCodeEnum CMediaControllerEntity::CheckConfigCameraName(capture_config_t *conf)
{
	ErrorCodeEnum Error = Error_Succeed;
	int EnvConfigNameError = 0; //0:环境摄像头配置名能成功打开 -1:环境摄像头配置名不能打开 1:未配置环境摄像头名字
	int OptConfigNameError = 0; //0:操作摄像头配置名能成功打开 -1:操作摄像头配置名不能打开 1:未配置操作摄像头名字

	//check env device
	if (conf->strVideoEnv.GetLength() > 1)
	{   // is not "$"
		conf->video_env_dev = capture_get_video_device_id(conf->strVideoEnv.GetData());
		if (conf->video_env_dev == -1) 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("find strVideoEnv:%s(-1)",(LPCTSTR)conf->strVideoEnv);
			EnvConfigNameError = -1;
		}
	} else 
	{
		conf->video_env_dev = -1;
		EnvConfigNameError = 1;
	}
	//check opt device
	if (conf->strVideoOpt.GetLength() > 1) 
	{ // is not "$"
		conf->video_opt_dev = capture_get_video_device_id(conf->strVideoOpt.GetData());
		if (conf->video_opt_dev == -1) 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("find strVideoOpt:%s(-1)",(LPCTSTR)conf->strVideoOpt);
			OptConfigNameError = -1;
		}
	} 
	else 
	{
		conf->video_opt_dev = -1;
		OptConfigNameError = 1;
	}

	//环境摄像头配置名不能打开
	if (EnvConfigNameError == -1){
		//操作摄像头配置名不能打开,此时表明摄像头都不可用
		if(OptConfigNameError == -1){
			Error = Error_AllCamera;
		}
		//未配置操作摄像头名字or操作摄像头配置名能打开,此时表明只有操作摄像头OK
		else{
			Error = Error_EnvCamera;
		}
	} 
	//环境摄像头配置名能打开
	else if (EnvConfigNameError == 0){
		//操作摄像头配置名不能打开,此时表明只有环境摄像头OK
		if (OptConfigNameError == -1){
			Error = Error_OptCamera;
		}
		//环境摄像头配置名能打开,未配置操作摄像头名字，此时也认为摄像头都OK(无操作摄像头场景)
	} 
	//环境摄像头未配置
	else {
		//操作摄像头配置名不能打开,此时表明只有操作摄像头OK
		if(OptConfigNameError == -1){
			Error = Error_OptCamera;
		}
		//操作摄像头未配置,此时表明摄像头都不可用
		else if (OptConfigNameError == 1){
			Error = Error_AllCamera;
		}
		//操作摄像头名字能打开，此时也认为摄像头都OK(无环境摄像头场景)
	}
		
	return Error;
}


ErrorCodeEnum CMediaControllerEntity::GetSalesAudioConfig(rvc_audio_capture_config_t *conf, bool bRemoteRecord)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spConfig);
	if (Error == Error_Succeed) {
		CSimpleStringA strAudioInDevice;
		table.AddEntryString("Audio", "sales_record_in_dev", conf->strAudioIn, "$");
		table.AddEntryString("Audio", "handfree_in_dev", strAudioInDevice, "$");
		table.AddEntryString("Audio", "handfree_out_dev", conf->strAudioOut, "$");
		Error = table.Load(spConfig);
		if (Error == Error_Succeed){
			conf->audio_capture_period = CAPTURE_FRAME_TIME;
			conf->audio_capture_samplerate = m_nSalesAudioSmpPsec;
			if (conf->strAudioIn==""){
				conf->strAudioIn = strAudioInDevice;
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("load sales audio device config failed!");
		}
	} 
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("open sales audio device config failed!");
	}

	if (Error_Succeed != Error){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get sales audio device info failed, now get from default value.");
		m_sales_audio_conf.strAudioIn =  this->conf.strAudioIn;
		m_sales_audio_conf.audio_capture_period = CAPTURE_FRAME_TIME;
		m_sales_audio_conf.audio_capture_samplerate = CAPTURE_CLOCK;
		Error = Error_Succeed;
	}

	conf->audio_capture_samplerate = CAPTURE_CLOCK*2;

	if (true == bRemoteRecord){
		if (CAPTURE_CLOCK*2 == m_sales_audio_conf.audio_capture_samplerate){
			m_sales_audio_conf.audio_capture_samplerate = CAPTURE_CLOCK;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("remote record, change audio sample rate to from %d to %d.", CAPTURE_CLOCK*2, m_sales_audio_conf.audio_capture_samplerate);
		}
	}

	return Error;
}


ErrorCodeEnum CMediaControllerEntity::AutoGetVideoDeviceName(capture_config_t* conf)
{
	ErrorCodeEnum Error = Error_Unexpect;
	int icount = rvc_videocap_get_device_count();
	int ifound = 0;
	bool benv = false;
	bool bopt = false;
	for (int i = 0; i < 64 && ifound < icount; ++i) {
		char strfullname[2 * MAX_PATH] = { 0 };
		if (0 == rvc_videocap_get_device_fullpathname(i, strfullname, 2 * MAX_PATH)) {
			ifound++;
			if (NULL != strstr(strfullname, AUTOMATCH_CAMERA_ENV)) {
				conf->strVideoEnv = strfullname;
				benv = true;
			}
			if (NULL != strstr(strfullname, AUTOMATCH_CAMERA_OPT)) {
				conf->strVideoOpt = strfullname;
				bopt = true;
			}

			if (benv && bopt){
				Error = Error_Succeed;
				break;
			}
		}
	}
	return Error;
}


static CSimpleStringA generateCameraInfosJson(CSimpleStringA strEnv, CSimpleStringA strOpt, int iEnv, int iOpt, int iMtu)
{
	return CSimpleStringA::Format("{\"EnvCamera\":\"%s\",\"OptCamera\":\"%s\",\"EnvRotate\":\"%d\",\"OptRotate\":\"%d\",\"mtu\":\"%d\"}",
		strEnv.GetData(), strOpt.GetData(), iEnv, iOpt, iMtu);
}

ErrorCodeEnum CMediaControllerEntity::LoadConfig(capture_config_t *conf)
{
	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	SpIniMappingTable table;
	strEwsCam = "$";
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Root, spConfig);
	if (Error == Error_Succeed) {
		int imtu = 0;
		table.AddEntryString("Audio", "handfree_in_dev", conf->strAudioIn, "$");
		table.AddEntryString("Audio", "handfree_out_dev", conf->strAudioOut, "$");
		table.AddEntryString("Video", "EnvCamera", conf->strVideoEnv, "$");
		table.AddEntryString("Video", "OptCamera", conf->strVideoOpt, "$");
		table.AddEntryString("Video", "EwsCamera", strEwsCam, "$");
		table.AddEntryInt("Video", "EnvRotate", conf->video_env_rotate, 0);
		table.AddEntryInt("Video", "OptRotate", conf->video_opt_rotate, 0);
		table.AddEntryInt("Video", "EnvFps", conf->video_env_fps, 0);
		table.AddEntryInt("Video", "OptFps", conf->video_opt_fps, 0);
		table.AddEntryInt("Video", "mtu", imtu, 0);
		Error = table.Load(spConfig);
		if (Error == Error_Succeed)
		{
			LogWarn(Severity_Low, Error_Debug, ERROR_MOD_MEDIACONTROLLER_ENV_CAMERA_INFO, conf->strVideoEnv.GetData());
			LogWarn(Severity_Low, Error_Debug, ERROR_MOD_MEDIACONTROLLER_OPT_CAMERA_INFO, conf->strVideoOpt.GetData());
			LogWarn(Severity_Low, Error_Debug, LOG_EVT_MEDIACONTROLLER_CAMERA_INFOS, generateCameraInfosJson(conf->strVideoEnv, conf->strVideoOpt, conf->video_env_rotate, conf->video_opt_rotate, imtu).GetData());

			char strInfo[MAX_PATH * 2] = { 0 };
			Error = AutoGetVideoDeviceName(conf);
			snprintf(strInfo, MAX_PATH * 2, "env = %s,opt = %s", conf->strVideoEnv.GetData(), conf->strVideoOpt.GetData());
			if (Error_Succeed == Error){
				LogWarn(Severity_Low, Error_Debug, ERROR_MOD_MEDIACONTROLLER_VIDEO_AUTO_MATHED_SUCCESS, strInfo);
			}
			else {
				LogWarn(Severity_Low, Error_Debug, ERROR_MOD_MEDIACONTROLLER_VIDEO_AUTO_MATHED_FAILED, strInfo);
			}
			Error = CheckConfigCameraName(conf);
			if (Error == Error_EnvCamera || Error == Error_AllCamera){
				char strMessage[MAX_PATH*2] = {0};
				get_camera_exception_message(strMessage, MAX_PATH*2, conf->strVideoEnv ,"ENV 摄像头打开失败，请检查设备或配置是否正确！");
				LogWarn(Severity_Middle,Error_DevMedia,ERROR_MOD_MEDIACONTROLLER_ENVCAM_INITFAIL, strMessage);
			} else if (Error == Error_OptCamera){
				char strMessage[MAX_PATH*2] = {0};
				get_camera_exception_message(strMessage, MAX_PATH*2, conf->strVideoOpt, "OPT 摄像头打开失败，请检查设备或配置是否正确！");
				LogWarn(Severity_Middle,Error_DevMedia,ERROR_MOD_MEDIACONTROLLER_OPTCAM_INITFAIL, strMessage);
			}
		}
		else 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("load config failed!");
		}
	} 
	else 
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("open config failed!");
	}
	return Error;
}


void CMediaControllerEntity::OnExternalCameraSwitchFailed(const char* pszFailedMsg)
{
	// 广播给业务系统
	ExternalCameraSwitchFailed evt;
	evt.failedmsg = CSimpleStringA2W(pszFailedMsg);
	SpSendBroadcast(GetFunction(), SP_MSG_OF(ExternalCameraSwitchFailed), SP_MSG_SIG_OF(ExternalCameraSwitchFailed), evt);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] ExternalCameraSwitchFailed broadcast sent!");

	CSmartPointer<IEntityFunction> Func = GetFunction();
	CSimpleStringA strValue;
	Func->GetSysVar("DesktopType", strValue);
	if (strValue == CSimpleStringA("U")) {
#ifdef RVC_OS_WIN
		MessageBoxA(NULL, pszFailedMsg, NULL, MB_SYSTEMMODAL);
#else

#endif // RVC_OS_WIN
	}
}


void CMediaControllerEntity::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)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("user_code = 0x%08x", dwUserCode);
	switch (dwUserCode)
	{    
	case MOD_EVENT_SNAPSHOT_START_CAPTURE_ENVOPT:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv MOD_EVENT_SNAPSHOT_START_CAPTURE_ENVOPT");
#ifdef RVC_OS_WIN
			InterlockedCompareExchange(&m_lCaptureEnvOptCount, 3, 0);
#else
			pthread_mutex_lock(&m_envopt_mutex);
			LONG* plTemp = &m_lCaptureEnvOptCount;
			if (0 == *plTemp) {
				*plTemp = 3;
			}
			pthread_mutex_unlock(&m_envopt_mutex);
#endif // RVC_OS_WIN
		}
		break;
	case MOD_EVENT_SNAPSHOT_START_CAPTURE_ENV:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv MOD_EVENT_SNAPSHOT_START_CAPTURE_ENV");
#ifdef RVC_OS_WIN
			InterlockedCompareExchange(&m_lCaptureEnvOptCount, 1, 0);
#else
			pthread_mutex_lock(&m_envopt_mutex);
			LONG* plTemp = &m_lCaptureEnvOptCount;
			if (0 == *plTemp) {
				*plTemp = 1;
			}
			pthread_mutex_unlock(&m_envopt_mutex);
#endif // RVC_OS_WIN
		} 
		break;
	case  MOD_EVENT_SNAPSHOT_START_CAPTURE_OPT:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv MOD_EVENT_SNAPSHOT_START_CAPTURE_OPT");
#ifdef RVC_OS_WIN
			InterlockedCompareExchange(&m_lCaptureEnvOptCount, 1, 0);
#else
			pthread_mutex_lock(&m_envopt_mutex);
			LONG* plTemp = &m_lCaptureEnvOptCount;
			if (0 == *plTemp) {
				*plTemp = 1;
			}
			pthread_mutex_unlock(&m_envopt_mutex);
#endif // RVC_OS_WIN
		}
		break;
	case  LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS:
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("recv LOG_EVT_MOD_ASSISCHAN_STARTED_SUCCESS");
			Sleep(800);
			if (m_pMediaControllerChannel != NULL){
				m_pMediaControllerChannel->GetFunction()->CloseSession();
				m_pMediaControllerChannel->SafeDelete();
				m_pMediaControllerChannel = NULL;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Close AssistChannel Session ");
				m_bConnectedAssist = FALSE;
			}

			if (Error_Succeed == ConnectAssistChannel()){
				m_bConnectedAssist = TRUE;
			}
			else {
				GetFunction()->SetTimer(2, this, 3350);
			}
		}
		break;

	case  EVENT_MOD_CUSTOMERAWARE_BEGIN:
		{
			m_bCustomerwareBegin = true;
			if (!m_bStartCamera&&!m_bExternControlCam)
			{
				StartCameraAndTiggerRecord(pszMessage);
			}
		}
		break;

	case EVENT_MOD_CUSTOMERAWARE_END:
		{
			m_bCustomerwareBegin = false;
			if (m_bStartCamera&&!m_bExternControlCam)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop camera");
				if (m_capture) 
				{
					LogEvent(Severity_Middle, EVENT_MOD_END_RECORD,pszMessage);
					GetFunction()->KillTimer(1);
					capture_stop(m_capture);
					capture_destroy(m_capture);
					m_capture = NULL;
				}
				m_bStartCamera = FALSE;
			}
		}
		break;

	case  EVENT_USB_CAMER_INPUT: // add by ly at 20160329
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] usbcam %s inserted.", pszMessage);
			//huchen add for support usb inout,camera config AutoCorrect 
			if (m_bCustomerwareBegin){
				if (!m_bStartCamera&&!m_bExternControlCam) {
					CSimpleStringA strSessionId;
					CSmartPointer<IEntityFunction> Func = GetFunction();
					Func->GetSysVar("SessionID", strSessionId);
					StartCameraAndTiggerRecord((LPCTSTR)strSessionId);
				}
			}
		}
		break;

	case  EVENT_USB_CAMER_OUTPUT: // add by ly at 20160329
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] usb cam %s removed.", pszMessage);
			int nEnv = capture_get_video_device_id((LPCTSTR)conf.strVideoEnv);
			if(nEnv<0)
			{
				// 对低柜双屏版屏蔽外接摄像头拔出事件 edit by ly@2018/10
				if (eDesk2SType != m_eDeviceType)
				{
					// 广播给业务系统
					ExternalCameraRemoved evt;
					// comment by ly@2019/03/19
					//evt.camname = CSimpleStringA2W(strUSBCam);
					evt.camname = CSimpleStringA2W(pszMessage);
					SpSendBroadcast(GetFunction(), SP_MSG_OF(ExternalCameraRemoved), SP_MSG_SIG_OF(ExternalCameraRemoved), evt);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] ExternalCameraRemoved broadcast sent!");
				}

				// 停止摄像头 add by ly@2019/03/19
				if (m_bStartCamera&&!m_bExternControlCam)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop camera");
					if (m_capture) 
					{
						LogEvent(Severity_Middle, EVENT_MOD_END_RECORD,pszMessage);
						GetFunction()->KillTimer(1);
						capture_stop(m_capture);
						capture_destroy(m_capture);
						m_capture = NULL;
					}
					m_bStartCamera = FALSE;
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] USBCam(%s) is not the one used now!",pszMessage);
			}
			//strUSBCam = "$";
		}
		break;

	case  EVENT_USB_CAMERA_NOT_ONLY: // add by ly at 20160707
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] more than one usb cam detected.");
			OnExternalCameraSwitchFailed(SwitchFailed_NoUnique);
		}
		break;

	case LOG_EVT_RECORDFAILED: 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] record failed event.");
			GetFunction()->KillTimer(1);
			//edit by ly @2018/01/17
			LogEvent(Severity_Middle, EVENT_MOD_END_RECORD, NULL);

			char FaildFlag = pszMessage[0];
			if (FaildFlag == '0')
			{
				GetFunction()->SetTimer(1, this, 5000);
				OnExternalCameraSwitchFailed("本地录音录像失败，已停止！");
			}
			else //if (FaildFlag == '1')
			{
				OnExternalCameraSwitchFailed("本地录音录像设备故障，尝试恢复中（预计10s内），请稍等");
				m_nCameraErrorCode = Error_AllCamera;
				RealSelfCheck(); // 录音录像失败，强行kill实体
			}
		}
		break;

	case  LOG_EVT_UI_RECORDFAILED: // add by ly@2018/06/08
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] sales record failed event.");
			GetFunction()->KillTimer(1);
			if (m_bIsRemoteRecord){
				LogEvent(Severity_Middle, LOG_EVT_UI_STOPREMOTERECORD, NULL);
			}
			else{
				LogEvent(Severity_Middle, LOG_EVT_UI_STOPRECORD, NULL);
			}
				
			GetFunction()->SetTimer(1, this, 5000);
			OnExternalCameraSwitchFailed(pszMessage);

			//char FaildFlag = pszMessage[0];
			//if (FaildFlag == '0')
			//{
			//	GetFunction()->SetTimer(1, this, 5000);
			//	OnExternalCameraSwitchFailed("现场销售录音录像失败，已停止！");
			//}
			//else //if (FaildFlag == '1')
			//{
			//	OnExternalCameraSwitchFailed("现场销售录音录像设备故障，尝试恢复中（预计10s内），请稍等");
			//	m_nCameraErrorCode = Error_AllCamera;
			//	RealSelfCheck(); // 录音录像失败，强行kill实体
			//}
		}
		break;

	case LOG_EVT_MOD_SALESRECORDER_STARTED_SUCCESS:
		m_bIsRemoteRecord = false;
		break;

	case LOG_EVT_BEGIN_CAMERA_CONFIG:
		{
			ExternStopCamera();
		}
		break;

	case LOG_EVT_END_CAMERA_CONFIG:
		{
			ExternStartCamera();
		}
		break;

	case LOG_EVT_UI_STARTREMOTERECORD:
		{
			m_bIsRemoteRecord = true;
			HandleRemoteRecord(pszMessage);
		}
		break;

	case LOG_EVT_UI_STOPREMOTERECORD:
		{
			m_bIsRemoteRecord = false;
			if (Error_Succeed == StopSalesRecordAudioCapture()){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop remote sales record audio capture.");
			}
			if (true == m_bHasStartSpeakerRender){
				StopSpeakerAudioRender();
			}
		}
		break;

	case LOG_EVT_UI_STARTRECORD:
	case LOG_EVT_UI_STARTRECORDPREVIEW:
		{
			m_bIsRemoteRecord = false;
			if (false == m_bRecordPCM){
				if (Error_Succeed == StartSalesRecordAudioCapture()){
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin remote sales record audio capture.");
				}
			}
			else{
				HandleSalesRecordPCMAudio(false, pszMessage);
			}
		}
		break;

	case LOG_EVT_UI_STOPRECORD:
		{
			if (Error_Succeed == StopSalesRecordAudioCapture()){
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop sales record audio capture.");
			}
		}
		break;
	default:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("unknown event.");
		break;
	}
}

void CMediaControllerEntity::OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext) 
{ 
	if (Test_ShakeHand == eTestType)
	{
		if (m_nCameraErrorCode == Error_AllCamera)
		{
			pTransactionContext->SendAnswer(Error_DevMedia); 
		}
		else
		{
			pTransactionContext->SendAnswer(Error_Succeed); 
		}
	}
}

//获取当前使用摄像头，30分钟轮休一次
int CMediaControllerEntity::GetActiveCamera()
{
#ifdef RVC_OS_WIN
	SYSTEMTIME st;
	GetLocalTime(&st);

	if (st.wMinute <= CAMERA_CHANGE_TIMER)
	{
		return ENVCAMERA;
	}
	else if (st.wMinute > CAMERA_CHANGE_TIMER)
	{
		return OPTCAMERA;
	}
#else
	return ENVCAMERA;
#endif // RVC_OS_WIN
}

ErrorCodeEnum CMediaControllerEntity::ChangeSysvar(ErrorCodeEnum op)
{
	switch (op)
	{
	case Error_Succeed:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to No_Error");
		SetCameraSysVar(CAMERA_NO_ERROR);
		GetFunction()->SetUserDefineState(USER_MEDIA_IDLE);
		break;
	case Error_EnvCamera:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Env_Error");
		SetCameraSysVar(CAMERA_ENV_ERROR);
		GetFunction()->SetUserDefineState(USER_MEDIA_ENVERRROR);
		capture_clearsnapshotvideo(m_capture,ENVCAMERA);
		break;
	case Error_OptCamera:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Opt_Error");
		SetCameraSysVar(CAMERA_OPT_ERROR);
		GetFunction()->SetUserDefineState(USER_MEDIA_OPTERROR);
		capture_clearsnapshotvideo(m_capture,OPTCAMERA);
		break;
	case Error_AllCamera:
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Both_Error");
		SetCameraSysVar(CAMERA_BOTH_ERROR);
		GetFunction()->SetUserDefineState(USER_MEDIA_ALLERROR);
		capture_clearsnapshotvideo(m_capture,AlLCAMERA);
		break;
	default:
		break;
	}

	return Error_Succeed;
}

void CMediaControllerEntity::AutoCorrectCameraConfigName(long wait_time)
{
	ErrorCodeEnum Error = Error_Succeed;
	int one_timeout = 400;
	int retry = 0;


#ifdef RVC_OS_WIN
	//检查配置名都成功，不用自动纠正
	Error = CheckConfigCameraName(&conf);
	if (Error == Error_Succeed) {
		return;
	}
#endif // RVC_OS_WIN

	//只针对低柜双屏做自纠正
	if(eDesk2SType != m_eDeviceType){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AutoCorrectCameraConfig failed, DeviceType:%d is not Desk2SType", m_eDeviceType);
		return;
	}

}

//开始销售双录音频采集函数
ErrorCodeEnum CMediaControllerEntity::StartSalesRecordAudioCapture(bool bRemoteRecord, eRvcPCMTransType eType, void* pData)
{
	ErrorCodeEnum Error = Error_Succeed;
	if (NULL == m_salesaudio_capture){
		memset(&m_sales_audio_conf, 0, sizeof(m_sales_audio_conf));
		GetSalesAudioConfig(&m_sales_audio_conf, bRemoteRecord);

		Error = (ErrorCodeEnum)salesaudio_capture_create(&m_sales_audio_conf, &m_salesaudio_capture);
		if (Error_Succeed == Error){
			Error = SetSalesRecordAudioCaptureTransActionData(eType, pData);
		}
	}

	if (Error_Succeed == Error){
		Error = salesrecord_audio_capture_start(m_salesaudio_capture);
		if (Error_Succeed == Error){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sales record audio capture start success.");
		}
		else{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sales record audio capture start failed for param error.");
		}
	}

	return Error;
}

//停止销售双录音频采集函数
ErrorCodeEnum CMediaControllerEntity::StopSalesRecordAudioCapture()
{
	salesrecord_audio_capture_stop(m_salesaudio_capture);
	salesaudio_capture_destroy(m_salesaudio_capture);
	m_salesaudio_capture = NULL;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("set m_salesaudio_capture to null.");
	return Error_Succeed;
}

ErrorCodeEnum CMediaControllerEntity::StartCamera()
{
	if (m_capture == NULL)
	{
		ErrorCodeEnum Error = Error_Succeed;
		conf.ref_env_capture_count = &m_lCaptureEnvCount;
		conf.ref_opt_capture_count = &m_lCaptureOptCount;
		conf.ref_envopt_capture_count = &m_lCaptureEnvOptCount;
#ifdef RVC_OS_WIN
#else
		conf.env_mutex = &m_env_mutex;
		conf.opt_mutex = &m_opt_mutex;
		conf.envopt_mutex = &m_envopt_mutex;
#endif

		Error = (ErrorCodeEnum)capture_create(&conf, &m_capture);
		if (Error == Error_Succeed) 
		{
#ifdef RVC_OS_WIN
#else
			m_capture->audio->paudiocap = m_pAudioCap;
#endif
			Error = capture_start(m_capture);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("capture_start Error code=0x%08x",Error);
			if (Error != Error_Succeed)
			{
				if((Error == Error_AudioIN)||(Error == Error_AudioOut))
				{
					return Error;
				}
				else if (Error == Error_AllCamera)
				{
					capture_destroy(m_capture);
					m_capture = NULL;
					return Error;
				}
				else
				{
					SetAutoBright(Error);
					GetFunction()->SetTimer(1, this, 5000);
					if((Error == Error_OptCamera)&&((ePadtype == m_eDeviceType)||(eMobilePadType == m_eDeviceType)||(eDesk2SType == m_eDeviceType)||(eDesk1SType == m_eDeviceType)||(eDesk2SIntegratedType == m_eDeviceType)))
					{
						return Error_Succeed;
					}
					else
					{
						return Error;
					}
				}	
			}
			else
			{
				SetAutoBright(Error);
				GetFunction()->SetTimer(1, this, 5000);
				return Error_Succeed;
			}
		} 
		else 
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("create capture failed! 0x%08x", Error);
			m_capture = NULL;
			return Error_Unexpect;
		}
		return Error;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_capture == NULL");
		return Error_Unexpect;
	}
}

ErrorCodeEnum CMediaControllerEntity::StartCamera(int nCamera)
{
	if (m_capture == NULL)
	{	
			
		ErrorCodeEnum Error = Error_Succeed;
		Error = capture_create(&conf, m_capture,nCamera);
		if (Error == Error_Succeed) 
		{
			return capture_start(m_capture,nCamera);
		}
		else
		{
			return Error_Hardware;
		}	
	}
	else
	{
		return Error_Unexpect;
	}
}

void CMediaControllerEntity::StartCameraAndTiggerRecord(const char * strSessionId)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start camera");
	ErrorCodeEnum Error = StartCamera();
	if (Error == Error_Succeed)
	{
		SetCameraSysVar(CAMERA_NO_ERROR);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_NO_ERROR");
		m_bStartCamera = TRUE;
		LogEvent(Severity_Middle, EVENT_MOD_BEGIN_RECORD,strSessionId);
	}
	else
	{
		if (Error == Error_EnvCamera)
		{
			SetCameraSysVar(CAMERA_ENV_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_ENV_ERROR");
			m_bStartCamera = TRUE;
			LogEvent(Severity_Middle, EVENT_MOD_BEGIN_RECORD,strSessionId);
		}
		else if (Error == Error_OptCamera)
		{
			SetCameraSysVar(CAMERA_OPT_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_OPT_ERROR");
			m_bStartCamera = TRUE;
			LogEvent(Severity_Middle, EVENT_MOD_BEGIN_RECORD,strSessionId);
		}
		else if (Error == Error_AllCamera)
		{
			SetCameraSysVar(CAMERA_BOTH_ERROR);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to CAMERA_BOTH_ERROR");
			m_nCameraErrorCode = Error_AllCamera;
			m_bStartCamera = FALSE;
			GetFunction()->SetUserDefineState(USER_MEDIA_ALLERROR);
		}
		else
		{
			SetCameraSysVar(Error);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Camera State to Other Error");
			m_nCameraErrorCode = Error;
			m_bStartCamera = FALSE;
		}
	}
}

ErrorCodeEnum CMediaControllerEntity::ReStartCamera(int nCamera)
{
	if (m_capture != NULL)
	{
		if((StopCamera(m_capture,nCamera)==-1))
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReStartCamera,stop camera fail!");
		}
		Sleep(2000);
			
		ErrorCodeEnum Error = Error_Succeed;
		Error = capture_create(&conf, m_capture,nCamera);
		if (Error == Error_Succeed) 
		{
			Error = capture_start(m_capture,nCamera);
			if (Error != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReStartCamera,capture_start fail!");
				capture_destroy(m_capture,nCamera);
				return Error;
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReStartCamera,camera = %d,success!",nCamera);
				return Error_Succeed;
			}
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ReStartCamera,capture_create fail!");
			capture_destroy(m_capture,nCamera);
			return Error;
		}	
	}
	else
	{
		return Error_Unexpect;
	}
}

	
CServerSessionBase *CMediaControllerEntity::OnNewSession(const char* pszRemoteEntityName, const char * pszClass)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s connected class = %s!", pszRemoteEntityName, pszClass);
	return new MediaServiceSession(this);
}

ErrorCodeEnum CMediaControllerEntity::ExternStartCamera()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Extern start camera");
	CSimpleStringA strSessionId;
	CSmartPointer<IEntityFunction> Func = GetFunction();
	Func->GetSysVar("SessionID", strSessionId);
	if (!m_bStartCamera)
	{
		StartCameraAndTiggerRecord((LPCTSTR)strSessionId);
	}
	m_bExternControlCam = FALSE;
	return Error_Succeed;
}


ErrorCodeEnum CMediaControllerEntity::ExternStopCamera()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Extern stop camera");
	if (m_capture) 
	{
		LogEvent(Severity_Middle, EVENT_MOD_END_RECORD,NULL);
		GetFunction()->KillTimer(1);
		capture_stop(m_capture);
		capture_destroy(m_capture);
		m_capture = NULL;
	}
	m_bStartCamera = FALSE;
	m_bExternControlCam = TRUE;
	return Error_Succeed;
}


ErrorCodeEnum CMediaControllerEntity::SaveInnerCamera()
{
	if (strFrontCam.GetLength() <= 1) {
		return Error_Resource;
	}

	if (strstr((LPCTSTR)conf.strVideoEnv,(LPCTSTR)strFrontCam)==NULL)
	{
		CSimpleStringA tmp = strRearCam;
		strRearCam = strFrontCam;
		strFrontCam = tmp;
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] strFrontCam: %s, strRearCam: %s", (LPCSTR)strFrontCam, (LPCSTR)strRearCam);

	CSmartPointer<IEntityFunction> spFunction = GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_Run, spConfig);
	if (Error == Error_Succeed) {
		SpIniMappingTable table;
		table.AddEntryString("Video", "FrontCamera", strFrontCam, "$");
		table.AddEntryString("Video", "RearCamera", strRearCam, "$");
		Error = table.Save(spConfig);
		if (Error != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to save run config.");
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[dbg] failed to open run config.");
	}

	return Error;
}


// 获取高拍仪摄像头（考虑多个高拍仪）
ErrorCodeEnum CMediaControllerEntity::GetHSPCameras(CAutoArray<CSimpleStringA> &HSPCameras)
{
	auto rc = Error_Succeed;

	auto pScannerSetClient = new ScannerService_ClientBase(this);

	if (pScannerSetClient->Connect() != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("连接ScannerSet实体失败");
		pScannerSetClient->SafeDelete();
		pScannerSetClient = NULL;
		rc = Error_DevConnFailed;
	}
	else
	{
		ScannerService_GetOnlineCameras_Req req = {};

		ScannerService_GetOnlineCameras_Ans ans = {};

		rc = pScannerSetClient->GetOnlineCameras(req, ans, 10000);
		if (rc != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ScannerSet 调用 GetOnlineCameras 失败: 0x%x", rc);
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ScannerSet invokes GetOnlineCameras suc.");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Count: %d", ans.devCount);
			if (ans.devCount > 0) {
				for (int i = 0; i < ans.devFriendlyNames.GetCount(); ++i) {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[%d]%s(%d)", i, (LPCTSTR)ans.devFriendlyNames[i], 
						ans.devType[i]);
					CapTypeEnum devType = (CapTypeEnum)ans.devType[i];
					if (devType == CAMTYPE_HSPS)
					{
						HSPCameras.Append(ans.devFriendlyNames, i, 1);
					}
				}
			}
		}

		pScannerSetClient->GetFunction()->CloseSession();
		pScannerSetClient = NULL;
	}

	return rc;
}

ErrorCodeEnum CMediaControllerEntity::HandleSalesRecordPCMAudio(bool bRemoteRecord, const char *pszMessage, audio_frame* pFrame)
{
	ErrorCodeEnum Error = Error_Succeed;
	char strSwiftName[MAX_PATH] = {0};
	if (NULL != pszMessage){
		size_t ulen = strlen(pszMessage);
		char *tmp = new char[ulen+1];
		memset(tmp, 0, ulen + 1);
		memcpy(tmp, pszMessage, ulen);

		char *result[16] = {0};
		auto arr1 = CSimpleStringA2W(tmp).Split('@');
		auto arr2 = CAutoArray<CSimpleStringA>(arr1.GetCount());
		for (int i = 0; i < arr1.GetCount(); ++i){
			arr2[i] = CSimpleStringW2A(arr1[i]);
			result[i] = const_cast<LPSTR>(arr2[i].GetData());
		}
		if (arr1.GetCount() > 4){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("remote record swift number is %s.", result[4]);
			snprintf(strSwiftName, MAX_PATH, "%s", result[4]);
		}
		delete tmp;
		tmp = NULL;
	}

	char strMicroName[MAX_PATH] = {0};
	CSimpleStringA strTempDir;
	if (Error_Succeed == GetFunction()->GetPath("Temp", strTempDir)){
		snprintf(strMicroName, MAX_PATH, "%s/local_micro_%s.pcm", strTempDir.GetData(), strSwiftName);
	}
	else{
		snprintf(strMicroName, MAX_PATH, "local_micro_%s.pcm", strSwiftName);
	}
		
	FILE *pRecord = fopen(strMicroName, "wb+");
	if (NULL != pRecord){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fopen %s success.", strMicroName);
		if (Error_Succeed == StartSalesRecordAudioCapture(bRemoteRecord, eSingleWriteLocal, pRecord)){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin remote sales record audio capture and record local PCM.");
		}
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("fopen %s failed.",strMicroName);
	}

	if (true == bRemoteRecord){
		char strSpeakerName[MAX_PATH] = {0};
		if ("" != strTempDir){
			snprintf(strSpeakerName, MAX_PATH, "%s/remote_speaker_%s.pcm", strTempDir.GetData(), strSwiftName);
		}
		else{
			snprintf(strSpeakerName, MAX_PATH, "remote_speaker_%s.pcm", strSwiftName);
		}
		StartSpeakerAudioRender(0, pFrame, strSpeakerName);
	}
		
	return Error;
}

void CMediaControllerEntity::HandleRemoteRecord(const char *pszMessage)
{
	audio_frame frame;
	frame.bitspersample = 16;
	frame.format = 1;
	frame.framesize = 320;
	frame.nchannels = 1;
	frame.samplespersec = 8000;

	if (true == m_bRecordPCM){
		HandleSalesRecordPCMAudio(true, pszMessage, &frame);
	}
	else{
		if (Error_Succeed == StartSalesRecordAudioCapture(true)){
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin remote sales record audio capture.");
		}
		StartSpeakerAudioRender(0, &frame, NULL);
	}
}


ErrorCodeEnum CMediaControllerEntity::StartSpeakerAudioRender(int iQueue, audio_frame* pFrame, const char* strName)
{
	auto rc = Error_Succeed;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start speak audio render.");

#ifdef RVC_OS_WIN
	if (NULL != m_pAudioRenderObj) {
		if (0 == m_pAudioRenderObj->StartRender(0, pFrame, strName)) {
			m_bHasStartSpeakerRender = true;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start speak audio render success.");
		}
	}
#else
	//m_salesaudio_capture->rvc_audio->bputremote = true;
#endif // RVC_OS_WIN

	return rc;
}


ErrorCodeEnum CMediaControllerEntity::StopSpeakerAudioRender()
{
	auto rc = Error_Succeed;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop speak audio render.");

#ifdef RVC_OS_WIN
	if (NULL != m_pAudioRenderObj) {
		m_pAudioRenderObj->StopRender();
		m_bHasStartSpeakerRender = false;
	}
#else
	//m_salesaudio_capture->rvc_audio->bputremote = false;
	//salesrecord_speaker_audio_capture_stop(m_salesaudio_capture);
#endif // RVC_OS_WIN
	return rc;
}

ErrorCodeEnum CMediaControllerEntity::SetSalesRecordAudioCaptureTransActionData(eRvcPCMTransType eType, void* pData)
{
	auto rc = Error_Param;
	if (NULL != m_salesaudio_capture){
		if (NULL != m_salesaudio_capture->rvc_audio){
			m_salesaudio_capture->rvc_audio->eType = eType;
			m_salesaudio_capture->rvc_audio->pdata = pData;
			rc = Error_Succeed;
		}
	}
	return rc;
}


ErrorCodeEnum CMediaControllerEntity::ConnectAssistChannel()
{
	if (NULL == m_pMediaControllerChannel) {
		m_pMediaControllerChannel = new ChannelMediaControllerClient(this);
	}

	ErrorCodeEnum Error = m_pMediaControllerChannel->Connect();
	if (Error != Error_Succeed) {
		m_pMediaControllerChannel = NULL;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ChannelMediaControllerClient connect fail!");
		return Error;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ChannelMediaControllerClient connect success!");
	}

	if (Error_Succeed == Error)
	{
		ChannelService_BeginState_Sub Sub;
		Error = m_pMediaControllerChannel->BeginState(Sub);
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("BeginState biz channel failed!");
			m_pMediaControllerChannel->GetFunction()->CloseSession();
			m_pMediaControllerChannel = NULL;
			return Error;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("BeginState biz channel success!");
		}
	}

	if (Error_Succeed == Error)
	{
		ChannelService_BeginRecv_Sub Sub;
		Sub.type = ACM_TYPE_DEVICE;
		Error = m_pMediaControllerChannel->BeginRecv(Sub);
		if (Error != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin BeginRecv ACM_TYPE_DEVICE failed!");
			m_pMediaControllerChannel->GetFunction()->CloseSession();
			m_pMediaControllerChannel = NULL;
			return Error;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Begin BeginRecv ACM_TYPE_DEVICE success!");
		}
	}

	return Error;
}



SelfChekerClient::SelfChekerClient( CMediaControllerEntity *pEntity ) : SelfCheckerService_ClientBase(pEntity)
{

}

ChannelMediaControllerClient::ChannelMediaControllerClient( CMediaControllerEntity *pEntity ) : ChannelService_ClientBase(pEntity)
{

}

void ChannelMediaControllerClient::OnMessage(ErrorCodeEnum Error, ChannelService_State_Info &Msg, CSmartPointer<IReleasable> pData)
{
	if (Error == Error_Succeed) 
	{
		CMediaControllerEntity *pEntity = static_cast<CMediaControllerEntity*>(m_pEntityBase);
		if (Msg.state == eChannelState_Idle) 
		{
			if (pEntity->m_bStartCamera)
			{
				if (pEntity->SetAutoBright(pEntity->m_nCameraErrorCode)==false)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SetAutoBright Fail!");
				}
			}
		} 
		else if (Msg.state == eChannelState_Connected) 
		{
			if (pEntity->m_bStartCamera)
			{
				pEntity->SendCameraBright();
			}
		}
	}
}


void ChannelMediaControllerClient::OnMessage( ErrorCodeEnum Error, ChannelService_Packet_Info &Msg, CSmartPointer<IReleasable> pData )
{
	LOG_FUNCTION();
	if (Error == Error_Succeed) 
	{
		CMediaControllerEntity *pEntity = static_cast<CMediaControllerEntity*>(m_pEntityBase);
		pEntity->OnReceivePkt(Msg.sub_type, (const char*)Msg.data.m_pData, Msg.data.m_iLength);
	}
}


void MediaServiceSession::Handle_GetVideoDeviceName(SpReqAnsContext<MediaService_GetVideoDeviceName_Req, MediaService_GetVideoDeviceName_Ans>::Pointer ctx)
{
	CSimpleStringA frontcam = m_pEntity->strFrontCam;
	CSimpleStringA rearcam = m_pEntity->strRearCam;

	if (frontcam.GetLength() > 1 && rearcam.GetLength() > 1)
	{
		ctx->Ans.frontcam = frontcam;
		if (strstr((LPCTSTR)frontcam,";"))
		{
			ctx->Ans.frontcam = frontcam.SubString(0, frontcam.IndexOf(";"));
		}
		ctx->Ans.rearcam = rearcam;
		if (strstr((LPCTSTR)rearcam,";"))
		{
			ctx->Ans.rearcam = rearcam.SubString(0, rearcam.IndexOf(";"));
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get camera1 name:%s",m_pEntity->strFrontCam);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("get camera2 name:%s",m_pEntity->strRearCam);
	}

	ctx->Answer(Error_Succeed);
}

void MediaServiceSession::Handle_StartCamera(SpOnewayCallContext<MediaService_StartCamera_Info>::Pointer ctx)
{
	m_pEntity->ExternStartCamera();
}

void MediaServiceSession::Handle_StopCamera(SpOnewayCallContext<MediaService_StopCamera_Info>::Pointer ctx)
{
	m_pEntity->ExternStopCamera();
}


void MediaServiceSession::Handle_StartEnvCamera(SpReqAnsContext<MediaService_StartEnvCamera_Req, MediaService_StartEnvCamera_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum Error = m_pEntity->StartEnvCamera();
	ctx->Ans.returncod = Error;
	ctx->Answer(Error);
}

void MediaServiceSession::Handle_StopEnvCamera(SpOnewayCallContext<MediaService_StopEnvCamera_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pEntity->StopEnvCamera();
}


void MediaServiceSession::Handle_StartSpeakerRender(SpOnewayCallContext<MediaService_StartSpeakerRender_Info>::Pointer ctx)
{
	LOG_FUNCTION();
}

void MediaServiceSession::Handle_StopSpeakerRender(SpOnewayCallContext<MediaService_StopSpeakerRender_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	if (true == m_pEntity->m_bHasStartSpeakerRender){
		m_pEntity->StopSpeakerAudioRender();
	}
	else{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("speaker audio render already stopped.");
	}
	
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CMediaControllerEntity)
SP_END_ENTITY_MAP()